第3章 数 组
知识要点:
1.数组概述
2.一维数组
3.多维数组
4.不规则数组
学习目标:
通过本章的学习,要求读者掌握一维数组和多维数组的定义、初始化与使用,数组的内
存分配方式,不规则数组的使用。
3.1 数组概述
数组是一组具有相同类型或者类型兼容数据的集合,方便数据的管理和使用,是一种引
用数据类型。
Java语言中数组的使用非常灵活。按照所支持数据维度的不同,数组可以分为一维数
组和多维数组。按照每一维数据的个数是否相同,数组可以分为规则数组和非规则数组(锯
齿数组)。
在数组中有5个重要概念,分别是:
(1)数组的名称(name),又称为数组名,代表一个数组。
(2)数组中的元素(element),数组中的每一个数据,数据在数组中有序排列。
(3)数组的类型(type),数组中每个数据的类型,通常是相同的类型。
(4)数组的索引(index),访问数组中元素的序号,序号的索引位置从0开始。
(5)数组的长度(length),数组中的元素个数,通过数组名.length获取。
例如,现实生活中,一个班级有几十位学生,班级就可以作为学生的数组,班级名作为数
组的名称,而每位学生作为数组中的一个元素,为了更好地管理学生,通常给每位学生分配
一个学号,作为数组的索引,通过学号可以快速地找到对应的学生,班级的总人数作为数组
的长度。
3.2 一维数组
3.2.1 一维数组的声明
类似于变量的声明,使用数组时,也要先声明数据类型和数组的名称。一维数组的声明
格式如下:
数据类型[] 数组名;
·73·
一维数组
或者
数据类型数组名[];
例如:声明整型一维数组a如下:
int[] a;
或者
int a[];
注意:以上两种声明方式没有任何区别。一般推荐使用第一种方式声明数组。从声明
中可知数组的名称是a,数组中元素的类型是int。
数组中可以存放声明中的数据类型或者比声明数据类型小的类型,但是在使用数组中
的元素时,都以声明中的数据类型操作数据。例如,在本例中,int类型或者比int类型小的
数据类型数据(byte,short,char)可以放在该数组中,但是在使用时会自动转型成int类型
后使用。
数组的维度可以简单理解为有几对中括号,例如:一维数组在声明的时候有一对中括
号[],二维数组在声明的时候有两对中括号[][],以此类推。
声明数组时,不能指定数组的长度(即数组中元素的个数),下面的写法是错误的。
例如:
int[3] a;
或者
int a[3];
都是错误的
3.2.2 一维数组的创建
声明数组之后,数组中能存放多少个数据还不能确定,因为Java虚拟机(JVM)还没有
为存储数组中的元素分配内存空间,根据数组内存空间分配的不同方式,可以分为静态创建
方式和动态创建方式两种。
1.一维数组静态创建方式
数组名={元素1,元素2,…,元素n };
也可以在声明数组的同时创建数组。如下所示:
数据类型[] 数组名={元素1,元素2,…,元素n };
数据类型数组名[]={元素1,元素2,…,元素n };
例如:
int[] a;
a=[10,20,30];
或者
·74·
int[] a=[10,20,30];
2.一维数组动态创建方式
数组名=new 数据类型[数组的长度];
也可以在声明数组的同时创建数组。如下所示:
数据类型[] 数组名=new 数据类型[数组的长度];
数据类型数组名[]=new 数据类型[数组的长度];
例如:
int[] a;
a=new int[3];
或者
int a=new int[3];
注意:关键字new是内存分配符,可以动态地为数组开辟存储空间。
分配存储空间大小的公式是:存储数据的类型×数组的长度。例如,一个int类型数据
占4字节空间,则前面创建的数组a占用4×3=12字节的空间。
3.2.3 一维数组的使用
1.一维数组的使用
一维数组元素的访问格式如下:
数组名[索引]
注意:索引是非负的整型常数或表达式,数组的索引从0开始,到数组的长度减1结
束。如果索引小于0或者大于数组的长度减1时,则会出现运行时数组索引越界异常
ArrayIndexOutOfBoundsException。该索引也被称为元素在数组中的偏移位置。
【例3-1】 一维数组的创建和使用。
1 package javaoo;
2 public class Demo3_1 {
3 public static void main(String[] args) {
4 int[] a={10,20,30};
5 System.out.println(a[1]);//20
6 int[] b=new int[3];
7 b[0]=8;
8 System.out.println(b[0]);//8
9 System.out.println(b[1]);//0
10 System.out.println(b[5]);//ArrayIndexOutOfBoundsException
11 }
12 }
运行结果:见单行代码注释。
·75·
代码解释:
第4行静态方式创建数组a,并存储3个int类型元素,分别是10,20,30。
第5行索引是1,表示要访问数组中的第2个元素,数组a中的第2个元素是20。
第6行动态方式创建数组时,系统会默认给数组的所有元素按照数据类型赋初值。本
例中数据类型是int类型,所以该数组中所有的元素初值默认为0。动态创建数组时元素的
默认初值见表3-1。
表3-1 动态创建数组时元素的默认初值
数据类型默 认 值备 注
byte 0
short 0
char \' u0000'
int 0
long 0 实际为0L
float 0.0 实际为0.0F
double 0.0 实际为0.0D
boolean false
引用类型null
第7行为数组b中的第1个元素重新赋值。
第10行无法访问到索引为5的元素,出现数组索引越界异常。
2.一维数组的遍历
一维数组的遍历,就是对一维数组中的所有元素按照相同的规律获取,常采用for循环
方式,其中用“数组名.length”表示一维数组的长度。
【例3-2】 一维数组的遍历。
1 package javaoo;
2 public class Demo3_2 {
3 public static void main(String[] args) {
4 int[] a={10,20,30};
5 //普通for 循环语句的写法
6 for(int i=0;i<a.length;i++) {
7 System.out.print(a[i]+" ");
8 }
9 System.out.println();
10 //增强for 循环语句的写法
11 for(int i:a) {
12 System.out.print(i+" ");
13 }
14 }
15 }
·76·
运行结果:
10 20 30
10 20 30
代码解释:
由于数组的索引从0开始,循环变量也是从0开始,所以可以利用循环变量i作为
索引。第
6行中的条件判断,推荐使用“数组名.length”的形式,而不是固定一个数值,因为“数
组名.length”的形式会随着数组中元素个数的改变而动态变化,使用起来比较灵活。
第11行是增强的for循环语句写法,可以简化for循环操作。
增强的for循环语句格式如下:
for(数据类型变量:集合类型){
循环体语句;
}
说明:集合类型可以是数组,或者是其他集合类型(如ArrayList等)。变量前的数据类
型要和集合中元素的数据类型一致。例如,例中a为int类型的数组,所以第11行变量i前
的数据类型也是int类型。
增强的for循环语句会自动从集合中按顺序1次取1个的方式,把集合中的元素赋值
给变量,并且能够自动判断循环的结束条件是否满足。
3.2.4 一维数组的内存分配
1.JVM 的内部体系结构
Java程序都是在JVM 中运行,JVM 为了运行一个程序,需要在内存中存储很多数据,
如字节码文件、方法的参数、返回值、创建的对象,以及运算的中间结果等。JVM 把这些数
据放在“运行时数据区”中统一管理。JVM 的内部体系结构如图3-1所示。
图3-1 JVM 的内部体系结构
(1)方法区。
方法区中存储class字节码文件、常量、类变量、方法等。当JVM 装载class字节码文件
·77·
时,会从该文件中解析类型信息,并把clas
字节码文件以及类型信息存放在方法区中。
(2)栈。
栈是一种数据结构,其特点是“先进后出”或者“后进先出”。该结构类似于游戏手枪中
的弹夹,最后压入弹夹的子弹会第一个发射出去,而第一颗压入的子弹,会最后一个发射出
去。本书中的栈特指方法栈,当运行方法时,用来存储该方法
JVM会开辟一个方法栈空间,
中局部变量的值。
(3)堆。
相对栈空间,系统为堆内存开辟的空间更大。在堆中主要存储引用类型数据,如数组或
对象等。
(4)PC寄存器。
PC寄存器类似于程序计数器,是在多线程启动时创建的。
下面以例3-1为例,讲解一维数组的内存空间分配,如图3-2所示。
图3-2 一维数组的内存空间分配示意图
解释说明:
第3行中,man()方法是程序运行的入口方法,会开辟一块方法
iJVM为了运行该方法,
栈空间。方法中定义的变量是局部变量(如,本例中的数组名a和b),局部变量的值都保存
在方法栈空间。无论是静态方式,还是动态方式创建的数组,由于数组中数据占用的空间比
较大,都会放在堆空间中保存,并且系统会在堆空间中为数组分配一块连续的空间。
第4行int[]a={10,20,30},通过静态方式创建数组。程序先执行“=”右边的代码,
在堆内存中分配一块连续的空间,用来保存3个int类型数据的值,因为每个int类型的数
据占4字节大小的空间,所以分配的连续空间大小是12字节。这块空间在内存中有一个首
地址,如图3-2中假定首地址为0x2000(内存地址由随机算法自动生成,通常用十六进制数
表示),10 、20 、30分别存储在这块空间中的特定位置上,因为10是数组中的第1个元素,所
以它所在空间的内存偏移位置是0,20是数组中的第2个元素,内存偏移位置是1,以此类
推。“=”为赋值运算符,把首地址赋值给数组名a,因此数组名中保存的是堆内存中的一个
地址,从而建立起栈内存与堆内存之间的联系。
第5行通过“数组名[索引]”的方式访问堆内存中的元素。
第6行int[]b=newint[3],通过动态方式创建数组。动态方式创建类似于静态方式
·78·
创建,不同点是动态创建数组中的元素,由系统按照数据类型赋默认初值,int类型数据的默
认值是0。
第7行改变b[0]的值是8,其他数据的值仍然是默认值0。
第10行访问b[5],因为在堆空间中没有为这个元素分配空间,所以出现数组索引越界
异常。注
意:掌握程序运行时的内存分配,对程序的理解大有益处。
2.数组的复制
数组的复制按照分配内存空间的不同,可以分为浅拷贝和深拷贝。
(1)浅拷贝。
浅拷贝中多个数组名共用同一块堆内存空间。
【例3-3】 一维数组的浅拷贝。
1 package javaoo;
2 public class Demo3_3 {
3 public static void main(String[] args) {
4 int[] a={10,20,30};
5 int[] b=a;
6 a[0]=88;
7 System.out.println(b[0]);//88
8 }
9 }
运行结果:
88
代码解释:
第5行数组名a中保存的堆内存首地址,赋值给了数组名b,因此a和b指向的是同一
块堆内存空间。
第6行修改a[0]的值为88,使用数组名b访问第1个元素时也是88,如图3-3所示。
图3-3 一维数组的浅拷贝示意图
(2)深拷贝。
深拷贝中每个数组在堆内存中有不同的空间。深拷贝的方式有很多种,这里只讲解
·79·
System.arraycopy()方法,其具体定义如下:
System. arraycopy (dataType [ ] srcArray, int srcIndex, dataType [ ] destArray, int
destIndex,int length)
说明:srcArray表示原数组,srcIndex表示原数组中的起始索引位置,destArray表示
目标数组,destIndex表示目标数组中的起始索引位置,length 表示复制的数组长度。使用
此方法复制数组时,length+srcIndex 必须小于或等于srcArray.length,同时length+
destIndex必须小于或等于destArray.length。
【例3-4】 一维数组的深拷贝。
1 package javaoo;
2 public class Demo3_4 {
3 public static void main(String[] args) {
4 int[] a={10,20,30};
5 int[] b=new int[3];
6 System.arraycopy(a, 0, b, 0, a.length);
7 a[0]=88;
8 System.out.println(b[0]);
9 }
10 }
运行结果:
10
代码解释:
第5行动态方式创建数组b,数组中的所有元素都是默认值0。
第6行通过System.arraycopy()方法,把数组a中的数据拷贝到数组b中对应的位置,
即数组b中的元素分别是10,20,30。
第7行只是修改数组a[0]的值,数组b[0]的值不变,如图3-4所示。
图3-4 一维数组的深拷贝示意图
·80·
课堂练习1
1.下列一维数组的声明中错误的是( )。
A.int[]a B.booleana[]
C.doublea[2] D.float[]d
2.数组定义的代码如doublea[]= newdouble[2];下列选项中错误的是( )。
A.该一维数组的长度是3
B.该数组中的元素默认为0.0
C.a[1]=3.0
D.a[0]=1.0
3.下列选项中正确的是( )。
public class ArrayTest {
public static void main(String[] args) {
int f1[] =new int[5];
int f2[] ={ 1, 2, 3, 4 };
f1 =f2;
System.out.println("f1[2] =" +f1[2]);
}
}
A.f1[2]=0 B.f1[2]=3
C.编译错误D.运行无结果
4.下列程序的运行结果是( )。
int index =2;
boolean[] test =new boolean[4];
boolean foo =test[index];
System.out.println("foo =" +foo);
A.foo=0; B.foo= null;
C.foo=true; D.foo=false;
3.3 多维数组
二维及以上维数组称为多维数组。在通常的编程中,二维数组使用得最频繁,因此以二
维数组为例学习多维数组,其他多维数组的操作和二维数组类似。
二维数组和一维数组的使用基本一致,也有声明、创建、初始化和访问几个步骤。二维
数组是一种特殊的一维数组,该一维数组的每个元素又是一维数组。因此,二维数组又称为
数组的数组。
3.3.1 多维数组的声明
二维数组的声明格式如下:
·81·
多维数组
数据类型[ ][ ] 数组名;
或者
数据类型数组名[ ][ ];
或者
数据类型[] 数组名[];
例如:声明整型二维数组a如下:
int[][] a;
或者
int a[][];
或者
int[] a[];
注意:以上3种声明方式没有任何区别。推荐使用第1种方式声明二维数组,对第3
种方式只做了解。从声明中可以知道二维数组的名称为a,数据类型是int。
声明二维数组时,不能指定数组的长度。下面的写法是错误的。
例如:
int[2][3] a;
或者
int a[2][3];
或者
int[2] a[3];
3.3.2 多维数组的创建
多维数组的创建分为静态创建方式和动态创建方式两种。
1.二维数组的静态创建方式
数组名= {{元素1},{元素2},…,{元素n }};
说明:元素1,元素2,…,元素n 都是一维数组。
也可以在声明数组的同时创建数组,如下所示。
数据类型[][] 数组名={{元素1},{元素2},…,{元素n }};
数据类型数组名[][]={{元素1},{元素2},…,{元素n }};
数据类型[] 数组名[]={{元素1},{元素2},…,{元素n }};
例如:
int[][] a;
·82·
a=[[1,2,3],[10,20,30]];
或者
int[][] a=[[1,2,3],[10,20,30]];
2.二维数组的动态创建方式
数组名=new 数据类型[一维长度][二维长度];
也可以在声明数组的同时创建数组,如下所示。
数据类型[][] 数组名=new 数据类型[一维长度][二维长度];
数据类型数组名[][]=new 数据类型[一维长度][二维长度];
数据类型[] 数组名[]=new 数据类型[一维长度][二维长度];
例如:
int[][] a;
a=new int[2][3];
或者
int a=new int[2][3];
注意:该二维数组在内存中的存储空间大小等于“数据类型×一维长度×二维长度”。
例如,int类型数据占4字节空间,则数组a占4×2×3=24字节的空间。
3.3.3 多维数组的使用
1.二维数组的使用
访问二维数组中的元素格式如下:
数组名[索引1][索引2];
说明:索引1和索引2都是非负的整型常数或表达式,索引值从0开始,到对应维度的
长度减1为止。如果索引小于0或者大于对应维度的长度减1时,则会出现数组索引越界
异常ArrayIndexOutOfBoundsException。
【例3-5】 二维数组的创建和使用。
1 package javaoo;
2 public class Demo3_5 {
3 public static void main(String[] args) {
4 int[][] a={{1,2,3},{10,20,30}};
5 System.out.println(a[1][2]);//30
6 int[][] b=new int[2][3];
7 b[0][0]=8;
8 System.out.println(b[0][0]);//8
9 System.out.println(b[1][2]);//0
10 System.out.println(b[0][5]);//ArrayIndexOutOfBoundsException
11 }
·83·
12 }
运行结果:见单行代码注释。
代码解释:
第5行a[1][2]表示访问二维数组中第2个一维数组中的第3个元素。a[1]是{10,20,
30},是一维数组,它的第3个元素是30。
第6行动态方式创建数组时,系统会默认给数组的所有元素按照数据类型赋初值。因
为本例中数据类型是int类型,所以该数组中所有的元素初值默认是0。
第7行给二维数组b中的第1个一维数组中的第1个元素赋值8。
第10行b[0]中没有第6个元素,所以运行时出现异常。
2.二维数组的遍历
二维数组的遍历是按照相同规律对数组中所有元素进行获取的过程,常采用for循环
方式。注意以下两个区别:
数组名.length表示二维数组中的元素个数,即一维数组的个数。
数组名[索引].length表示二维数组中索引值所对应的一维数组的长度。
【例3-6】 二维数组的遍历。
1 package javaoo;
2 public class Demo3_6 {
3 public static void main(String[] args) {
4 int[][] a={{1,2,3},{10,20,30}};
5 //普通for 循环语句的写法
6 for(int i=0;i<a.length;i++) {
7 for(int j=0;j<a[i].length;j++) {
8 System.out.print(a[i][j]+" ");
9 }
10 System.out.println();
11 }
12 //增强for 循环语句的写法
13 for(int[] i:a) {
14 for(int j:i) {
15 System.out.print(j+" ");
16 }
17 System.out.println();
18 }
19 }
20 }
运行结果:
1 2 3
10 20 30
1 2 3
10 20 30
·84·
代码解释
:
第6行a.nth表示二维数组的长度,值是2,a[0]表示{1,2,3}, 因此a[0]lnth的
值
leg.eg
是3,a[1]表示{10,20,30},a[1]lnth的值也是3。a[0][0]表示{1,2,3}中的第1个元素
.eg
值1,类似地,a[1][2]表示{10,20,30}中的第3个元素值30 。
第13~18 行为二维数组增强的for循环写法,因为二维数组中的每个元素都是一维数
组,所以第13 行冒号前用int[]i,又因为i为一维数组,它的每个元素都是1个int值,所以
第14 行冒号前用intj。
注意:对动态方式创建数组的遍历方式同本例。
3.4
多维数组的内存分配
3.
二维数组在内存分配时,也涉及栈内存和堆内存,但是内存分配的情况较一维数组更复
杂。下面以例3-5为例,讲解二维数组的内存空间分配,如图3-5所示。
图3-5 二维数组的内存空间分配示意图
解释说明:
系统在堆内存分配时,为二维数组中不同维度的数据开辟多块内存空间。因为二维数
组中每个元素都是一维数组,所以分配的第一块空间用来保存一维数组的名字,而一维数组
的名字对应的是内存中的1个地址,第二块空间用来保存数组中的数据。
内存地址用十六进制的整数表示,格式是“数组类型@内存地址”,图3-5中给出的是简
略写法。
输出a,得到如“[[I@2f92e0f4”的结果(实际情况下,会有不同)。“[[表(”) 示a是二维数
Ifa(“)
组,“表(”) 示数据类型是整型,“@”后的数据是十六进制数,“”表示十六进制中的15,表(”) 示10,“b”表示11,以此类推。
输出a[0], 得到如“”的结果。“[”表示a[是一维数组,“表(”) 示数据类型
是整型。
[I@28a418fc0] I
·85·
课堂练习2
1.下列二维数组的创建,错误的是( )。
A.double[][]a= newdouble[][];
B.inta[][]= newint[3][];
C.inta[][]= {{1,2},{3,4}};
D.int[][]a= newint[3][4];
2.下面能引起编译器错误的语句是( )。
A.int[]a= {1,2,3,4};
B.inta[][]= {1,2},{3,4};
C.inta[]= newint[4];
D.Stringa[]= {"1","2","3"};
3.下列数组初始化形式正确的是( )。
A.intt1[][]= {{1,2},{3,4},{5,6}};
B.intt2[][]= {1,2,3,4,5,6};
C.intt3[3][2]= {1,2,3,4,5,6};
D.intt4[][];t4= {1,2,3,4,5,6};
3.4 不规则数组
在定义二维数组的时候,组成二维数组的各个一维数组的长度相同,该数组称为规则数
组。如果组成二维数组的一维数组的长度不同,则称之为不规则数组(或锯齿数组),其他多
维数组中出现的不规则数组与二维数组的定义类似。
【例3-7】 不规则二维数组的使用。
1 package javaoo;
2 public class Demo3_7 {
3 public static void main(String[] args) {
4 int[][] a={{1},{2,3},{10,20,30}};
5 int[][] b=new int[3][];
6 b[0]=new int[1];
7 b[1]=new int[2];
8 b[2]=new int[3];
9 a[0][0]=66;
10 b[2][1]=88;
11 for(int i=0;i<a.length;i++) {
12 for(int j=0;j<a[i].length;j++) {
13 System.out.print(a[i][j]+" ");
14 }
15 System.out.println();
16 }
·86·
不规则数组
17 for(int[] i:b) {
18 for(int j:i) {
19 System.out.print(j+" ");
20 }
21 System.out.println();
22 }
23 }
24 }
运行结果:
66
2 3
10 20 30
00
0
0 88 0
代码解释:
第4行静态方式创建不规则数组int[][]a= {{1},{2,3},{10,20,30}};
二维数组a有3个元素,分别是一维数组a[0]是{1},a[1]是{2,3},a[2]是{10,20,30},
3个一维数组的长度不相同。
第5行动态方式创建不规则数组,表示该二维数组中可以包含3个一维数组,并且只为
存储这3个一维数组名分配了空间,默认空间里保存的值都是null。
第6~8行在堆内存中二次分配内存空间,分别为3个一维数组分配了4字节、8字节
及12字节的空间。由于是动态方式创建,因此会按照数据类型int赋初值0。
第9~10行修改二维数组中元素的值。
第11~16行使用普通for循环输出二维数组a的所有元素。
第17~22行使用增强for循环输出二维数组b的所有元素。
注意:静态方式创建数组会一次性为所有元素分配内存空间,而动态方式创建数组时,
会多次分配内存空间。
例3-7不规则二维数组的内存空间分配如图3-6所示。
【例3-8】 编程实现杨辉三角形,输出效果如下所示。
1
1 1 →↑
1 2 1
1 3 3 1
→↑
1 4 6 4 1
提示:假设i表示行,j表示列,该三角形腰上的数都是1,其他位置的数值等于其上一
行相邻两个数之和,公式为:a[i][j]=a[i-1][j-1]+a[i-1][j]。
·87·
图3-6 不规则二维数组的内存空间分配示意图
1 package javaoo;
2 public class Demo3_8 {
3 public static void main(String[] args) {
4 int a[][] =new int[5][];
5 for (int i =0; i <a.length; i++) {
6 a[i] =new int[i +1];
7 for (int j =0; j <a[i].length; j++) {
8 if (j ==0 || i ==j) {
9 a[i][j] =1;
10 } else {
11 a[i][j] =a[i -1][j -1] +a[i -1][j];
12 }
13 System.out.print(a[i][j] +" ");
14 }
15 System.out.println();
16 }
17 }
18 }
代码解释:
第4行inta[][]= newint[5][];使用动态方式创建由5个一维数组组成的二维数
组。用每个一维数组保存三角形的一行数据,但是每个一维数据的组成情况目前未知。
第6行a[i]=newint[i+1];通过循环变量i创建不同长度的一维数组,分别是a[0]=
newint[1],a[1]=newint[2],…,a[4]=newint[5],这时该二维数组是不规则数组。不规
则二维数组的使用是为了更节省内存空间的消耗。
假设第4行使用inta[][]= newint[5][5]创建规则二维数组时,保存所有数据需要
4×5×5=100字节空间,而不规则数组只需要4×1+4×2+4×3+4×4+4×5=60字节
空间,节省了40%的内存空间。
·88·
第8行判断数组中的元素是否在三角形的腰上,条件为j== 0 或i==j,其他元素
的赋值都满足公式a[i][j]=a[i-1][j-1]+a[i-1][j]。
本章小结
本章主要讲述了数组的基本概念;一维数组和二维数组的声明、创建、使用,其中需要重
点掌握数组静态创建方式和动态创建方式的区别;结合内存分配图,方便读者更好地了解数
组内部的运行原理,因为数组是一种引用类型,所以对后续章节中对象的内存分配理解有指
导作用。本章最后讲解了不规则数组的声明、创建、使用。不规则数组满足“按需分配”的要
求,能更好地节省内存空间。
习 题 3
一、单选题
1.下列程序的运行结果是( )。
public class Test {
public static void main(String args[]) {
String foo ="blue";
boolean[] bar =new boolean[1];
if (bar[0]) {
foo ="green";
}
System.out.println("foo =" +foo);
}
}
A.foo= B.foo= blue C.foo= null D.foo= green
2.下列程序的运行结果是( )。
public class Test {
public static void main(String args[]) {
int index =1;
int[] foo =new int[3];
int bar =foo[index];
int baz =bar +index;
System.out.println(" baz =" +baz);
}
}
A.baz=0 B.baz=1 C.baz=2 D.编译错误
3.下列程序的运行结果是( )。
int index;
char[] array ={'x', 'y', 'z'};
·89·
System.out.println(array[index]);
A.x B.y
C.z D.编译错误
4.下列二维数组的声明中,错误的是( )。
A.inta[][]; B.int[][]a;
C.int[]a[]; D.inta[5][6];
5.下列二维数组的创建中,错误的是( )。
A.inta[][]=newint[3][]; B.int[][]a=newint[3][4];
C.inta[][]=newint[1][4]; D.int[][]a=newint[][];
二、简答题
1.简述数组中的5个重要概念。
2.简述创建一维数组的两种方式。
3.简述栈内存和堆内存的区别。
4.如何遍历二维数组?
5.简述不规则数组和规则数组的区别。
三、编程题
1.正序和倒序输出如下数组。
a[]= {1,2,3,4,5}
2.找出如下数组中的最大元素和最小元素。
a[][]={ {3,2,6}, {6,8,2,10}, {5}, {12,3,23} }
3.编写主类,在主方法中定义大小为10×10的二维字符型数组,数组名为y,正反对角
线上存的是'*',其余位置存的是'#';请输出这个数组中的所有元素。
4.编写类,在主方法中定义大小为50的一维整型数组,数组中存放{1,3,5,…,99},
输出这个数组中的所有元素,每输出10个数换行,相邻元素之间用空格隔开。
·90·