面向对象程序设计-Java（第四版）课件 第6章 数组

第6章数组6.1一维数组6.2一维数组引用举例6.3二维数组6.4二维数组的引用求30名学生的成绩的平均成绩。

（1）用变量实现

doubleg1,g2,…,g30,sum,average;

g1=80;g2=85.2;…;g30=78;

sum=g1+g2+….+g30;

average=sum/30.0;

（2）用数组实现

doubleg[]={80,85.2,…,78};

doublesum=0,average;

for(inti=0;i<=29;i++){sum=sum+g[i];}

average=sum/30.0;

6.1一维数组

Java语言中，数组被定义为：

(1)数组是一个对象(object)，属于引用类型，它由一系列具有相同类型的带序号的元素组成。这些元素的序号从0开始编排，并且通过下标操作符[ ]中的数字引用它们。

(2)数组中的每个元素相当于该对象的数据成员变量，数组中的元素可以是任何数据类型，包括基本类型和引用类型。

(3)根据数组中下标的个数(或方括号的对数)可将数组区分为只有一对方括号的一维数组和有两对方括号的二维数组。

只有一个下标的数组称为一维数组，它是数组的基本形式。建立一维数组通常包括声明数组、创建数组对象和初始化数组三步。6.1.1一维数组的声明

一维数组的声明格式如下：类型标识符数组名[]；

或类型标识符[]数组名；

说明：

(1)类型标识符：是指数组元素的数据类型，它可以是Java的基本类型和引用类型。

(2)数组名：是数组对象的引用变量名，这个名称应遵从Java标识符定义规则。

(3)数组的维数：数组的维数是用方括号“[]”的个数来确定的。对于一维数组来说，只需要一对方括号。

例如：intabc[ ];//声明名为abc的一维整型数组

double[ ]example2;/*声明名为example2

的双精度型一维数组*/注意：声明一维数组时，系统只为数组对象的引用变量在内存的变量存储区中分配存储空间，但并未创建具体的数组对象，所以，这个变量的值为null。数组名的内存分配6.1.2创建一维数组对象

创建一维数组对象主要包括三个方面：

（1）为数组对象在对象存储区中分配存储空间；

（2）对数组对象进行初始化；

（3）将新创建的数组对象与已声明的引用数组对象的变量(即数组名)关联起来。

一维数组对象的创建可以通过直接指定数组元素初始值的方式完成，也可以用new操作符完成。

1．直接指定初值的方式创建数组对象

例如：int[]a1={23,–9,38,8,65};

数组元素的初值依次写入赋值号后的一对花括号内，各个元素值间用逗号分隔，给这个数组的所有元素赋上初始值；初始值的个数也就确定了数组的长度。

这条语句声明数组名为a1(a1也称为引用数组对象的变量名，)；数组元素的数据类型为整型(int，占4个字节)，共有5个初始值，故数组元素的个数为5。

例如：int[]a1={23,–9,38,8,65};

该语句为Java分配存储空间提供了所需要的全部信息，系统可为这个数组对象分配5*4=20个字节的连续存储空间。a1数组的值是a1关联的数组对象的首地址，如图所示。a1关联对象示意图数组对象的元素由a1[ ] 引用，经过初始化后，使a1[0] = 23，a1[1] = -9，a1[2] = 38，a1[3] = 8，a1[4] = 65，如图6.3所示。

注意：Java中的数组元素下标从0开始。a1数组的初始化

2．用关键字new创建数组对象

用关键字new创建数组对象，并按照Java提供的数据成员默认初始化原则对数组元素赋初值。用关键字new来创建数组对象有两种方式。

(1)先声明数组，再创建数组对象。这实际上由两条语句构成，格式如下：

类型标识符数组名[]；

数组名=new类型标识符[数组长度]；

其中，第一条语句是数组的声明语句；第二条语句是创建数组对象，并初始化。

注意：两条语句中的数组名、类型标识符必须一致。数组长度通常是整型常量，用以指明数组元素的个数。

例如：inta[];

a=newint[9];

定义a数组对象有9个元素，并按照Java提供的数据成员默认初始化原则进行初始化，如图所示。用new创建数组对象并初始化

(2)在声明数组的同时用new关键字创建数组对象，并初始化。这种初始化实际上是将上面所述的两条语句合并为一条语句。其格式如下：

类型标识符数组名[]=new类型标识符[数组长度]；

或

类型标识符[]数组名=new类型标识符[数组长度]；

例如：int[]a=newint[10];

或inta[]=newint[10];

6.1.3一维数组的引用

一维数组元素的引用格式如下：数组名[数组下标]

其中，数组名是与数组对象关联的引用变量；数组下标是指元素在数组中的位置，数组下标的取值范围是0～(数组长度–1)，下标值可以是整数型常量或整数型变量表达式。

例如，int[ ]a=newint[10];

a[3]=25;（合法）a[3+6]=90;（合法）

a[10]=8；（错误）

下标从0开始到9正好10个元素，不存在下标为10的数组元素a[10]。

6.2一维数组引用举例

6.2.1测定数组的长度

在Java语言中，数组也是一种对象。数组经初始化后就确定了它的长度（数组元素的个数），Java用一个数据成员length来测定数组的长度值。第六章程序位置

【示例程序C6_1.java】数组的声明、初始化和其长度的测定。

public

classC6_1

{public

static

voidmain(Stringarg[])

{int

i;

double

a1[];//[]放在引用变量后面声明

char[]a2;//[]放在引用变量前面声明

a1=new

double[8];//创建a1数组，数组元素个数为8，类型double型

a2=new

char[8];//创建a2数组，数组元素个数为8，类型char型

int

a3[]=new

int[8];//创建a3数组，数组元素个数为8，类型int型

byte[]a4=new

byte[8];//创建a4数组，数组元素个数为8，类型byte型

char

a5[]={'A','B','C','D','E','F','H','I’};

//创建a5数组，直接指定初值

//下面各句测定各数组的长度

System.out.println("a1.length="+a1.length);

System.out.println("a2.length="+a2.length);

System.out.println("a3.length="+a3.length);

System.out.println("a4.length="+a4.length);

System.out.println("a5.length="+a5.length);

//以下各句引用数组中的每一个元素，为各元素赋值

for(i=0;i<8;i++)

{a1[i]=100.0+i;a3[i]=i;

a2[i]=(char)(i+97);//将整型转换为字符型

}

//下面各句打印各数组元素

System.out.println("\ta1\ta2\ta3\ta4\ta5");

System.out.println("\tdouble\tchar\tint\tbyte\tchar");

for(i=0;i<8;i++)

System.out.println("\t"+a1[i]+"\t"+a2[i]+"\t"+

a3[i]+"\t"+a4[i]+"\t"+a5[i]);

}}

运行结果：

6.2.2数组下标的灵活使用

【示例程序C6_2.java】用数组求解Fibonacci数列的前20项，即使用数组下标表达式求解数学上的迭代问题。

public

classC6_2{

public

static

voidmain(String[]args){

int

i;

int

f[]=new

int[20];//创建f数组，使其可存储20个整型数据

f[0]=1;f[1]=1;

for(i=2;i<20;i++)

f[i]=f[i-2]+f[i-1];//数组元素的下标使用循环变量

for(i=0;i<20;i++)

{if(i%5==0)System.out.println("\n");

System.out.print("\t"+f[i]);

}

}//main

}运行结果：

二分查找的比较与下标调整过程二分查找6880mid=()/2+85+mid=()/2lowHigh=数组名.length-1Low=mid+1high=mid-1数据为升序队列

【示例程序C6_3.java】设数组中的数值是由小到大存放的，编写二分查找程序。

classFindSearch

{intbinarySearch(int

arr[],int

searchValue)

{

int

low=0;//low是第一个数组元素的下标

int

high=arr.length-1;//high是最后一个数组元素的下标

int

mid=(low+high)/2;//mid是中间那个数组元素的下标

while(low<=high&&arr[mid]!=searchValue)

{if(arr[mid]<searchValue)

low=mid+1;//要找的数可能在数组的后半部分中

else

high=mid-1;//要找的数可能在数组的前半部分中

mid=(low+high)/2;

}

if(low>high)mid=-1;

return

mid;//mid是数组元素下标，若为-1，则表示不存在要查的元素

}}public

classC6_3

{public

static

voidmain(String[]args)throwsIOException

{Scannersc=newScanner(System.in);//创建Scanner类对象sc

int

i,search,mid;Stringc1;

int

arr[]={2,4,7,18,25,34,56,68,89};

System.out.println("打印原始数据");

for(i=0;i<arr.length;i++)System.out.print(""+arr[i]);

System.out.println("\n");

System.out.println("请输入要查找的整数");

c1=sc.next();//从键盘上读取一个字符串赋给c1

search=Integer.parseInt(c1);//取出字符串转换为整型数赋给search

FindSearchp1=newFindSearch();

mid=p1.binarySearch(arr,search);

if(mid==-1)System.out.println("没找到！");

elseSystem.out.println("所查整数在数组中的位置下标是："+mid);

}}运行结果：

arr247…89arr双向地址传递6.2.3数组名之间的赋值

Java语言允许两个类型相同但数组名不同(指向不同的对象)的数组相互赋值。赋值的结果是两个类型相同的数组名指向同一数组对象。

【示例程序C6_4.java】编程实现两个数组名之间的赋值。

public

classC6_4{

public

static

voidmain(Stringarg[])

{int

i;

int[]a1={2,5,8,25,36};

int

a3[]={90,3,9};

System.out.println("a1.length="+a1.length);

System.out.println("a3.length="+a3.length);

a3=a1;//赋值的结果是a3指向a1指向的数组，

//而a3先前指向的含有3个元素的数组由于没有指向而消失

System.out.print("a1:");

for(i=0;i<a1.length;i++)

System.out.print(""+a1[i]);

System.out.println("\n");

System.out.println("a3.length="+a3.length);

System.out.print("a3:");

for(i=0;i<a3.length;i++)

System.out.print(""+a3[i]);

System.out.println("\n");

}

}运行结果：

a12582536a390396.2.4向成员方法传递数组元素

向成员方法传递数组元素也就是用数组元素作为成员方法的实参，若数组元素的数据是基本数据类型，则数组元素作为成员方法的实参与用变量作为实参一样，是单向值传递。即只能由数组元素传递给形参，程序中对形参的任何修改并不改变数组元素的值。

【示例程序C6_5.java】数组元素作为成员方法的实参(数据是基本数据类型)，在成员方法中改变形参x和y的值，方法调用结束后实参数组元素的值没有改变。

classFf

{intaa(int

x,int

y)//定义方法aa，有两个整型形参x和y

{int

z;x=x+4;y=y+2;z=x*y;

return

z;

}

}

public

classC6_5

{public

static

voidmain(String[]args)

{

int

arr[]={6,8,9};//声明并初始化数组arr

int

len=arr.length,k;Ffp1=newFf();

k=p1.aa(arr[0],arr[1]);//数组元素arr[0]和arr[1]作为方法aa的实参

System.out.println("k="+k);

for(int

i=0;i<len;i++)

System.out.print(""+arr[i]);//循环输出数组元素的值

System.out.println("\n");

}}

运行结果如下：k=100

6896.2.5向成员方法传递数组名

数组名作为成员方法的实参时，是把实参数组对象的起始地址传递给形参数组名，即两个数组名共同引用同一对象。这种参数的传递方式被称为“双向地址传递”。因此，在成员方法中对形参数组名指向的各元素值的修改，都会使实参数组名指向的各元素的值也发生同样的变化。

【示例程序C6_6.java】两个数组相加，将结果存入第二个数组中。

运行结果：classAdd1Class

{voidadd(int

arA[],int

arB[])

{int

i;int

len=arA.length;

for(i=0;i<len;i++)arB[i]=arA[i]+arB[i];

}

}数组名用作实参的“双向地址传递”public

classC6_6

{public

static

voidmain(String[]args)

{int

i;int

arX[]={1,3,7,6};

int

arY[]={78,0,42,5};int

len=arX.length;

Add1Classp1=newAdd1Class();

System.out.println("arX的原始数据");//打印X数组

for(i=0;i<len;i++)System.out.print(""+arX[i]);

System.out.println("\narY的原始数据");//打印Y数组

for(i=0;i<len;i++)System.out.print(""+arY[i]);

p1.add(arX,arY);//p1引用对象的add方法计算两个数组之和

System.out.println("\n再次输出arX");//再次打印X数组

for(i=0;i<len;i++)System.out.print(""+arX[i]);

System.out.println("\n再次输出arY");//再次打印Y数组

for(i=0;i<len;i++)System.out.print(""+arY[i]);

System.out.println("\n");

}

}

【示例程序C6_7.java】有s1和s2两个一维数组，s1数组中存放8名学生的成绩，s2数组中存放5名学生的成绩，分别求出这两组学生的平均成绩。

public

classC6_7

{static

doubleaverage(double

ascore[])

{double

aaver=0;

for(int

i=0;i<ascore.length;i++)aaver=aaver+ascore[i];

aaver=aaver/ascore.length;

return

aaver;

}

ascores1905686.5879967.565807090879967s2

public

static

voidmain(Stringarg[])

{double

aver1,aver2;

double

s1[]={90,56,86.5,87,99,67.5,65,80};

double

s2[]={70,90,87,99,67};

System.out.println("s1.length="+s1.length);

aver1=average(s1);//数组名s1作为average成员方法的实参

System.out.println("aver1="+aver1);

System.out.println("s2.length="+s2.length);

aver2=average(s2);//数组名s2作为average成员方法的实参

System.out.println("aver2="+aver2);

}

}

运行结果：程序中，尽管两个数组对象的长度不同(分别为8和5)，但其数据类型相同，因此，可以作为同一个成员方法(计算平均成绩)的实参。6.2.6数组元素排序

1.冒泡排序

冒泡排序是从后向前对相邻的两个数组元素进行比较，若后面元素的值小于前面元素的值，则让这两个元素交换位置；否则，不进行交换。依次进行下去，第一趟排序可将数组中值最小的元素移至下标为0的位置。对于有n个元素的数组，循环执行n-1趟扫描便可完成排序。当然，也可以从前向后对相邻的两个数组元素进行比较，但此时是将大数向后移。与小者前移的冒泡法相对应，可将这种大者后移的排序称为下沉法。

冒泡排序

用冒泡法对6个数据进行排序的两趟扫描中比较与交换的过程运行结果：

【示例程序C6_8.java】用冒泡法对8个数从小到大进行排序。

importjava.util.Scanner;

classSortClass//类定义开始

{

voidsort(int

arr[])//开始定义冒泡排序方法sort

{

int

i,k,temp;

int

len=arr.length;

for(i=0;i<len-1;i++)

for(k=len-1;k>i;k--)

if(arr[k]<arr[k-1])

{

temp=arr[k-1];arr[k-1]=arr[k];arr[k]=temp;

}//if块结束，同时使内循环for(k…)和外循环for(i…)结束

}//sort方法结束

}//类SortClass定义结束public

classC6_8

{public

static

voidmain(String[]args)throwsIOException

{//Scanner类是一个简单的文本扫描器类，可以从键盘读入数据

Scannersc=newScanner(System.in);//创建Scanner类对象sc

int

i;Stringc1;int

arr[]=new

int[8];

int

len=arr.length;

System.out.println("请从键盘输入8个整数，一行只输入一个数"

);

for(i=0;i<len;i++)

{c1=sc.next();//从键盘上读取一个字符串赋给c1

arr[i]=Integer.parseInt(c1);//将字符串类型c1转换成整数类型

}

System.out.print("原始数据:");

for(i=0;i<len;i++)System.out.print(""+arr[i]);//打印原始数据

System.out.println("\n");SortClassp1=newSortClass();

p1.sort(arr);//实参为数组名

System.out.println("冒泡法排序的结果：");

for(i=0;i<len;i++)System.out.print(""+arr[i]);

System.out.println("\n");}}

2.选择法排序

它的基本思想是首先从待排序的n个数中找出最小的一个与arr1[0] 对换；再将arr1[1] 到arr1[n] 中的最小数与arr1[1] 对换，依此类推。每比较一轮，找出待排序数中最小的一个数进行交换，共进行n - 1次交换便可完成排序。选择法排序的交换过程i=0j=1k=0k=1j=2k=2j=3j=4k=4j=5j=6j=7i=1k=1j=2j=7k=7

【示例程序C6_9.java】选择法排序。

classSelectSort

{static

voidsort(int

arr1[])//成员方法的形参是数组

{int

i,j,k,t;int

len=arr1.length;

for(i=0;i<len-1;i++)//外循环开始

{k=i;

for(j=i+1;j<len;j++)

if(arr1[j]<arr1[k])k=j;//内循环只用k记录最小值的下标

if(k>i)

{t=arr1[i];//在外循环实施交换，可减少交换次数

arr1[i]=arr1[k];arr1[k]=t;

}//if(k>i)结束

}//外循环for(i…)结束

}//成员方法sort定义毕

}public

classC6_9extendsSelectSort

{public

static

voidmain(String[]args)

{int

arr[]={78,70,2,5,-98,7,10,-1};

int

len=arr.length;

SelectSort.sort(arr);//数组名作为成员方法的实参

System.out.print("选择法排序的结果：");

System.out.println("length="+arr.length);

//数组arr的值已在方法调用中被改变了

for(int

i=0;i<len;i++)

System.out.print(""+arr[i]);

System.out.println("\n");

}

}

运行结果：

选择法排序的结果：-98-12571070786.2.7对象数组

学生成绩表这种数据结构在过去的结构化程序设计中被称为记录或结构体，而在面向对象的程序设计中把每一个学生看做一个对象。学生成绩表就是由多个对象组成的。学 生 成 绩 表

如果一个类有若干个对象，可以把这一系列具有相同类型的对象用一个数组来存放。这种数组称为对象数组。数组名的值是第一个元素的首地址。每一个元素的值是引用对象的首地址。

【示例程序C6_10.java】设有若干名学生，每个学生有姓名、性别和成绩三个属性，要求将每个学生作为一个对象，建立获取对象名字的成员方法getName和获取对象性别的成员方法getSex，以及输出对象的全部数据成员的成员方法studPrint。classStudent

{privateStringname;private

char

sex;

private

double

score;

Student(Stringcname,char

csex,double

cscore)

{name=cname;sex=csex;

score=cscore;

}

StringgetName(){return

name;}

chargetSex(){return

sex;}

voidstudPrint(){

System.out.println("Name:"+name+

"\tSex:"+sex+"\tScore:"+score);

}

}

public

classC6_10

{public

static

voidmain(String[]args)

{Stringmname;char

msex;int

len;

//声明对象数组，用new为每一个对象分配存储空间

Student[]st1=newStudent[3];

st1[0]=newStudent("li",'F',89);

st1[1]=newStudent("he",'M',90);

st1[2]=newStudent("zhang",'M',78);len=3;

//对象数组元素的引用

for(int

i=0;i<len;i++)st1[i].studPrint();

mname=st1[1].getName();msex=st1[1].getSex();

System.out.println("Name1:"+mname+"\tSex:"+msex);

}

}运行结果：对象数组st1的内存分配

6.3二维数组

许多数据，从逻辑上看是由若干行、若干列组成的。例如，矩阵、行列式、二维表格等。为适应存放这样一类数据，人们设计出了一种如图所示的数据结构——二维数组。矩阵二维数组Java中只有一维数组，不存在称为“二维数组”的明确结构。二维数组实际上看成是其每个数组元素是一个一维数组的一维数组。

二维数组在Java中的实现6.3.1二维数组的声明

声明二维数组格式如下：

类型说明符数组名[][]；或类型说明符[][]数组名；

例如，声明数组名为arr二维整型数组：

intarr[][];或

int[][]arr;

其中：类型说明符可以是Java的基本类型和引用类型；数组名遵循标识符命名规则给出的一个标识符。

注意：声明二维数组时，系统只为二维数组对象的引用变量在内存的变量存储区中分配存储空间，但并未创建具体的数组对象，所以，这个变量的值为null。

行列6.3.2创建二维数组对象

创建二维数组对象主要包括三个方面：

（1）为数组对象在对象存储区中分配存储空间；

（2）对数组对象进行初始化；

（3）将新创建的数组对象与已声明的引用数组对象的变量(即数组名)关联起来。

二维数组对象的创建可以通过直接指定数组元素初始值的方式完成，也可以用new操作符完成。

1．用new操作符创建二维数组对象

用new操作符来创建数组对象，并根据Java提供的数据成员默认初始化原则，对数组元素赋初值。用new操作符创建数组对象有两种方式：

(1)先声明数组，再创建数组对象。在数组已经声明以后，可用下述两种格式中的任意一种来初始化二维数组。

数组名=new类型说明符[数组长度][]；

或

数组名=new类型说明符[数组长度][数组长度]；行列其中，对数组名、类型说明符和数组长度的要求与一维数组一致。

例如：intarra[][];//声明二维数组

arra=newint[3][4]；/*创建二维数组对象，初始化二维数组*/

上述两条语句声明并创建了一个3行4列的arra数组。也就是说arra数组有3个元素，而每一个元素又都是长度为4的一维数组，实际上共有12个元素。

arra=newint[3][4]；相当于下述4条语句：

arra=newint[3][ ]； //创建一个有3个元素的数组，且每个元素也是一个数组

arra[0]=newint[4]； //创建arra[0]元素的数组，它有4个元素

arra[1]=newint[4]； //创建arra[1]元素的数组，它有4个元素

arra[2]=newint[4]； //创建arra[2]元素的数组，它有4个元素

也等价于：

arra=newint[3][ ];

for(inti=0;i<3;i++){arra[i]=newint[4]；}

在初始化二维数组时也可以只指定数组的行数而不给出数组的列数，每一行的长度由二维数组引用时决定。但是，不能只指定列数而不指定行数。

(2)在声明数组时创建数组对象。其格式如下：

类型说明符[][]数组名=new类型说明符[数组长度][ ]；

或

类型说明符数组名[][]=new类型说明符[数组长度][数组长度]；

例如：

int[][]arr=newint[4][];

intarr[][]=newint[4][3];

不指定行数而指定列数是错误的。

例如：int[][]arr=newint[ ][4];行列

2．直接指定初值的方式创建二维数组对象

用直接指定初值的方式创建二维数组对象，是在数组声明的同时创建数组对象。将数组元素的初值依次写入赋值号后的一对花括号内的花括号内。例如：

int[][]arr1={{3,-9,6},{8,0,1},{11,9,8}};

声明并创建了二维数组对象，arr1数组有3个元素，每个元素又都是有3个元素的一维数组。

用指定初值的方式创建数组对象时，各子数组元素的个数可以不同。例如：

int[][]arr1={{3,-9},{8,0,1},{10,11,9,8}};等价于：int[][]arr1=newint[3][ ];intarr1[0]={3,-9};intarr1[1]={8,0,1};intarr1[2]={10,11,9,8};

6.4二维数组的引用

6.4.1测定数组的长度及数组赋值

“数组名.length”的形式测定的是二维数组的行数，使用“数组名[i].length”的形式测定的是该行的列数。

例如，若有如下的初始化语句：

int[][]arr1={{3,-9},{8,0,1},{10,11,9,8}};

则arr1.length的返回值是3，表示arr1数组有3行或3个一维数组元素。而arr1[2].length的返回值是4，表示arr1[2]的长度为4。

【示例程序C6_11.java】在程序中测定数组的长度。

public

classC6_11

{public

static

voidmain(Stringarg[])

{

int

i,j;

int

len1[]=new

int[2];

int

len2[]=new

int[2];

int[][]a1={{1,4,8,9},{3,2,2}};

int

a2[][]={{90,3},{9,12}};

System.out.println("a1.length="+a1.length);

for(i=0;i<2;i++)

{len1[i]=a1[i].length;//将a1数组的元素i的长度赋给len1[i]

System.out.println("a1[].length="+len1[i]);

}

for(i=0;i<2;i++)

{for(j=0;j<len1[i];j++)System.out.print(""+a1[i][j]);

System.out.println("\n");

}

System.out.println("a2.length="+a2.length);

for(i=0;i<2;i++)

{len2[i]=a2[i].length;//将a2数组的元素i的长度赋给len2[i]

System.out.println("a2[].length="+len2[i]);

}

//打印a2数组对象的值

for(i=0;i<2;i++)

{for(j=0;j<len2[i];j++)System.out.print(""+a2[i][j]);

System.out.println("\n");

}

a2=a1;//将a1数组赋给a2，说明a2指向a1指向的数组对象

System.out.println("a1.length="+a1.length);

for(i=0;i<2;i++)

{len1[i]=a1[i].length;//将a1数组的元素i的长度赋给len1[i]

System.out.println("a1[].length="+len1[i]);

}

//打印a1数组的对象的值

for(i=0;i<2;i++)

{for(j=0;j<len1[i];j++)System.out.print(""+a1[i][j]);

System.out.println("\n");

}

System.out.println("a2.length="+a2.length);

for(i=0;i<2;i++)

{len2[i]=a2[i].length;//将a2数组的元素i的长度赋给len2[i]

System.out.println("a2[].length="+len2[i]);

}

//打印a2数组的对象的值

for(i=0;i<2;i++)

{for(j=0;j<len2[i];j++)System.out.print(""+a2[i][j]);

System.out.println("\n");

}

System.