JAVA数组与字符串详解.docx
《JAVA数组与字符串详解.docx》由会员分享，可在线阅读，更多相关《JAVA数组与字符串详解.docx（28页珍藏版）》请在冰豆网上搜索。
JAVA数组与字符串详解
第5章数组与字符串
我们在前面学习的整形、字符型等都是基本数据类型，通过一个变量表示一个数据，这种变量称为简单变量。
在实际应用中，经常需要处理具有相同性质的一批数据。
例如要处理100个学生的考试成绩，如果要使用简单变量，将需要100个变量，极不方便。
为此，在Java中，除简单变量外，还引进了数组，即用一个变量表示一组相同性质的数据。
数组必须先经过声明和初始化后才能使用。
5.1一维数组
数组是用一个变量名表示一组数据，每个数据称为数组元素，各元素通过下标来区分。
如果用一个下标就能确定数组中的不同元素，这种数组称为一维数组，否则称为多维数组。
5.1.1一维数组的声明
声明一个数组就是要确定数组名、数组的维数和数组元素的数据类型。
一维数组声明的格式为：
类型标识符数组名【】
或
类型标识符【】数组名
类型标识符指定每个元素的数据类型，如int表明数组中的每个元素都是整型数。
说明：
（1）数组名的命名方法同简单变量，可以是任意合法的标识符。
取名是最好符合“见名知意”的原则。
（2）类型标识符可以是任意的基本类型，如int、long、float和double，也可以是类或接口。
例如，要表示学生的成绩（整数），可以声明元素的数据类型为整数的数组score，其声明如下：
intscore【】
该声明表示数组的名字为score，每个元素为整型数。
要表示学生的体重（浮点数），可以声明元素的数据类型为float的数组weight，其声明如下：
float【】weight
5.1.2一维数组的初始化
声明一个数组仅为数组指定了数组名和元素的数据类型，并未指定数组的元素个数，系统无法为数组分配存储空间。
要让系统为数组分配存储空间，必须指出数组元素的个数，该工作在数组初始化时进行。
数组经过初始化后，其元素的个数、所占用的存储空间就决定下来。
数组的初始化工作可以通过new操作符完成，也可以通过给元素赋初始值进行。
1.用new初始化数组
用new关键字初始化数组，只指定数组元素的个数，为数组分配存储空间，并不给数组元素赋初始值。
通过new关键字初始化数组有两种：
先声明数组再初始化和声明的同时进行初始化。
（1）先声明数组再初始化
先声明数组再初始化是通过两条语句来实现的，第一条语句是声明数组，第二条语句用new关键字初始化数组。
用new关键字初始化数组的格式如下：
数组名=new类型标识符【元素个数】
元素个数通过整型常量来表示。
例如：
要表示10个学生的成绩（整数），可以先声明元素的数据类型为整数score，再用new关键字初始化该数组。
intscore[]；
score=newint[10]；
数组中各元素通过下标来区分，下标的最小值为0，最大值比元素个数少1。
对于前面初始化的数组score，其10个元素分别为score[0]，score[2]，score[3]，···，score[9]。
系统为数组的10个元素分配存储空间，形式如表5-1所示：
表5-1一维数组
score[0]
score[1]
score[2]
score[3]
score[4]
score[5]
score[6]
score[7]
score[8]
score[9]
各元素的元素空间是连续的。
初始化数组后，如果想知道其元素个数，可以通过属性length获得。
其格式为：
数组名·length
例如，对于前面初始化的数组score和weight，score·length和weight·length的值分别为10和15.
数组下标可以使用变量，所以数组和循环语句结合使用，使得程序书写简洁，操作方便。
例如，要计算100个学生的平均成绩，可以使用以下的程序段。
floatsum;
inti;
intscore[];
score=newint[100];//输入数组各元素的值
sum=0;
for（i=0;i<100;i++）
sum=sum+score[i];
sum=sum/100;
（2）声明的同时进行初始化
可以用一条语句声明并初始化数组，即将上面的两条语句合并为一条语句。
其格式如下：
类型标识符[]数组名=new类型标识符[元素个数]
例如，要表示10个学生的学号，可以按以下方法声明并初始化数组no：
intno[]=newint[10];
2.赋初值初始化数组
可以在声明数组的同时，给数组元素赋初值。
所赋初值的个数决定数组元素的数目。
其格式如下：
类型标识符数组名={初值表}
初值表是用逗号隔开的初始值。
例如：
intscore[]={65,34,78,81,56,92,56,87,90,77};
该语句声明了一个数组score，其元素类型为int，因为初始值的各数为10，所以数组有10个元素，并且10个元素score[0]，score[1]，score[2]，···，score[9]的初始值分别为65,34,78,···,77，如同5-1所示。
score[0]
score[1]
score[2]
score[3]
score[4]
score[5]
score[6]
score[7]
score[8]
score[9]
65
34
78
81
56
92
56
87
90
77
图5-1初始化数组
5.2多维数组
日常工作中涉及到许多数据是由若干行和若干列所组成，例如行列式、矩阵、二维表格等待，为了描述和处理其中的一个数据，需要两个下标，即行标和列标。
有些情况下，可以需要三个或多个下标，如描述三维空间中各点的温度需要三个下标。
为了解决这一类问题，在Java中可以使用多维数组，即每个元素需要两个或多个下标来描述数组。
正像一维数组，多维数组在使用前也必须进行声明和初始化，且声明和初始化的方法于一维数组类似。
下面以二维数组为例，说明多维数组的使用方法，三维或三维以上的数组用法类似。
5.2.1二维数组的声明
二维数组的声明方法与一维数组类似，只是要给出两队方括号。
二维数组声明形式如下：
类型标识符数组名[][]
或
类型标识符[][]数组名
其中的类型标识符表示每个元素的数据类型
声明：
（1）数组名的命名方法同简单变量，可以是任意合法的标识符。
取名时最好符号“见名知意”的原则。
（2）类型标识符可以是任意的基本类型，如int、long、float和double，也可以是类或接口。
（3）对于多维数组，只需在数组名或类型标识符的后面放置多对方括号。
实数上，很少用到三维或更高维数的数组。
例如，要表示每个数据为整型数的行列式，可以声明如下二维数组：
inta[][];
5.2.2二维数组的初始化
声明一个二维数组仅为数组指定了数组名和元素的数据类型，并未指定数组的行数和列数，系统无法为数组分配存储空间。
要让系统为数组分配存储空间，必须指出数组的行数和列数，该工作在数组初始化时进行。
二维数组经过初始化后，其元素的个数、所占的存储空间就确定下来。
数组的初始化可以通过new操作符完成，也可以通过给元素赋初值进行。
1.用new初始化二维数组
用new关键字初始化二维数组，只指定数组行数和列数，为数组分配存储空间，并不给数组元素赋初始值。
通过new关键字初始化数组有两种方式：
先声明数组再初始化和在声明的同时进行初始化。
（1）先声明数组再初始化
先声明数组再初始化是通过两条语句来实现的，第一条语句声明数组，第二条语句用new关键字初始化数组。
用new关键字初始化数组的格式如下：
数组名=new类型标识符【行数】【列数】
行数和列数通过整型常量来表示。
元素的个数等于行数与列数的乘积。
例如，要表示每个数据为整型数的三行、四列的行列式，可以先声明元素的数据类型为整型的数组a，再用new关键字初始化该数组。
inta【】【】；
a=newint【3】【4】；
数组中各元素通过两个下标来区分，每个下标的最小值为0，最大值分别比行数和列数少1.对于前面初始化的数组a，其12个元素分别为a【0】【0】，a【0】【1】，a【0】【2】，a【0】【3】，a【1】【0】，a【1】【1】，···a【2】【3】。
系统为该数组的12个元素分配存储空间，形式如表5-2所示。
表5-2二维数组
a【0】【0】a【0】【1】a【0】【2】a【0】【3】
a【1】【0】a【1】【1】a【1】【2】a【1】【3】
a【2】【0】a【2】【1】a【2】【2】a【2】【3】
各元素的存储空间是连续的。
初始化数组后，如果想知道行数和列数，可以通过属性length获得。
数组名·length
获取数组列数的格式为：
数组名【行标】·length
二维数组的下标可以使用变量，所以二维数组和循环语句结合使用，使得程序书写简洁，操作方便。
在Java中，二维数组是作为一维数组来处理的，只是其每个元素本身又是个一维数组。
例如，前面初始化的数组a可以看做一维数组，共有3个元素a【0】、a【1】和a【2】，只不过每个元素本身又是一个一维数组。
a【0】的4个元素分别是a【0】【0】、a【0】【1】、a【0】【2】和a【0】【3】，a【1】的4个元素分别是a【1】【0】、a【1】【1】、a【1】【2】和a【1】【3】，a【2】的4个元素分别是a【2】【0】、a【2】【1】、a【2】【2】和a【2】【3】。
由于Java将二维数组当做一维数组来处理，所以在进行初始化的时候，可以各行单独进行，也允许各行的元素个数不同。
例如，要表示实型数的二行、三行行列式b，可以按照以下方式进行声明和初始化：
float【】【】b
b=newint【2】【】；//将b初始化为两行二维数组
b【0】=newint【3】；//将b【0】初始化三个元素
b【1】=newint【3】；//将b【1】初始化三个元素
再例如，要使用具有三行元素，第一行1个元素、第二行3个元素、第三行5个元素的二维数组c，可以按照以下方式进行声明和初始化：
intc【】【】；
c=newint【3】【】；//将c初始化为三行二维数组
for（inti=0;i<3;i++）
c【i】=newint【2·i+1】；
（2）赋初值初始化数组
可以用一条语句声明并初始化二维数组，即将上面的两条语句合并为一条语句。
其格式如下：
类型标识符数组名【】【】=new类型标识符【行数】【列数】
或
类型标识符【】【】数组名=new类型标识符【行数】【列数】
例如，要声明并初始化前面的数组a，可以按照以下方式进行：
inta【】【】=newint【3】【4】；
2.赋初值初始化数组
可以在声明二维数组的同时，给数组元素赋初值。
通过赋初值的数组和每组的个数决定二维数组的行数和每行元素的数目。
其格式如下：
类型标识符数组名【】【】={{初值表}，{初值表}，···，{初值表}}
每个初值表是用逗号隔开的初始值，数组后的一对方括号也可以移到类型标识符的后面。
例如：
intgrade【】【】={{65,34,78}，{81,56,92}，{56,87,90}，{92,69,75}}；
该语句声明了一个二维数组grade，其元素类型为int。
因为初始值分为四组，所以grade有四行元素。
每组的初值个数均为3，说明grade每行有3个元素。
数组grade共有12个元素。
表5-3初始化
a【0】【0】65a【0】【1】34a【0】【2】78
a【1】【0】81a【1】【1】56a【1】【2】92
a【2】【0】56a【2】【1】87a【2】【2】90
a【3】【0】92a【3】【1】96a【3】【2】75
5.3数组的基本操作
声明一个数组后，就可以对其进行各种操作。
对数组的操作主要是对数组元素的操作。
数组元素的下标可以使用变量，将其与循环语句结合起来使用，可以发挥巨大作用。
5.3.1数组的引用
对数组的引用，通常是对其元素的引用。
数组元素的引用方法是在数组名后面的括号中指定其下标。
数组元素几乎能出现在巨大变量可以出现的任何情况下，如可以被赋值，可以被打印，可以参见表达式计算。
例如：
intage【】；
age=newint【3】；
age【1】=23；
age【2】=2+age【1】；
5.3.2数组的复制
要将一个数组的诸元素的值复制到另外一个数组的各个元素，可以通过循环语句，逐个元素进行赋值，也可以直接将一个数组的各元素值赋给另一个数组的对应元素。
【例】
intc[][],d[][],e[][],I,j;
c=newint[3][3];
d=newint[3][3];
e=newint[3][3];
for（i=0;i<3;i++）
for（j=0;j<3;j++）
{
d[i][j]=i+j;
c[i][j]=d[i][j]
}
e=d;
【程序解析】
本例中，通过循环语句给数组d的各元素赋值，接着将d的各元素的值赋给c的各元素，即c数组和d数组对应元素的值相等。
最后一个赋值语句直接将数组d赋给数组e，也实现了将数组的各元素的值赋给数组e的各元素的功能。
本例中进行复制的两个数组具有相同的维数，且各维元素的个数相同。
事实上，通过逐个元素赋值的方法可以在不同维数，不同大小的数组之间进行复制，直接数组赋值只能在维数相等的两个数组之间进行。
5.3.3数组的输出
数组的输出通常是逐个元素结合循环语句实现的。
例如，程序段：
inta[],i;
a=newint[3];
for（i=0;i{
a[i]=iI;
System.out.println（a[i]）;
}
的功能是首先给数组a的各元素分别赋0、1和2，然后分别在3行输出其各元素的值。
【例5-2】一维数组的复制
publicclassArrayC
{
publicstaticvoidmain（Stringargs[]）
{
inta[],b[],i,j;
a=newint[3];
b=newint[5];
System.out.println（"a.length="+a.length）;
for（i=0;i{
a[i]=i;
System.out.print（a[i]+""）;
}
System.out.println（）;
System.out.println（"Beforearrayassignment"）;
System.out.println（"b.length="+b.length）;
for（j=0;j{
b[j]=j*10;
System.out.print（b[j]+""）;
}
System.out.println（）;
b=a;
System.out.println（"Afterarrayassignment"）;
System.out.println（"b.length="+b.length）;
for（j=0;j{
System.out.print（b[j]+""）;
}
System.out.println（）;
}
}
【程序解析】
第一个循环语句分别给数组a的3个元素赋值0、1和2，并将各元素的值输出在同一行。
第二个循环语句分别给数组b的5个元素赋值0、10、20、30和40，并将各元素的值输出在同一行。
通过语句b=a，将数组a赋给b，使得b的元素个数和a的元素个数相等，并将a的各元素赋给b的对应元素。
程序运行如下：
a.length=3
013
Beforearrayassignment
b.length=5
010203040
Afterarrayassignment
b.length=3
013
【例5-3】二维数组的复制
publicclassArrayC2
{
publicstaticvoidmain（Stringargs[]）
{
intc[][],d[][],i,j;
c=newint[2][2];
d=newint[3][3];
System.out.println（"Arrayd"）;
for（i=0;i{
for（j=0;j{
d[i][j]=i+j;
System.out.print（d[i][j]+""）;
}
System.out.println（）;
}
c=d;
System.out.println（"Arrayc"）;
for（i=0;i{
for（j=0;j{
c[i][j]=i+j;
System.out.print（c[i][j]+""）;
}
System.out.println（）;
}
}
}
【程序解析】
第一个循环语句分别给数组d的9个元素赋值，并将各元素的值分行输出。
通过语句c=d，将数组d赋给c，使得c的元素个数和d的元素个数相等，并将d的各元素赋给c的对应元素。
注意：
虽然数组c被初始化为两行两列，但d被初始化为三行三列，执行语句c=d后，数组c变为三行三列。
d.length的值为数组d的行数，d[i].length的值为第i行元素的个数。
程序运行结果如下：
Arrayd
012
123
234
Arrayc
012
123
234
5.4数组应用举例
数组是Java中重要的数据结构，是程序设计课程的重要部分。
【例5-4】排序
排序是将一组数按照递增或递减的顺序排列。
排列的方法很多，其中最基本的是选择法。
其基本思想如下：
（1）对于给定的n个数，从中选出最小（大）的数，与第1个数交换位置，便将最小（大）的数置于第一个位置。
（2）对于除第一个数外的剩下的n-1个数，重复步骤
（1），将次小（大）的数置于第二个位置。
（3）对于剩下的n-2，n-3，···，n-n+2个数用同样的方法，分别将第3个最小（大）数置于第3位置，第4个最小（大）数置于第4位置，···。
假定有7个数，7,4,0,6,2,5,1，根据该思想，对其按照递增顺序排列，需要进行6轮选择和交换过程。
第1轮：
7个数中，最小数是0，与第1个数7交换位置，结果为：
0476251
第2轮：
剩下6个数中，最小数是1，与第2个数4交换位置，结果为：
0176254
第3轮：
剩下5个数中，最小数是2，与第3个数7交换位置，结果为：
0126754
第4轮：
剩下4个数中，最小数是4，与第4个数6交换位置，结果为：
0124756
第5轮：
剩下3个数中，最小数是5，与第5个数7交换位置，结果为：
0124576
第6轮：
剩下2个数中，最小数是6，与第6个数7交换位置，结果为：
0124567
可见，对于n个待排序的数，要进行n-1轮的选择和交换过程。
其中第i轮的选择和交换过程中，要进行n-i次的比较，方能选择出该轮中最小（大）的数。
根据前面的分析，可以编写对n个整数进行升序排序的程序。
importjava.io.*;
publicclassArraySort
{
publicstaticvoidmain（Stringargs[]）throwsIOException
{
BufferedReaderkeyin=newBufferedReader（newInputStreamReader（System.in））;
inta[],i,j,k,temp;
Stringc;
System.out.println（"Inputthenumberofarrayelements!
"）;
c=keyin.readLine（）;
temp=Integer.parseInt（c）;
a=newint[temp];
System.out.println（"Input"+temp+"numbers.Oneperline!
"）;
for（i=0;i{
c=keyin.readLine（）;
a[i]=Integer.parseInt（c）;
}
System.out.println（"Aftersorting"）;
for（i=0;i{
k=i;
for（j=i+1;j{
if（a[j]}
temp=a[i];
a[i]=a[k];
a[k]=temp;
}
for（i=0;i{
System.out.println（a[i]）;
}
}
}
【程序解析】
定义变量keyin的目的是想在程序运行过程中通过键盘输入数据，其功能在后面介绍。
后面的语句c=keyin.readLine（）是将通过键盘输入的一行字符串保存到变量c中。
语句temp=Integer.parseInt（c）的功能是将变量c中内存的字符串转换成整型数。
第一个循环语句给数组a的各元素输入值，第二个循环语句是个二重循环，对数组a进行排序，第三个循环语句输出排序后数组各元素的值。
在排序的第i轮循环中，用变量k记录该轮中最小数的下标。
待该轮循环结束后，将第i个元素和第k个元素的值交换，从而实现将第i个最小数置于第i位置的目的。
运行该程序，根据提示，首先输入数组元素的个数6，接着输入6个元素值：
4、90、56、3、48和23。
运行结果如下所示：
Inputthenumberofarrayelements!
6
Input6numbers.Oneperline!
4
90
56
3
48
23
Aftersorting
3
4
23
48
56
90
【例5-5】矩阵运算
数学中的矩阵在Java中用二维数组来实现，本例中要进行矩阵的加、乘运算。
publicclassArrayC3
{
publicstaticvoidmain（Stringargs[]）
{
intc[][]={{1,2,3},{4,5,6},{7,8,9}};
intd[][]={{2,2,
升级会员 