第7章、字符串数组授课

学习导读字符、字符串、数组都是使用Java语言编制程序要经常使用的数据结构，因此，熟练掌握这些数据结构是进一步学习Java程序设计的必要阶段。通过本章的学习，应该能够熟练掌握字符、字符串、数组的各种基本操作。第7章字符、字符串、数组IntroducingArraysDeclaringArrays,CreatingArrays,andInitializingArraysArrayofObjectsCopyingArraysMultidimensionalArraysNumericWrapperClassesCommand-LineParametersCreatingGenericClassesTheVectorClass第7章字符、字符串、数组教学重点与难点：字符与字符串的区别字符串常量与String类字符串变量与StringBuffer类数组与数组类Arrays7.1字符

字符是指用单引号括起来单个字符，如’a’、’b’、’A’等。这里的字符不是指占1个字节的ASCII字符，而是指占2个字节的Unicode字符。因为Unicode被设计用来处理现在世界上所有书面语言中的字符，所以一个汉字也是被当作一个字符来处理的。对于单个字符，除了有char这个原始类型以外，Java平台中的java.lang包还专门提供了一个Character类来进行储存和操作。

7.1.1Character类的构造函数

Character类只能用于存储和操作单一的字符数值，Character类的对象包含了单一字符数值。以下是Character类提供的构造函数：

publicCharacter（char）参数必须为一个char类型数据，它创建了一个Character对象，该对象包含了由参数提供的数值。一旦Character对象被创建，它包含的数值就不能改变。下面的语句将创建一个Character对象a，该对象包含字符数据’b’：

Charactera=newCharacter('b');7.1.2Character类提供的常用方法

1．publicintcompareTo（Character）

compareTo（Character）是一个实例方法，参数必须为一个Character对象，而不能是char类型数据。该方法比较两个Character对象包含的数值，返回一个整数表明在当前对象中的数值是否大于、等于或者小于参数给定的数值。

2．publicbooleanequals（Objectobj）

equals（）是一个实例方法，用于比较两个对象。用于Character类对象时，该方法比较当前对象容纳的数值和参数对象容纳的数值。在两个对象容纳的数值相等的时候返回true，否则返回false。

3．publicStringtoString（）所有的类从对象类继承了toString方法。toString是一个实例方法，它将对象转换为字符串。该方法用于Character类对象时，结果的字符串在长度为1，并且它包含了有这个Character对象容纳的数值。4．publiccharcharValue（）

charValue是一个实例方法，它返回Character对象的字符。5．publicstaticbooleanisUpperCase（char）

isUpperCase（char）是一个类方法，该方法用来判断字符参数值是否为大写。当字符参数值是大写时，返回值为true，否则返回false。

【例6.1】Character类提供的常用方法6.2字符串

字符串指的是字符的序列，有两种类型的字符串：一种是创建以后不需要改变的，称为字符串常量，在Java中，String类用于存储和处理字符串常量；另外一种字符串是创建以后，需要对其进行改变的，称为字符串变量，在Java中，StringBuffer类用于存储和操作字符串变量。字符串是有序的字符序列，它的最基本元素是字符，一个字符可以是字母、数字、标点符号或其它的符号。在Java中，可以通过使用在String后面跟一个变量名的形式来直接建立一个保存字符串的变量，例如：Stringstring1="Hello!";这个语句创建了一个名为string1的字符串变量，并将文本Hello!保存在此变量中。在Java中，字符串是用双引号括起来的，但字符串的内容并不包括双引号。字符串与我们使用过的简单数据类型（int、float、char、boolean等）不一样，String的第一个字母是大写的，因为在Java中，字符串是一个特殊的资源，这个资源叫对象，而所有的对象类型名的第一个字母都必须大写。

6.2.1字符串常量与String类

在Java中，没有内置的字符串类型，字符串常量是作为String类的对象存在的。1．创建String类对象

String类的对象表示的是字符串常量，一个字符串常量创建以后就不能够被修改了。所以在创建String类对象时，通常需要向构造函数传递参数来指定创建的字符串的内容。以下是常用的String类构造函数：（1）publicString（）该构造函数用于创建一个空的字符串常量。（2）publicString（Stringvalue）该构造函数用于根据一个已经存在的字符串常量来创建一个新的字符串常量，该字符串的内容和已经存在的字符串常量一致。（3）publicString（charvalue[]）该构造函数用于根据一个已经存在的字符数组来创建一个新的字符串常量。数组将在本章后面的内容中介绍。（4）publicString（StringBufferbuffer）该构造函数用于根据一个已经存在的StringBuffer对象来创建一个新的字符串常量。

2．String类对象的常用操作及方法在Java中，String类包含有50多个方法来实现字符串的各种操作，以下介绍一些我们需要经常使用的方法。（1）字符串的连接

publicStringconcat(Stringstr)

该方法的参数为一个String类对象，作用是将参数中的字符串str连接到原来字符串的后面。

（2）求字符串的长度

publicintlength()

返回字串的长度，这里的长度指的是字符串中Unicode字符的数目。（3）求字符串中某一位置的字符

publiccharcharAt(intindex)

该方法在一个特定的位置索引一个字符串，以得到字符串中指定位置的字符。值得注意的是，在字符串中第一个字符的索引是0，第二个字符的索引是1，依次类推，最后一个字符的索引是length（）－1。

【例6.2】求字符串的长度及每一个位置上的字符

（4）字符串的比较比较字符串可以利用String类提供的下列方法：

1）publicintcompareTo（StringanotherString）该方法比较两个字符串，和Character类提供的compareTo方法相似，Character类提供的compareTo方法比较的是两个字符类数据，而这里比较的是字符串数据。

其比较过程实际上是两个字符串中相同位置上的字符按Unicode中排列顺序逐个比较的结果。如果在整个比较过程中，没有发现任何不同的地方，则表明两个字符串是完全相等的，compareTo方法返回0；如果在比较过程中，发现了不同的地方，则比较过程会停下来，这时一定是两个字符串在某个位置上不相同，如果当前字符串在这个位置上的字符大于参数中的这个位置上的字符，compareTo方法返回一个大于0的整数，否则返回一个小于0的整数。2）publicbooleanequals（ObjectanObject）该方法比较两个字符串，和Character类提供的equals方法相似，因为它们都是重载Object类的方法。该方法比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。

3）publicbooleanequalsIgnoreCase（StringanotherString）该方法和equals方法相似，不同的地方在于，equalsIgnoreCase方法将忽略字母大小写的区别。

（5）从字符串中提取子串利用String类提供的substring方法可以从一个大的字符串中提取一个子串，该方法有两种常用的形式：

1）publicStringsubstring（intbeginIndex）该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。

2）publicStringsubstring(intbeginIndex,intendIndex)

该方法从当前字符串中取出一个子串，该子串从beginIndex位置起至endIndex-1为结束。子串返的长度为endIndex-beginIndex。

（6）判断字符串的前缀和后缀判断字符串的前缀是否为指定的字符串利用String类提供的下列方法：

1)publicbooleanstartsWith(Stringprefix)

该方法用于判断当前字符串的前缀是否和参数中指定的字符串prefix一致，如果是，返回true，否则返回false。

2）publicbooleanstartsWith（Stringprefix,inttoffset）该方法用于判断当前字符串从toffset位置开始的子串的前缀是否和参数中指定的字符串prefix一致，如果是，返回true，否则返回false。

判断字符串的后缀是否为指定的字符串利用String类提供的方法：

publicbooleanendsWith（Stringsuffix）该方法用于判断当前字符串的后缀是否和参数中指定的字符串suffix一致，如果是，返回true，否则返回false。（7）字符串中单个字符的查找字符串中单个字符的查找可以利用String类提供的下列方法：

1）publicintindexOf（intch）该方法用于查找当前字符串中某一个特定字符ch出现的位置。该方法从头向后查找，如果在字符串中找到字符ch，则返回字符ch在字符串中第一次出现的位置；如果在整个字符串中没有找到字符ch，则返回-1。2）publicintindexOf（intch,intfromIndex）该方法和第一种方法类似，不同的地方在于，该方法从fromIndex位置向后查找，返回的仍然是字符ch在字符串第一次出现的位置。

3）publicintlastIndexOf（intch）该方法和第一种方法类似，不同的地方在于，该方法从字符串的末尾位置向前查找，返回的仍然是字符ch在字符串第一次出现的位置。

4）publicintlastIndexOf（intch,intfromIndex）该方法和第二种方法类似，不同的地方在于，该方法从fromIndex位置向前查找，返回的仍然是字符ch在字符串第一次出现的位置。

（8）字符串中子串的查找字符串中子串的查找与字符串中单个字符的查找十分相似，可以利用String类提供的下列方法：

1）publicintindexOf（Stringstr）

2）publicintindexOf（Stringstr,intfromIndex）

3）publicintlastIndexOf（Stringstr）

4）publicintlastIndexOf（Stringstr,intfromIndex）

（9）字符串中字符大小写的转换字符串中字符大小写的转换，可以利用String类提供的下列方法：

1）publicStringtoLowerCase（）该方法将字符串中所有字符转换成小写，并返回转换后的新串。

2）publicStringtoUpperCase（）该方法将字符串中所有字符转换成大写，并返回转换后的新串。（10）字符串中多余空格的去除

publicStringtrim()

该方法只是去掉开头和结尾的空格，并返回得到的新字符串。值得注意的是，在原来字符串中间的空格并不去掉。

（11）字符串中字符的替换

1）publicStringreplace（charoldChar,charnewChar）该方法用字符newChar替换当前字符串中所有的字符oldChar，并返回一个新的字符串。

2）publicStringreplaceFirst（Stringregex,Stringreplacement）该方法用字符串replacement的内容替换当前字符串中遇到的第一个和字符串regex相一致的子串，并将产生的新字符串返回。

3）publicStringreplaceAll（Stringregex,Stringreplacement）该方法用字符串replacement的内容替换当前字符串中遇到的所有和字符串regex相一致的子串，并将产生的新字符串返回。在字符串中使用特殊字符

当一个字符串被创建或被显示时，它的文本必须用双引号括起来，以表示字符串的开始和结束，但双引号并不是字符串内容的一部分。如果你想让字符串的内容包括双引号，就必须使用一个特殊符号：\"。每当在字符串中遇到此符号时，它就被一个双引号代替。例如：System.out.println("Heasked:\"Whoareyou?\"");将会显示出如下结果：Heasked:"Whoareyou?"转义字符表7-1Java中常用的特殊字符表例：String中的特殊符号示例。publicclassStringDemo1{ publicstaticvoidmain(Stringargs[]){ System.out.println("Heasked:\"Whoareyou?\""); System.out.println("Heasked:\'Whoareyou?\'"); System.out.println("Heasked:\\Whoareyou?\\"); System.out.println("Heasked:\tWhoareyou?\t"); System.out.println("Heasked:\bWhoareyou?"); System.out.println("Heasked:\nWhoareyou?"); }}运行程序会得到如下输出结果：Heasked:"Whoareyou?"Heasked:'Whoareyou?'Heasked:\Whoareyou?\Heasked:Whoareyou?HeaskedWhoareyou?Heasked:Whoareyou?DOS下运行！将字符串合并

字符串之间用操作符“+”能够实现合并，即将两个字符串连接在一起。如："Hello!"+"MynameisMary."等价于："Hello!MynameisMary."连接一个字符串和一个非字符串值时，后者将被转换成字符串。例如：Stringrating="PG"+13;它会把rating的值设为PG13。这个特性常用于输出语句。例如：System.out.println("Theansweris:"+answer);常用的字符串处理示例

publicclassStringDemo2{ publicstaticvoidmain(Stringargs[]){ Strings=“Hello";//Hello前后各有二个空格

System.out.println("s="+s); //将s中的所有大写字母转变为小写

System.out.println("s.toLowerCase()="+s.toLowerCase()); //将s中的所有小写字母转变为大写

System.out.println("s.toUpperCase()="+s.toUpperCase()); //去掉前后空格

System.out.println("s.trim()="+s.trim()); //取子串(从指定的开始位置到最后) System.out.println("s.substring(5)="+s.substring(5)); //取子串(从指定的开始位置到指定的结束位置,但不包括结束位置) System.out.println("s.substring(3,5)="+s.substring(3,5)); //将s中所有的'l'替换为't'以生成新串

Stringnews=s.replace('l','t');System.out.println("replaceall'l'with't':"+news); }}见JB演示s=Hellos.toLowerCase()=hellos.toUpperCase()=HELLOs.trim()=Hellos.substring(5)=los.substring(3,5)=elreplaceall'l'with't':Hetto提取字符

/*从String中提取一个字符，可以使用charAt方法直接访问指定的字符;需一次提取多个字符，可以使用getChars方法*/classGetCharsDemo{ publicstaticvoidmain(Stringargs[]){ Strings="ThisisandemoofthegetCharsmethod.";intstart=11; intend=15; charbuf[]=newchar[end-start];//提取4个字符

s.getChars(start,end,buf,0); System.out.println(buf); }}结果demo

比较两个字符串

classequalsDemo{ publicstaticvoidmain(Stringargs[]){ Strings1="Hello"; Strings2="Hello"; Strings3="Good-bye"; Strings4="HELLO"; System.out.println(s1+"equals"+s2+"->"+s1.equals(s2)); System.out.println(s1+"equals"+s3+"->"+s1.equals(s3)); System.out.println(s1+"equals"+s4+"->"+s1.equals(s4));System.out.println(s1+"equalsIgnoreCase"+s4+"->"+s1.equalsIgnoreCase(s4)); }}HelloequalsHello->trueHelloequalsGood-bye->falseHelloequalsHELLO->falseHelloequalsIgnoreCaseHELLO->true/*比较字符串是否相等，可以使用String的equals方法（完全匹配）和equalsIgnoreCase方法(忽略字符的大小写区别）*/例：排序

/*字符串的排序，可以使用String的compareTo方法。如果返回负值，那么该串比参数中的串要小；如果为正数，该串比参数中的串要大；若为0，则表示两串相等。*/classSortString{ staticStringarr[]={"Now","is","the","all"}; publicstaticvoidmain(Stringargs[]){ for(intj=0;j<arr.length;j++){ for(inti=j+1;i<arr.length;i++){ if(arr[i]pareTo(arr[j])<0){ Stringt=arr[j]; arr[j]=arr[i]; arr[i]=t; } } System.out.println(arr[j]); } }}※

程序的输出结果是一个以字母顺序排列的单词表：Nowallisthe

从这个例子的结果可以看出，compareTo区分字母的大小写。词Now排在最前是因为它以大写字母开始，在字符集中大写字母A~Z排在前，小写字母a~z排在后。排在前面的字符对应的值小，排在后面的字符对应的值大。可见ASCII码的重要性！结果Nowallisthe※

publicclassStringCharacters{publicstaticvoidmain(String[]args){//TextstringtobeanalyzedStringtext="Tobeornottobe,thatisthequestion;Whether'tisnoblerinthemindtosuffer"+"theslingsandarrowsofoutrageousfortune,ortotakearmsagainstaseaoftroubles,"+"andbyopposingendthem?";intspaces=0,//Countofspacesvowels=0,//Countofvowelsletters=0;//Countoflettersfor(inti=0;i<text.length();i++)//Analyzeallthecharactersinthestring{charch=Character.toLowerCase(text.charAt(i));//Checkforvowelsif(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')++vowels;if(Character.isLetter(ch))//Checkforletters++letters;if(Character.isWhitespace(ch))//Checkforspaces++spaces;}System.out.println("Thetextcontainedvowels:"+vowels+"\n"+"consonants:"+(letters-vowels)+"\n"+"spaces:"+spaces);}}统计各类字符数量publicclassFindCharacters{publicstaticvoidmain(String[]args){//TextstringtobeanalyzedStringtext="Tobeornottobe,thatisthequestion;"+"Whether'tisnoblerinthemindtosuffer"+"theslingsandarrowsofoutragousfortune,"+"ortotakearmsagainstaseaoftroubles,"+"andbyopposingendthem?";intandCount=0;//Numberofand'sinttheCount=0;//Numberofthe'sintindex=-1;//CurrentindexpositionStringandStr="and";//SearchsubstringStringtheStr="the";//Searchsubstring

统计串的数量//Searchforwardsfor"and"index=text.indexOf(andStr);//Find1st'and'while(index>=0){++andCount;index+=andStr.length();//Steptopositionafterlast'and'index=text.indexOf(andStr,index);}//Searchbackwardsfor"the"index=text.lastIndexOf(theStr);//Findlast'the'while(index>=0){++theCount;index-=theStr.length();//Steptopositionbeforelast'the'index=text.lastIndexOf(theStr,index);}System.out.println("Thetextcontains"+andCount+"ands\n"+"Thetextcontains"+theCount+"thes");}}7.2.2字符串变量与StringBuffer类

1．创建StringBuffer类对象

StringBuffer类对象表示的是字符串变量，每一个StringBuffer类对象都是可以扩充和修改的字符串变量。以下是常用的StringBuffer类构造函数：（1）publicStringBuffer（）（2）publicStringBuffer（intlength）

（3）publicStringBuffer（Stringstr）

2．StringBuffer类对象的常用方法（1）StringBuffer类对象的扩充

StringBuffer类提供两组方法用来扩充StringBuffer对象所包含的字符，分别是：

1）publicStringBufferappend（Objectobj）

append方法用于扩充StringBuffer对象所包含的字符，该方法将指定的参数对象转化为字符串后，将其附加在原来的StringBuffer对象之后，并返回新的StringBuffer对象。附加的的参数对象可以是各种数据类型的，如int、char、String、double等。2）publicStringBufferinsert（

int插入位置，参数对象类型，参数对象名）该方法将指定的参数对象转化为字符串后，将其插入在原来的StringBuffer对象中指定的位置，并返回新的StringBuffer对象。（2）StringBuffer类对象的长度与容量一个StringBuffer类对象的长度指的是它包含的字符个数；容量指的是被分配的字符空间的数量。

1）publicintlength（）该方法返回当前StringBuffer类对象包含的字符个数。

2）publicintcapacity（）该方法返回当前StringBuffer类对象分配的字符空间的数量。

（3）StringBuffer类对象的修改

publicvoidsetCharAt(intindex,charch)

该方法将当前StringBuffer对象中的index位置的字符替换为指定的字符ch。（4）字符串的赋值和加法字符串是在程序中要经常使用的数据类型，在Java编译系统中引入了字符串的赋值和加法操作。

【例6.4】反转字符串中的字符7.3数组

数组是一个长度固定的数据结构，它存储多个相同类型的数值。数组直接被Java编程语言所支持，但是无论数组是由原始类型构成，或者带有其它类数据，数组也是一个对象。数组是一个Object类的一个不明显的扩展，所以可以指定一个数组给一个类型定义为Object的变量。数组是相同类型的数据元素按顺序组成的一种复合数据类型，元素在数组中的相对位置由下标来指明。数组中的每个元素通过数组名加数组下标进行引用。数组作为一种特殊的数据类型具有以下特点：一个数组中所有的元素应该是同一类型；数组中的元素是有顺序的；数组中的一个元素通过数组名和数组下标来确定。数组有一维数组和多维数组之分。IntroducingArraysdouble[]myList=newdouble[10]Arrayisadatastructurethatrepresentsacollectionofthesametypesofdata.Javatreatsthesearraysasobjects.AnArrayof10Elements

oftypedouble

7.3.1一维数组一维数组的声明（declaration）与创建（creating）同其他变量一样，在使用数组前，必须先声明它。数组声明的格式为：类型

数组名[]；其中类型指出了数组中各元素的数据类型，包括基本类型和复合类型。数组名为一个标识符。“[]”部分指明该变量是一个数组类型变量。例如：int

list[];例如：int

list[];int

list[];声明了一个整型数组，数组中的每个元素为整型数。数组声明时，也可以将“[]”放在类型之后,例如：int[]list;它的效果和上面的例子一样。在声明数组时，不直接指出数组中元素的个数（即数组长度）。数组声明之后尚不能立即被访问，因为还没有为数组元素分配内存空间。如果试图在声明后直接给数组中的任一元素赋值，编译器将要提示如下信息：

Variablelistmaynothavebeeninitialized.

用new关键字来创建数组在数组声明之后为数组元素分配存储空间，同时对数组元素进行初始化。new语句指明了分配类型以及由一个正整数表示的数组长度，其格式如下：数组名=

new类型

[数组长度]；例如：list=new

int[3];可以为整型数组list分配3个整数元素所占据的内存空间，并使每个元素初值为0。把数组的声明和创建合在一起为简化起见，还可以把数组的声明和创建合在一起，如：类型

数组名[]=new

类型

[数组长度]；例如：int

list[]=newint[3];

这个语句等同于下面两个语句：intlist[];list=newint[3];用new关键字为一个数组分配内存空间后，系统将为每个数组元素都赋予一个初值，这个初值取决于数组的类型。所有数值型数组元素的初值为0，字符型数组元素的初值为一个不可见的ISO控制符（’\u0000’），布尔型数组元素的初值为false，字符串数组和所有其他对象数组在创建时元素的初值为null。在实际应用中，用户应根据具体情况来对数组元素重新进行赋值。数组一旦创建之后，就不能再改变其长度。一维数组的初始化

数组初始化就是为数组元素指定初始值。通常在创建数组时，Java会使每个数组元素初始化为一个默认值。但在许多情况下，并不希望数组的初值为默认值，此时，就需要用赋值语句来对数组进行初始化。数组的初始化方式有两种。一种方式是像初始化简单类型一样自动初始化数组，即在声明数组的同时进行初始化。例如：inta[]={1,2,3,4,5};

上述语句声明并创建了数组a，并且为数组每个元素赋值即初始化，使a[0]=1，a[1]=2，a[2]=3，a[3]=4，a[4]=5。由上可见，数组初始化可由花括号“{}”括起的一串由逗号分隔的表达式组成，逗号（，）分隔数组元素中的值。在语句中不必明确指明数组的长度，因为它已经体现在所给出的数据元素个数之中了，系统会自动根据所给的元素个数为数组分配一定的内存空间，如上例中数组a的长度自动设置为5。应该注意的是，“{}”里的每一个数组元素的数据类型必须是相同的。【例7.1】划分成绩等级例：自动初始化数组下面的代码在整型数组month_days中保存了一年中每月的天数。classArray2{ publicstaticvoidmain(String[]args){intmonth_days[]={31,28,31,30,31,30,31,31,30,31,30,31};System.out.println("Mayhas"+month_days[4]+"days."); }}

运行结果：Mayhas31days.

数组的初始化的另一种方式是在声明之后再创建数组，然后为每个元素赋值。

InitializingArraysUsingaloop: for(inti=0;i<myList.length;i++) myList[i]=(double)i;Declaring,creating,initializinginonestep: double[]myList={1.9,2.9,3.4,3.5};一维数组元素的使用

声明了一个数组，并用new语句为它分配了内存空间后，就可以在程序中像使用任何变量一样来使用数组元素，即可以在任何允许使用变量的地方使用数组元素。数组元素的标识方式为：数组名[下标]

其中下标为非负的整型常数或表达式，其数据类型只能为byte，short，int，而不能为long。如a[3]，b[i](i为整型)，c[i*5]等。下标的取值范围从0开始，一直到数组的长度减1。int

list[]=newint[3];它有3个元素，分别为：list[0]，list[1]和list[2]。（注意：不存在list[3]）Java在对数组元素操作时会对数组下标进行越界检查，以保证安全性。若在Java程序中超出了对数组下标的使用范围（例如：数组的最大下标为5，但是在程序中存取了下标为8或-4的元素），则在运行此程序时将出现如下错误信息：

Exceptioninthread"main"java.lang.ArrayIndexOutOfBoundsException※

数组属性length

在Java中，对于每个数组都有一个属性length来指明其长度（即该数组可以容纳的元素的个数），由程序自动计算。例如：list.length指明了数组list的长度。如下面的这段程序，就是给每个元素赋值，并将其值送往标准输出设备。例：数组元素的赋值与输出

classArray1{ publicstaticvoidmain(String[]args){ intlist[]=newint[5]; System.out.println("list数组的长度为："+list.length); for(inti=0;i<list.length;i++){list[i]=i*5;System.out.println("list["+i+"]="+list[i]); } }}运行结果：list数组的长度为：5list[0]=0list[1]=5list[2]=10list[3]=15list[4]=20publicclassBubbleSort{publicstaticvoidmain(Stringargs[]){inti,j;intintArray[]={30,1,-9,70,25};intl=intArray.length;for(i=1;i<l;i++)for(j=0;j<=l-i-1;j++)if(intArray[j]>intArray[j+1]) {intt=intArray[j]; intArray[j]=intArray[j+1]; intArray[j+1]=t; } for(i=0;i<l;i++)System.out.println(intArray[i]+"");}}例6-3：用冒泡排序法对一维数组中的元素按值从小到大进行排序，并输出最终结果

运行结果：-91253070经典数组中元素的查找

publicclassLinearSearch{publicstaticvoidmain(String[]args){int[]list=newint[10];System.out.print("Thelistis");//Createthelistrandomlyanddisplayitfor(inti=0;i<list.length;i++){list[i]=(int)(Math.random()*100);System.out.print(list[i]+"");}System.out.println();数组中元素的查找

System.out.print("Enterakey");//Prompttheusertoenterakeyintkey=MyInput.readInt();intindex=linearSearch(key,list);if(index!=-1)System.out.println("Thekeyisfoundinindex"+index);elseSystem.out.println("Thekeyisnotfoundinthelist");}publicstaticintlinearSearch(intkey,int[]list)//Themethodforfindingakeyinthelist{for(inti=0;i<list.length;i++)if(key==list[i])returni;return-1;}}用二分法在数组中查找元素publicclassBinarySearch{//Mainmethodpublicstaticvoidmain(String[]args){int[]list=newint[10];//CreateasortedlistanddisplayitSystem.out.print("Thelistis");for(inti=0;i<list.length;i++){list[i]=2*i+1;System.out.print(list[i]+"");}System.out.println();//PrompttheusertoenterakeySystem.out.print("Enterakey");intkey=MyInput.readInt();intindex=binarySearch(key,list);if(index!=-1)System.out.println("Thekeyisfoundinindex"+index);elseSystem.out.println("Thekeyisnotfoundinthelist");}用二分法在数组中查找元素publicstaticintbinarySearch(intkey,int[]list){intlow=0;intup=list.length-1;returnbinarySearch(key,list,low,up);}//Usebinarysearchtofindthekeyinthelistbetweenlist[low]list[up]publicstaticintbinarySearch(intkey,int[]list,intlow,intup){if(low>up)//Thelisthasbeenexhaustedwithoutamatchreturn-1;intmid=(low+up)/2;if(key<list[mid])returnbinarySearch(key,list,low,mid-1);elseif(key==list[mid])returnmid;elseif(key>list[mid])returnbinarySearch(key,list,mid+1,up);return-1;}对象数组//TotalArea.java:TestpassinganarrayofobjectstothemethodpublicclassTotalArea{publicstaticvoidmain(String[]args){

Circle[]circleArray;//DeclarecircleArraycircleArray=createCircleArray();//CreatecircleArray//PrintcircleArrayandtotalareasofthecirclesprintCircleArray(circleArray);}//CreateanarrayofCircleobjectspublicstaticCircle[]createCircleArray(){Circle[]circleArray=newCircle[10];for(inti=0;i<circleArray.length;i++){circleArray[i]=newCircle(Math.random()*100);}//ReturnCirclearrayreturncircleArray;}对象数组

publicstaticvoidprintCircleArray(Circle[]circleArray){System.out.println("Theradiiofthecirclesare");for(inti=0;i<circleArray.length;i++){System.out.print("\t\t\t\t"+circleArray[i].getRadius()+'\n');}System.out.println("\t\t\t\t-------------------");//ComputeanddisplaytheresultSystem.out.println("Thetotalareasofcirclesis\t"+sum(circleArray));}

publicstaticdoublesum(Circle[]circleArray)//Addcircleareas{//Initializesumdoublesum=0;//Addareastosumfor(inti=0;i<circleArray.length;i++)sum+=circleArray[i].findArea();returnsum;}}7.3.2多维数组（multi-dimensionalarrays）

在Java中并不直接支持多维数组，所以，多维数组的声明是通过对一维数组的嵌套式声明来实现的，即用“数组的数组”来声明多维数组。例如二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。下面我们主要以二维数组为例来进行说明，更多维的情况是类似的。二维数组的声明与创建二维数组声明的格式为：类型

数组名[][]；例如：int

intArray[][];与一维数组一样，此时还没有为数组元素分配内存空间，还需要用new关键字来创建数组，然后才可以使用该数组的每个元素。※

对二维数组来说，分配内存空间有下面几种方法：

（1）直接为每一维分配空间，如：int

a[][]=new

int[2][3];该语句创建了一个二维数组a，其较高一维含两个元素，每个元素为由3个整型数构成的整型数组。此时该数组的示意图为：

a[0][0]a[0][1]a[0][2]a[1][0]a[1][1]a[1][2]（2）从最高维开始，分别为每一维分配空间，如：int

b[][]=newint[2][];//最高维含2个元素，每个元素为一个整型数组b[0]=newint[3];//最高维第一个元素是一个长度为3的整型数组b[1]=newint[5];//最高维第二个元素是一个长度为5的整型数组此时该数组的示意图为：b[0][0]b[0][1]b[0][2]b[1][0]b[1][1]b[1][2]b[1][3]b[1][4]注意：

在使用运算符new来分配内存时，对于多维数组至少要给出最高维的大小。例如：如果在程序中出现inta2[][]=newint[][];编译器将要提示如下错误：Arraydimensionmissing.二维数组元素的初始化

二维数组元素的初始化有两种方式：1.

直接对每个元素进行赋值；2.

在声明数组的同时进行初始化。如：

inta[][]={{2,3},{1,5},{3,4}};声明了一个3×2的数组，并对每个元素赋值。即：

a[0][0]=2a[0][1]=3a[1][0]=1a[1][1]=5a[2][0]=3a[2][1]=4二维数组元素的引用

对二维数组中每个元素，其引用方式为：数组名[下标1]

[下标2]其中下标1、下标2为非负的整型常数或表达式。如：a[2][3]、cc[i+2][j*3]（i，j为整数）等。每一维的下标取值都从0开始。例:创建一个44的int型矩阵，使其对角线上的元素初始化为1

/*二维数组的例子：打印一个4*4的int型矩阵*/classMatrix{publicstaticvoidmain(Stringargs[]){ intm[][]; m=newint[4][4]; m[0][0]=1; m[1][1]=1; m[2][2]=1; m[3][3]=1; System.out.println(m[0][0]+""+m[0][1]+""+m[0][2]+""+m[0][3]); System.out.println(m[1][0]+""+m[1][1]+""+m[1][2]+""+m[1][3]); System.out.println(m[2][0]+""+m[2][1]+""+m[2][2]+""+m[2][3]); System.out.println(m[3][0]+""+m[3][1]+""+m[3][2]+""+m[3][3]); }}结果1000010000100001例：构造杨辉三角形

classSj1{ publicstaticvoidmain(String[]args){ inti,j; //直接指定初值

intyanghui[][]={{1},{1,1},{1,2,1},{1,3,3,1},{1,4,6,