数组.docx
《数组.docx》由会员分享，可在线阅读，更多相关《数组.docx（21页珍藏版）》请在冰豆网上搜索。
数组
第五章：
数组
学习目标
⏹数组的声明
⏹创建数组
⏹多维数据（数组的数组）
⏹数组的界限
⏹数组的拷贝
数组的描述
数组是我们接触的第一个容器，数组是固定空间的容器。
一但定义好大小，将不能改变。
由于Java中的数据类型分为两种：
基本类型和引用类型。
所以数组也有两种类型的：
基本类型的数组和引用类型的数组（数组的数组也是引用类型的数组）
数组声明
语法：
[];
或
[];
说明：
目前可以用private，public或着默认的修饰，private是封装的访问权限。
可以是任何原始类型（基本类型）或其它类（引用类型）。
：
任何合法的标识符。
它代表所声明属性的名称。
举例：
chars［］;
Pointp;//wherepointisaclass
在Java编程语言中，无论数组元素由原始类型构成，还是由类构成，数组都是一个对象。
声明不能创建对象本身，而创建的是一个引用，该引用可被用来引用数组。
数组元素使用的实际存储器可由new语句或数组初始化软件动态分配。
上述这种将方括号置于变量名之后的声明数组的格式，是用于C、C++和Java编程语言的标准格式。
这种格式会使声明的格式复杂难懂，因而，Java编程语言允许一种替代的格式，该格式中的方括号位于变量名的左边：
char［］s;
Point［］p;
这样的结果是，你可以认为类型部分在左，而变量名在右。
上述两种格式并存，你可选择一种你习惯的方式。
数组声明不指出数组的实际大小。
注意：
当数组声明的方括号在左边时，该方括号可应用于所有位于其右的变量。
char［］s1，s2;//s1，s2都是字符数组。
chars1［］，s2;//s1是字符数组，s2是字符。
创建数组
语法：
=new[];
或
=new[]{};
说明：
：
任何合法的标识符。
它代表所声明属性的名称。
：
可以是任何原始类型（基本类型）或其它类（引用类型）。
:
一个整数值，数组的大小
用来指示单个数组元素的下标必须总是从0开始，并保持在合法范围之内－－大于或等于0，并小于数组长度。
任何访问在上述界限之外的数组元素的企图都会引起运行时出错。
publicint[]createIntArray（）{
int[]k=null;
k=newint[5];
for（inti=0;ik[i]=i+1;
returnk;
}
你可以象创建对象一样，使用关键字new创建一个数组。
k=newint5;
创建了一个5个int值元素的数组。
内存中数组初始化情形如下：
对于应用类型元素的数组，示例如下：
publicPoint[]createArray（）{
Point[]p=null;
p=newPoint[5];
for（inti=0;ip[i]=newPoint（i,i+1）;
returnp;
}
数组在内存中的映像则如下：
当创建一个数组时，每个元素都被初始化。
在上述int数组k的例子中，每个值都被初始化为0；在数组p的例子中,每个值都被初始化为null，表明它还未引用一个Point对象。
在经过赋值p0=newPoint（i,i+1）之后，数组的第一个元素引用为实际Point对象。
Java编程语言允许使用下列形式快速创建数组:
Stringnames=
“Georgianna”,
“Jen”,
“Simon”,
;
其结果与下列代码等同：
Stringnames;
names=newString3;
names0=“Georgianna”;
names1=“Jen”;
names2=“Simon”;
这种”速记”法可用在任何元素类型。
例如：
MyDateDates=
newMyDate（22,7,1964）,
newMyDate（1,1,2000）,
newMyDate（22,12,1964）
;
适当类型的常数值也可被使用：
Colorpalette=
Color.blue,
Color.red,
Color.white
;
例1
publicclassTestArray1{
publicstaticvoidmain（String[]args）{
//声明并初始化一个数组
int[]num=newint[40];
//记录数组下标
intk=0;
//循环找素数
for（inti=2;i<=100;i++）{
intj=2;
for（;jif（i%j==0）
break;
}
if（j==i）//表示是素数
{
num[k++]=i;
}
}
//输出所有素数，5个一行
for（inti=0;i//如果是小于10的数，多输出个空格，整齐
if（num[i]<10）
System.out.print（num[i]+""）;
else
System.out.print（num[i]+""）;
//够5个数换行
if（（i+1）%5==0）
System.out.println（）;
}
}
}
结果如下：
例2
把一个班的名字（String类型，引用类型）保存起来，并进行输出。
publicclassTestStudents{
publicstaticvoidmain（String[]args）{
//定义3个空间大小的数组
String[]stu=newString[3];
//数组是通过下标来赋值，下标从0开始
stu[0]="java";
stu[1]="c++";
stu[2]="c#";
//下面的赋值将产生异常
stu[3]="j2me";
//输出数据
for（inti=0;iSystem.out.println（stu[i]）;
}
}
运行的结果如下：
如果把stu[3]="j2me";这句去掉，运行正常，结果如下：
例3
保存1到100之间的素数（除了1和它本身不能被其他整数整除的数）。
publicclassTestArray3{
publicstaticvoidmain（String[]args）{
//声明并初始化一个数组
int[]num=newint[40];
//记录数组下标
intk=0;
//循环找素数
for（inti=2;i<=100;i++）{
intj=2;
for（;jif（i%j==0）
break;
}
if（j==i）{//表示是素数
num[k++]=i;
}
}
//输出所有素数，5个一行
for（inti=0;i//如果是小于10的数，多输出个空格，整齐
if（num[i]<10）
System.out.print（num[i]+""）;
else
System.out.print（num[i]+""）;
//够5个数换行
if（（i+1）%5==0）
System.out.println（）;
}
}
}
运行结果如下：
多维数组
Java编程语言没有象其它语言那样提供多维数组。
因为一个数组可被声明为具有任何基础类型，所以你可以创建数组的数组（和数组的数组的数组，等等）。
一个二维数组（JAVA中没有二维数组的概念，二维数组其实就是数组的数组）如下例所示：
inttwoDim[][]=newint[4][];
twoDim[0]=newint[5];
twoDim[1]=newint[5];
首次调用new而创建的对象是一个数组，它包含4个元素，每个元素对类型arrayofint的元素都是一个null引用并且必须将数组的每个元素分别初始化。
注意：
尽管声明的格式允许方括号在变量名左边或者右边，但此种灵活性不适用于数组句法的其它方面。
例如:
newint4是非法的。
因为这种对每个元素的分别初始化，所以有可能创建非矩形数组的数组。
也就是说，twoDim的元素可按如下方式初始化：
twoDim0=newint2
twoDim1=newint4;
twoDim2=newint6;
twoDim3=newint8;
由于此种初始化的方法烦琐乏味，而且矩形数组的数组是最通用的形式，因而产生了一种”速记”方法来创建二维数组。
例如：
inttwoDim=newint45;
可被用来创建一个每个数组有5个整数类型的4个数组的数组。
数组界限
在Java编程语言中，所有数组的下标都从0开始。
一个数组中元素的数量存储在length属性中;这个值被用来检查所有运行时访问的界限。
如果发生了一个越出界限的访问，那么运行时的报错也就出现了。
使用length属性的例子如下：
intlist=newint10;
for（inti=0;iSystem.out.println（listi）;
}
使用length属性使得程序的维护变得更简单。
例4
存放java班，c++班，j2me班，嵌入式班四个班学生的名字，并打印出来。
publicclassTestFourClass{
publicstaticvoidmain（String[]args）{
//声明4个空间大小，类型是String数组的数组
String[][]stu=newString[4][];
//初始化java班的6个人
stu[0]=newString[6];
for（inti=0;istu[0][i]="java"+（i+1）;
//初始化c++班的3个人
stu[1]=newString[3];
for（inti=0;istu[1][i]="c++"+（i+1）;
//初始化j2me班的5个人
stu[2]=newString[5];
for（inti=0;istu[2][i]="j2me"+（i+1）;
//初始化潜入式班的4个人
stu[3]=newString[4];
for（inti=0;istu[3][i]="嵌入式"+（i+1）;
//打印各个班级的名单
for（inti=0;iswitch（i）{
case0:
System.out.println（"java班：
"）;
break;
case1:
System.out.println（"c++班：
"）;
break;
case2:
System.out.println（"j2me班：
"）;
break;
case3:
System.out.println（"嵌入式班：
"）;
}
System.out.print（""）;
for（intj=0;jSystem.out.print（stu[i][j]+""）;
}
System.out.println（）;
}
}
}
运行的结果如下：
拷贝数组
数组一旦创建后，其大小不可调整。
然而，你可使用相同的引用变量来引用一个全新的数组：
intmyArray=newint6;
myArray=newint10;
在这种情况下，第一个数组被丢弃，除非对它的其它引用保留在其它地方。
Java编程语言在System类中提供了一种特殊方法拷贝数组，该方法被称作arraycopy（）。
例如，araycopy可作如下使用：
intmyArray[]={1,2,3,4,5,6};//原始数组
inthold[]={10,9,8,7,6,5,4,3,2,1};//新的更大的数组
System.arraycopy（myArray,0,hold,0,myArray.length）;//从没有Array拷贝所有元素到hold，从下标0开始
这时，数组hold有如下内容：
1,2,3,4,5,6,4,3,2,1。
注意：
如果数组保存的是基本类型的话直接把值拷贝过来。
如果数组存放的是引用类型（类类型，数组类型（多维数组的拷贝）等），那么拷贝的是引用类型的地址，请看下面的例子：
例5
classAA{
inti;
publicAA（intii）{
i=ii;
}
}
publicclassTestArrayCopy{
publicstaticvoidmain（String[]args）{
//声明数组并初始化，源数组
AAstr1[]=newAA[]{newAA
（1）,newAA
（2）,newAA（3）,newAA（4）};
//拷贝的目的数组
AAstr2[]=newAA[str1.length];
//完全拷贝,array方法参数的介绍看api
System.arraycopy（str1,0,str2,0,str1.length）;
//改变目的数组
str2[1].i=5;
//打印原始数组，如果没有改变说明是两个数组
for（inti=0;iSystem.out.print（str1[i].i+""）;
}
}
}
输出的结果如下：
显然，数组发生了改变，也就是经过拷贝操作后，原始的数组和新拷贝的数组没有分离，因为所拷贝的将是元素的引用。
对于多维数组，由于数组本身是引用类型，所以其拷贝特性与引用类型数组相同。
例6
publicclassTestMutipleDemensionArrayCopy{
publicstaticvoidmain（String[]args）{
//定义数组的数组
int[][]source=newint[5][];
//定义目的数组
int[][]target1=newint[5][];
int[][]target2=newint[5][];
//给源数组赋值
for（inti=0;i<5;i++）{
source[i]=newint[i+1];
//inttemp=i;
for（intj=0;jsource[i][j]=j+1;
}
//打印源数组的数据
System.out.println（"-------------源数据-------------"）;
for（inti=0;ifor（intj=0;jSystem.out.print（source[i][j]+""）;
System.out.println（）;
}
//数组的拷贝（浅拷贝）
System.arraycopy（source,0,target1,0,source.length）;
//改变目的1数组的值
target1[1][0]=100;
//打印源数组的信息,可以看到值改变，说明没有深拷贝
System.out.println（"-----------浅拷贝后输出-----------"）;
for（inti=0;ifor（intj=0;jSystem.out.print（source[i][j]+""）;
System.out.println（）;
}
//数组的深拷贝，先拷贝”第一维“的
System.arraycopy（source,0,target2,0,source.length）;
//再深拷贝
for（inti=0;i<5;i++）{
target2[i]=newint[i+1];
System.arraycopy（source[i],0,target2[i],0,i+1）;
}
//改变目的2数组的数据
target2[1][0]=999;
//打印源数组的信息，可以看到值没有改变，说明是深拷贝
System.out.println（"-----------深拷贝后输出未把100改成999-----------"）;
for（inti=0;ifor（intj=0;jSystem.out.print（source[i][j]+""）;
System.out.println（）;
}
}
}
输出的结果如下：
内容总结
⏹数组是某种数据类型的集合
⏹数组使用new操作符初始化
⏹数组长度具有不可变性
⏹数组初始化后其每个元素得到缺省值
⏹可以使用System.arraycopy方法对数组进行拷贝，数组拷贝时对其元素进行浅拷贝，对于引用类型元素将只按照引用方式拷贝。
独立实践
1.基本数组的使用
1）创建一个称作BasicArray的类，在...main（）方法中声明两个变量，一个是thisArray，另一个是thatArray，它们应属类型arrayofint。
2）创建一个数组，它有10个int值，范围从1至10。
分配这个第三数组的引用给变量thisArray。
3）使用for（）循环打印thisArray的所有值。
如何控制循环的次数？
4）编译并运行程序。
多少值被打印？
这些值是什么？
5）对每个thisArray的元素，建立它的值为索引值的阶乘。
打印数组的值。
6）编译并运行程序。
7）分配thisArray的引用给变量thatArray。
打印thatArray的所有元素。
8）编译并运行程序。
tyatArray的多少值被显示？
这些值是什么？
它们来自何处。
9）修改thisArray的某些元素，打印thatArray的值。
10）编译并运行程序；在thatArray的值中，你注意到了什么？
11）创建一个有20个int值的数组。
分配新数组的引用给变量thatArray，打印thatArray的值。
12）编译并运行程序。
每个数组有多少值被显示?
这些值是什么？
13）拷贝thisArray的值给thatArray。
你将使用什么方法调用?
你将如何限制拷贝元素的数量?
thatArray的元素10至19有什么变化？
14）打印thatArray的值。
15）编译并运行程序。
你所显示的值都是正确的吗？
如果不是，你知道有那些内容理解得不对吗？
16）改变thatArray的某些值；打印thisArray和thatArray。
17）编译并运行程序。
这些值是你所期待的吗？
2，数组的数组
1）创建一个称作Array2D的类，在main（）方法中声明一个称作twoD的变量，它应属类型arrayofarrayofint。
2）创建一个元素类型为int的数组，该数组应包括4个元素并被赋值到变量twoD的elements0。
3）编写两个嵌套for（）循环语句以打印twoD的全部值。
以矩阵的格式安排输出（可采用System.out.print（）方法）。
4）编译并运行程序。
你应该能发现此时出现了运行错误（空指针异常），这是因为twoD的elements1至3未被初始化。
5）分别创建包括5个、6个和7个元素的int数组，将这些数组的引用分别赋予twoD的elements1，2和3；确认完成上述操作的代码是在第3步所描述的嵌套for（）循环之前插入的。
6）编译并运行程序。
这次你应该看到一个零值的非矩形布局。
7）赋予twoD数组的每个元素一个明显的非零值（提示：
使用Math.random（）以获得随机值）。
8）声明一个属类型arrayofint的称作oneD的变量。
然后,创建一个包括4个元素的int数组。
将该数组的引用分别赋予数组arraytwoD和oneD的第一个元素。
赋值后，打印oneD和twoD数组。
9）编译并运行程序。
请注意通过打印oneD的值而显示的单个数组与twoD数组的元素是相同的。
升级会员 