JAVA数组与字符串详解.doc

第5章 数组与字符串
我们在前面学习的整形、字符型等都是基本数据类型，通过一个变量表示一个数据，这种变量称为简单变量。在实际应用中，经常需要处理具有相同性质的一批数据。例如要处理100个学生的考试成绩，如果要使用简单变量，将需要100个变量，极不方便。为此，在Java中，除简单变量外，还引进了数组，即用一个变量表示一组相同性质的数据。数组必须先经过声明和初始化后才能使用。
5.1 一维数组
数组是用一个变量名表示一组数据，每个数据称为数组元素，各元素通过下标来区分。如果用一个下标就能确定数组中的不同元素，这种数组称为一维数组，否则称为多维数组。
5.1.1 一维数组的声明
声明一个数组就是要确定数组名、数组的维数和数组元素的数据类型。
一维数组声明的格式为：

类型标识符 数组名【】
或
类型标识符【】 数组名

类型标识符指定每个元素的数据类型，如int表明数组中的每个元素都是整型数。
说明：
（1） 数组名的命名方法同简单变量，可以是任意合法的标识符。取名是最好符合“见名知意”的原则。
（2） 类型标识符可以是任意的基本类型，如int、long、float和double，也可以是类或接口。

例如，要表示学生的成绩（整数），可以声明元素的数据类型为整数的数组score，其声明如下：
int score【】
该声明表示数组的名字为score，每个元素为整型数。
要表示学生的体重（浮点数），可以声明元素的数据类型为float的数组weight，其声明如下：
float【】 weight

5.1.2 一维数组的初始化
声明一个数组仅为数组指定了数组名和元素的数据类型，并未指定数组的元素个数，系统无法为数组分配存储空间。要让系统为数组分配存储空间，必须指出数组元素的个数，该工作在数组初始化时进行。数组经过初始化后，其元素的个数、所占用的存储空间就决定下来。数组的初始化工作可以通过new操作符完成，也可以通过给元素赋初始值进行。
1. 用new初始化数组
用new关键字初始化数组，只指定数组元素的个数，为数组分配存储空间，并不给数组元素赋初始值。通过new关键字初始化数组有两种：先声明数组再初始化和声明的同时进行初始化。
（1） 先声明数组再初始化
先声明数组再初始化是通过两条语句来实现的，第一条语句是声明数组，第二条语句用new关键字初始化数组。
用new关键字初始化数组的格式如下：
数组名=new 类型标识符【元素个数】
元素个数通过整型常量来表示。
例如：要表示10个学生的成绩（整数），可以先声明元素的数据类型为整数score，再用new关键字初始化该数组。
int score[]；
score=new int[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个学生的平均成绩，可以使用以下的程序段。
float sum;
int i;
int score[];
score=new int[100]; //输入数组各元素的值
sum=0;
for(i=0;i<100;i++)
sum=sum+score[i];
sum=sum/100;
（2） 声明的同时进行初始化
可以用一条语句声明并初始化数组，即将上面的两条语句合并为一条语句。其格式如下：

类型标识符[] 数组名=new 类型标识符[元素个数]
例如，要表示10个学生的学号，可以按以下方法声明并初始化数组no：
int no[]=new int[10];
2. 赋初值初始化数组
可以在声明数组的同时，给数组元素赋初值。所赋初值的个数决定数组元素的数目。其格式如下：

类型标识符 数组名={初值表}

初值表是用逗号隔开的初始值。

例如：int score[]={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） 对于多维数组，只需在数组名或类型标识符的后面放置多对方括号。
实数上，很少用到三维或更高维数的数组。
例如，要表示每个数据为整型数的行列式，可以声明如下二维数组：
int a[][];

5.2.2 二维数组的初始化
声明一个二维数组仅为数组指定了数组名和元素的数据类型，并未指定数组的行数和列数，系统无法为数组分配存储空间。要让系统为数组分配存储空间，必须指出数组的行数和列数，该工作在数组初始化时进行。二维数组经过初始化后，其元素的个数、所占的存储空间就确定下来。数组的初始化可以通过new操作符完成，也可以通过给元素赋初值进行。
1. 用new初始化二维数组
用new关键字初始化二维数组，只指定数组行数和列数，为数组分配存储空间，并不给数组元素赋初始值。通过new关键字初始化数组有两种方式：先声明数组再初始化和在声明的同时进行初始化。
（1） 先声明数组再初始化
先声明数组再初始化是通过两条语句来实现的，第一条语句声明数组，第二条语句用new关键字初始化数组。
用new关键字初始化数组的格式如下：
数组名=new 类型标识符【行数】【列数】
行数和列数通过整型常量来表示。元素的个数等于行数与列数的乘积。
例如，要表示每个数据为整型数的三行、四列的行列式，可以先声明元素的数据类型为整型的数组a，再用new关键字初始化该数组。
int a【】【】；
a=new int【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=new int【2】【】； //将b初始化为两行二维数组
b【0】=new int【3】； //将b【0】初始化三个元素
b【1】=new int【3】； //将b【1】初始化三个元素
再例如，要使用具有三行元素，第一行1个元素、第二行3个元素、第三行5个元素的二维数组c，可以按照以下方式进行声明和初始化：
int c【】【】；
c=new int【3】【】； //将c初始化为三行二维数组
for(int i=0;i<3;i++)
c【i】=new int【2·i+1】；

（2） 赋初值初始化数组
可以用一条语句声明并初始化二维数组，即将上面的两条语句合并为一条语句。其格式如下：

类型标识符 数组名【】【】=new 类型标识符【行数】【列数】
或
类型标识符【】【】 数组名=new 类型标识符【行数】【列数】

例如，要声明并初始化前面的数组a，可以按照以下方式进行：
int a【】【】=new int【3】【4】；

2. 赋初值初始化数组
可以在声明二维数组的同时，给数组元素赋初值。通过赋初值的数组和每组的个数决定二维数组的行数和每行元素的数目。其格式如下：

类型标识符 数组名【】【】={{初值表}，{初值表}，···，{初值表}}
每个初值表是用逗号隔开的初始值，数组后的一对方括号也可以移到类型标识符的后面。
例如：
int grade【】【】={{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】 65 a【0】【1】 34 a【0】【2】 78
a【1】【0】 81 a【1】【1】 56 a【1】【2】 92
a【2】【0】 56 a【2】【1】 87 a【2】【2】 90
a【3】【0】 92 a【3】【1】 96 a【3】【2】 75

5.3 数组的基本操作
声明一个数组后，就可以对其进行各种操作。对数组的操作主要是对数组元素的操作。数组元素的下标可以使用变量，将其与循环语句结合起来使用，可以发挥巨大作用。

5.3.1 数组的引用
对数组的引用，通常是对其元素的引用。数组元素的引用方法是在数组名后面的括号中指定其下标。数组元素几乎能出现在巨大变量可以出现的任何情况下，如可以被赋值，可以被打印，可以参见表达式计算。
例如：
int age【】；
age=new int【3】；
age【1】=23；
age【2】=2+age【1】；

5.3.2 数组的复制
要将一个数组的诸元素的值复制到另外一个数组的各个元素，可以通过循环语句，逐个元素进行赋值，也可以直接将一个数组的各元素值赋给另一个数组的对应元素。
【例】
int c[][],d[][],e[][],I,j;
c=new int[3][3];
d=new int[3][3];
e=new int[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 数组的输出
数组的输出通常是逐个元素结合循环语句实现的。
例如，程序段：
int a[],i;
a=new int[3];
for(i=0;i<a.length;i++)
{
a[i]=iI;
System.out.println(a[i]);
}
的功能是首先给数组a的各元素分别赋0、1和2，然后分别在3行输出其各元素的值。
【例5-2】一维数组的复制
public class ArrayC
{
public static void main(String args[])
{
int a[],b[],i,j;
a=new int[3];
b=new int[5];
System.out.println("a.length="+a.length);
for(i=0;i<a.length;i++)
{
a[i]=i;
System.out.print(a[i]+" ");
}
System.out.println();
System.out.println("Before array assignment");
System.out.println("b.length="+b.length);
for(j=0;j<b.length;j++)
{
b[j]=j*10;
System.out.print(b[j]+" ");
}
System.out.println();
b=a;
System.out.println("After array assignment");
System.out.println("b.length="+b.length);
for(j=0;j<b.length;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
0 1 3
Before array assignment
b.length=5
0 10 20 30 40
After array assignment
b.length=3
0 1 3

【例5-3】二维数组的复制
public class ArrayC2
{
public static void main(String args[])
{
int c[][],d[][],i,j;
c=new int[2][2];
d=new int[3][3];
System.out.println(" Array d");
for(i=0;i<d.length;i++)
{
for(j=0;j<d[i].length;j++)
{
d[i][j]=i+j;
System.out.print(d[i][j]+" ");
}
System.out.println();
}
c=d;
System.out.println(" Array c");
for(i=0;i<c.length;i++)
{
for(j=0;j<c[i].length;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行元素的个数。
程序运行结果如下：
Array d
0 1 2
1 2 3
2 3 4
Array c
0 1 2
1 2 3
2 3 4

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交换位置，结果为：
0 4 7 6 2 5 1
第2轮：剩下6个数中，最小数是1，与第2个数4交换位置，结果为：
0 1 7 6 2 5 4
第3轮：剩下5个数中，最小数是2，与第3个数7交换位置，结果为：
0 1 2 6 7 5 4
第4轮：剩下4个数中，最小数是4，与第4个数6交换位置，结果为：
0 1 2 4 7 5 6
第5轮：剩下3个数中，最小数是5，与第5个数7交换位置，结果为：
0 1 2 4 5 7 6
第6轮：剩下2个数中，最小数是6，与第6个数7交换位置，结果为：
0 1 2 4 5 6 7
可见，对于n个待排序的数，要进行n-1轮的选择和交换过程。其中第i轮的选择和交换过程中，要进行n-i次的比较，方能选择出该轮中最小（大）的数。
根据前面的分析，可以编写对n个整数进行升序排序的程序。
import java.io.*;
public class ArraySort
{
public static void main(String args[]) throws IOException
{
BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));
int a[],i,j,k,temp;
String c;
System.out.println("Input the number of array elements!");
c=keyin.readLine();
temp=Integer.parseInt(c);
a=new int[temp];
System.out.println("Input "+temp+" numbers.One per line!");

for(i=0;i<a.length;i++)
{
c=keyin.readLine();
a[i]=Integer.parseInt(c);
}
System.out.println("After sorting");

for(i=0;i<a.length;i++)
{
k=i;
for(j=i+1;j<a.length;j++)
{
if(a[j]<a[k]) k=j;
}
temp=a[i];
a[i]=a[k];
a[k]=temp;
}
for(i=0;i<a.length;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。运行结果如下所示：
Input the number of array elements!
6
Input 6 numbers.One per line!
4
90
56
3
48
23
After sorting
3
4
23
48
56
90
【例5-5】 矩阵运算
数学中的矩阵在Java中用二维数组来实现，本例中要进行矩阵的加、乘运算。
public class ArrayC3
{
public static void main(String args[])
{
int c[][]={{1,2,3},{4,5,6},{7,8,9}};
int d[][]={{2,2,2},{1,1,1},{3,3,3}};
int i,j,k;
int e[][]=new int[3][3];
System.out.println(" Array c");

for(i=0;i<c.length;i++)
{
for(j=0;j<c[i].length;j++)
{
System.out.print(c[i][j]+" ");
}
System.out.println();
}

System.out.println(" Array d");

for(i=0;i<d.length;i++)
{
for(j=0;j<d[i].length;j++)
{
System.out.print(d[i][j]+" ");
}
System.out.println();
}

System.out.println(" Array c+d");

for(i=0;i<e.length;i++)
{
for(j=0;j<e[i].length;j++)
{
e[i][j]=c[i][j]+d[i][j];
System.out.print(e[i][j]+" ");
}
System.out.println();
}

System.out.println(" Array c*d");

for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
e[i][j]=0;
for(k=0;k<3;k++)
e[i][j]=e[i][j]+c[i][k]+d[k][j];
System.out.print(e[i][j]+" ");
}
System.out.println();
}
}
}
程序运行结果如下：
Array c
1 2 3
4 5 6
7 8 9
Array d
2 2 2
1 1 1
3 3 3
Array c+d
3 4 5
5 6 7
10 11 12
Array c*d
12 12 12
21 21 21
30 30 30

5.5 数组参数
在Java的方法中，允许参数是数组。在使用数组参数时，应该注意以下事项：
（1） 在形参表中，数组名后的括号不能省略，括号个数和数组的维数相等不需给出数组元素的个数。
（2） 在实参表中，数组名不需括号。
（3） 数组名做实参时，传递的是地址，而不是值，即形参和实参具有相同的存储单元。
例如，定义以下过程：
void f(int a[])
{
···
}
方法f有一个一维数组参数a，在形参表中，只需列出数组参数a的名字以及后面的方括号。
如果已经定义了数组b，可以通过以下的语句调用该方法：
f（b）
在调用该方法时，就将数组b传递给数组a。由于是传址方式，所以将数组b的地址传递给数组a，因而数组a和数组b共享相同的存储单元。所以在方法f中，对数组a的某一元素值进行了更改，也就是对数组b的元素进行了修改。当方法结束后，数组b将修改的结果带回到调用过程。
【例5-6】计算数组元素平均值的方法。
public class ArrayC4
{
public static void main(String args[])
{
int c[]={1,2,3,4,5,6,7,8,9};
int j;
System.out.println("Array c");

for(j=0;j<c.length;j++)
{
System.out.print(c[j]+" ");
}
System.out.println();
System.out.println("Array average");
System.out.println(arrayAverage(c));
}
static float arrayAverage(int d[])
{
float average=0;
for(int i=0;i<d.length;i++)
average=average+d[i];
average=average/d.length;
return average;
}
}
【程序解析】
方法arrayAverage的形参是一维数组，其功能是计算该数组元素的平均值，并将所计算的平均值返回。在main方法中，通过语句System.out.println(arrayAverage(c))，以数组c做为实参调用方法arrayAverage，计算并打印数组c各元素的平均值。
程序运行结果如下：
Array c
1 2 3 4 5 6 7 8 9
Array average
5.0
【例5-7】展示数组参数传递地址的方法
简单变量做方法的参数时传递值，即实参和形参拥有不同的存储空间；数组做参数时传递的是地址，即实参和形参拥有相同的存储空间，所以当在方法中更改了形式参数的值，也就是更改了实参的值。本例用来展示数组参数的传递地址特性。
public class ArrayC6
{
public static void main(String args[])
{
int c[][]={{1,2,3,4,5},{6,7,8,9,10}};
int i,j;
System.out.println("Array c before calling arrayMultiply");

for(i=0;i<c.length;i++)
{
for(j=0;j<c[i].length;j++)
System.out.print(c[i][j]+" ");
System.out.println();
}
arrayMultiply(c);
System.out.println("Array c after calling arrayMultiply");
for(i=0;i<c.length;i++)
{
for(j=0;j<c[i].length;j++)
System.out.print(c[i][j]+" ");
System.out.println();
}
}
static void arrayMultiply(int d[][])
{
int k,l;
for(k=0;k<d.length;k++)
for(l=0;l<d[k].length;l++)
d[k][l]=2*d[k][l];
System.out.println("In arrayMultiply");
for(k=0;k<d.length;k++)
{
for(l=0;l<d[k].length;l++)
System.out.print(d[k][l]+" ");
System.out.println();
}
}
}
【程序解析】
方法arrayMultiply带有一个二维数组参数d，其功能是将d的各元素值称以2并分行输出。
在方法main中，声明并初始化了二维数组c，并以分行方式输出数组c的各元素值。
接着通过语句arrayMultiply（c），以数组c做为实参调用方法arrayMultiply。由于调用该方法的实参是数组，所以传递的是地址，即形参数组d和实参数组c具有相同的存储单元。所以当该方法将数组d中各元素值扩大2倍的时候，也自然将c的各元素值扩大了两倍。
在main中，最后又分行显示数组c各元素的值，其值比调用方法arrayMultiply（c）之前扩大了2倍。
程序运行结果如下：
Array c before calling arrayMultiply
1 2 3 4 5
6 7 8 9 10
In arrayMultiply
2 4 6 8 10
12 14 16 18 20
Array c after calling arrayMultiply
2 4 6 8 10
12 14 16 18 20
【例5-8】展示数组元素参数传递值的方法
public class ArrayC7
{
public static void main(String args[])
{
int c[]={1,10,100,1000};
int j;
System.out.println("Array c before calling elementMultiply");

for(j=0;j<c.length;j++)
{
System.out.print(c[j]+" ");
}
System.out.println();
elementMultiply(c[2]);
System.out.println("Array c after calling elementMultiply");
for(j=0;j<c.length;j++)
{
System.out.print(c[j]+" ");
}
System.out.println();
}
static void elementMultiply(int d)
{
d=2*d;
System.out.println("d="+d);
}
}
【程序解析】
在方法elementMultiply中唯一的形参是一个简单变量d，其功能是将参数d的值扩大2倍并输出。
在方法main中声明了一维数组a，并为其4个元素分别赋了初始值1、10、100、1000。接着输出数组各元素的值。再通过语句elementMultiply(c[2])以c[2]做为实参调用方法elementMultiply。由于c[2]传递的值是100，形参d和实参c[2]拥有不同的存储空间。方法elementMultiply仅将d的值扩大了2倍，变为200，实参c[2]的值仍然保持100。在main的最后再输出数组c各元素的值，其结果与调用elementMultiply之前完全相同。
该程序的运行结果如下：
Array c before calling elementMultiply
1 10 100 1000
d=200
Array c after calling elementMultiply
1 10 100 1000

5.6 字符串
字符串是字符组成的序列，是编程中常用的数据类型。字符串可用来表示标题、名称、地址等。

5.6.1 字符数组与字符串
所谓字符数组指数组的每个元素是字符类型的数据。对于标题、名称等由字符组成的序列可以使用字符数组来描述。例如要表示字符串“China”，可以使用如下的字符数组：
char【】 country={‘C’，‘h’，‘i’，‘n’，‘a’}；
字符串中所包含的字符个数称为字