Java数组与容器应用总结Word格式文档下载.docx
《Java数组与容器应用总结Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《Java数组与容器应用总结Word格式文档下载.docx（47页珍藏版）》请在冰豆网上搜索。
equals（）—比较两个数组是否相等；
fill（）—用某个值填充整个数组；
sort（）—对数组排序；
binarySearch（）—在已经排序的数组中查找元素。
1.1数组的初始化
基本类型的数组如果是数值型的，就被自动初始化为0；
字符型（char）数组被初始化为（char）0；
布尔（boolean）数组被初始化为false。
非基本类型的对象数组，在新生成一个数组对象时，其中所有的引用被自动初始化为null，所以检查其中的引用是否为null，即可知道数组的某个位置是否存有对象。
基本类型的数组，直接存储基本类型数据的值；
对象数组，存储指向堆中对象的引用。
所有数组（无论它们的元素是对象还是基本类型）都有一个固有成员length，可以通过它获知数组内包含了多少个元素，但不能对其修改。
classSimpleClass{}
classMyArray{
publicstaticvoidmain（String[]args）{
//基本类型数组初始化
int[]a=newint[5];
//基本类型数组对象创建，数组元素值被初始化为0
for（inti=0;
i<
a.length;
i++）
a[i]=i*i;
int[]b={1,2,3,4,5};
//聚集初始化方式，此时b.length=5;
int[]c;
//声明而未初始化的局部变量
c=b;
//通过数组对象赋值，使c含有与数组b相同的内容，c.length=5
//对象数组初始化
SimpleClass[]sc;
//未初始化的局部变量，如果直接使用编译器会报错
sc=newSimpleClass[]{
newSimpleClass（）,newSimpleClass（）
};
//动态聚集初始化方式，此时sc.length=2
SimpleClass[]sc1=newSimpleClass[5];
//在栈中生成了一个数组对象sc1，
//该数组中的每个元素都是一个指向SimpleClass
//对象的引用，此时，并没有SimpleClass对象置
//入数组中。
sc[0]~sc[4]皆为null。
SimpleClass[]sc2=newSimpleClass[4];
for（inti=0;
sc2.length;
if（sc2[i]==null）//可以测试数组元素是否为null
sc2[i]=newSimpleClass（）;
SimpleClass[]sc3={
newSimpleClass（）,newSimpleClass（）,newSimpleClass（）
//聚集初始化方式，此时sc3.length=3
sc=sc3;
//将sc进行赋值，使sc指向另一个数组对象；
此时sc.length=3
//现在sc与sc3都指向堆中的同一个数组对象。
////多维数组初始化
int[][]a1={
{1,2,3,},
{4,5,6,},
Integer[][]a2={
{newInteger
（1）,newInteger
（2）},
{newInteger（3）,newInteger（4）},
{newInteger（5）,newInteger（6）},
Integer[][]a3;
a3=newInteger[3][];
a3.length;
i++）{
a3[i]=newInteger[3];
for（intj=0;
j<
a3[i].length;
j++）
a3[i][j]=newInteger（i*j）;
}
}
1.2填充数组—Arrays.fill（）
Arrays的fill（）方法，用一个值填充指定数组的各个位置。
对于保存对象的数组，就是复制同一个引用进行填充。
intsize=5;
boolean[]a1=newboolean[size];
byte[]a2=newbyte[size];
char[]a3=newchar[size];
short[]a4=newshort[size];
int[]a5=newint[size];
long[]a6=newlong[size];
float[]a7=newfloat[size];
double[]a8=newdouble[size];
String[]a9=newString[size];
Arrays.fill（a1,true）;
//a1:
[true,true,true,true,true]
Arrays.fill（a2,（byte）2）;
//a2:
[2,2,2,2,2]
Arrays.fill（a3,'
三'
）;
//a3:
[三,三,三,三,三]
Arrays.fill（a4,（short）4）;
//a4:
[4,4,4,4,4]
Arrays.fill（a5,5）;
//a5:
[5,5,5,5,5]
Arrays.fill（a6,6）;
//a6:
[6,6,6,6,6]
Arrays.fill（a7,7）;
//a7:
[7,7,7,7,7]
Arrays.fill（a8,8）;
//a8:
[8,8,8,8,8]
Arrays.fill（a9,"
a9"
//a9:
[a9,a9,a9,a9,a9]
Arrays.fill（a9,1,3,”Hi”）;
//a9:
[a9,Hi,Hi,a9,a9]
//fillrange:
[1,3）
可以指定填充位置的方法说明：
publicstaticvoidfill（int[]
a,
int
fromIndex,
toIndex,
val）
将指定的int值分配给指定int型数组指定范围中的每个元素。
填充的范围从索引fromIndex（包括）一直到索引toIndex（不包括）。
（如果fromIndex==toIndex，则填充范围为空。
）
参数：
a-要填充的数组
fromIndex-要使用指定值填充的第一个元素的索引（包括）
toIndex-要使用指定值填充的最后一个元素的索引（不包括）
val-要存储在数组所有元素中的值
抛出：
IllegalArgumentException-如果fromIndex>
toIndex
ArrayIndexOutOfBoundsException-如果fromIndex<
0或toIndex>
a.length
1.3复制数组—System.arraycopy（）
使用System.arraycopy（）方法复制数组，比用for循环复制要快很多。
int[]a1=newint[5];
int[]a2=newint[8];
Arrays.fill（a1,47）;
[47,47,47,47,47]
Arrays.fill（a2,99）;
//a2:
[99,99,99,99,99,99,99,99]
System.arraycopy（a1,0,a2,0,a1.length）;
[47,47,47,47,47,99,99,99]
//填充复制Object
Integer[]a3=newInteger[4];
Integer[]a4=newInteger[8];
Arrays.fill（a3,newInteger（47））;
//a3:
[47,47,47,47]
Arrays.fill（a4,newInteger（99））;
System.arraycopy（a3,0,a4,a4.length/2,a3.length）;
//a4:
[99,99,99,99,47,47,47,47]
方法使用说明：
publicstaticvoidarraycopy（Object
src,
srcPos,
Object
dest,
destPos,
length）
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
从src引用的源数组到dest引用的目标数组，数组组件的一个子序列被复制下来。
被复制的组件的编号等于length参数。
源数组中位置在srcPos到srcPos+length-1之间的组件被分别复制到目标数组中的destPos到destPos+length-1位置。
src-源数组。
srcPos-源数组中的起始位置。
dest-目标数组。
destPos-目标数据中的起始位置。
length-要复制的数组元素的数量。
IndexOutOfBoundsException-如果复制会导致对数组范围以外的数据的访问。
ArrayStoreException-如果因为类型不匹配而使得无法将src数组中的元素存储到dest数组中。
NullPointerException-如果src或dest为null。
1.4数组的比较—Arrays.equals（）
使用Arrays类的equals（）方法比较数组。
数组相等的条件时元素个数必须相等，并且对应位置的元素也相等，这可以通过对每一个元素使用equals（）做比较来判断。
对于基本类型，需要使用基本类型的包装类的equals（）方法，例如，对于int类型使用Integer.equals（）作比较。
int[]a1=newint[5];
int[]a2=newint[5];
Arrays.fill（a2,47）;
System.out.println（Arrays.equals（a1,a2））;
//output:
true
a1[0]=5;
//a1:
[5,47,47,47,47]
//output:
false
String[]s1=newString[5];
Arrays.fill（s1,"
Hi"
//s1:
["
"
]
String[]s2={"
System.out.println（Arrays.equals（s1,s2））;
1.5数组的排序—Arrays.sort（）
1.5.1基本类型数组的排序
基本类型数组的排序，可以直接使用Arrays的sort（）方法，按照数字升序进行排序。
对String数组排序时，排序算法依据词典顺序排序，大写字母开头的词都会放在前面，然后才是小写字母开头的词。
static
voidsort（int[]
a）//对指定的int型数组按数字升序进行排序。
a,int
fromIndex,int
toIndex）
//对指定int型数组的指定范围按数字升序进行排序。
范例：
int[]a={2,4,1,3,6,5};
//排序前：
a:
[2,4,1,3,6,5]
Arrays.sort（a）;
//排序后：
[1,2,3,4,5,6]
//对于字符串数组是按照“自然顺序”排序，即“字典顺序”
String[]s={"
cannon"
a"
abuse"
accurate"
desk"
block"
Arrays.sort（s）;
//排序后：
s:
[a,abuse,accurate,block,cannon,desk]
Arrays.sort（s,3,6）;
//部分排序：
s:
[cannon,a,abuse,accurate,block,desk]
Arrays.sort（s,Collections.reverseOrder（））;
//指定比较器Comparator
//逆序排序：
[desk,cannon,block,accurate,abuse,a]
1.5.2对象数组的排序
针对对象数组中对象进行排序，首要解决的问题是，需要一个可以在两个对象之间进行比较的方法。
Java有两种方式提供比较功能。
第一种是实现java.lang.Comparable接口。
即被比较的对象的类型需要实现Comparable接口，覆盖接口中的CompareTo（）方法。
Comparable接口定义如下：
publicinterfaceComparable{
intcompareTo（T
o）;
如果待排序的对象所属的类型实现了上述接口，那么，在调用Arrays类型的以下两种排序方法时，sort会自动去调用CompareTo（）方法，完成两个对象之间的比较，最终完成数组的排序。
voidsort（Object[]
a）//根据元素的自然顺序对指定对象数组按升序进行排序。
toIndex）//根据元素的自然顺序对指定对象数组的指定范围
//按升序进行排序。
使用范例：
importjava.util.*;
classElementClassimplementsComparable
{
privateintnumber;
publicElementClass（intnum）{
number=num;
publicintgetNumber（）{
returnnumber;
publicintcompareTo（Objectobj）{
return（number>
（（ElementClass）obj）.number）?
1:
（number==（（ElementClass）obj）.number?
0:
-1）;
classCompareTest
publicstaticvoidmain（String[]args）
{
Randomrand=newRandom（）;
ElementClass[]ec=newElementClass[5];
ec.length;
ec[i]=newElementClass（rand.nextInt（10））;
System.out.print（ec[i].getNumber（）+"
"
//排序前:
[37952]
}
System.out.println（）;
Arrays.sort（ec）;
//sort（）方法会自动调用ElementClass实现的compareTo函数
//排序后:
[23579]
第二种是实现java.util.Comparator接口。
得到一个可以对数组中对象进行比较的比较器，然后把这个比较器传递给sort（）方法，完成比较与最终的数组排序（基本类型的数组无法用Comparator进行排序）。
Comparator接口定义如下：
publicinterfaceComparator{
intcompare（T
o1,T
o2）;
//比较用来排序的两个参数。
booleanequals（Object
obj）;
//指示某个其他对象是否“等于”此Comparator。
Comparator接口中的函数需要同时实现。
假设实现的比较器名为MyComparator，其实现形式如下：
publicMyComparatorimplementsComparator{
publicintcompare（T
o2）{……}
publicbooleanequals（Object
obj）{……}
有了比较器之后，调用下面的sort（）方法完成比较与排序：
staticvoidsort（T[]
a,newMyComparator）//根据指定比较器产生的顺序对指定对象数组进行排序。
staticvoidsort（T[]
toIndex,newMyComparator）//根据指定比较器产生的顺序对指
//定对象数组的指定范围进行排序。
classElementClass
classMyComparatorimplementsComparator
publicintcompare（Objectobj1,Objectobj2）{
intnum1=（（ElementClass）obj1）.getNumber（）;
intnum2=（（ElementClass）obj2）.getNumber（）;
return（num1>
num2?
1:
（num1==num2?
0:
-1））;
[91765]
Arrays.sort（ec,newMyComparator（））;
//将比较器传递给sort进行排序
[15679]
1.6在已排序的数组中查找—Arrays.binarySearch（）
如果数组已经排好序了，可以使用Arrays.binarySearch（）执行快速查找。
对未排序的数组使用binarySearch（）的结果不可预料。
如果找到了目标，Arrays.binarySearch（）的返回值等于或大于0。
否则，返回负值，表示为了保持数组的排序状态，此目标元素应该插入的位置。
这个负值的计算方式是：
-（插入点）–1
“插入点”是指，第一个大于查找对象的元素在数组中的位置，如果所有数组元素都小于要查找的对象，“插入点”就等于a.size（）。
如果数组包含重复的元素，则无法保证找到的是哪一个。
此算法并不是为包含重复元素的数组专门设计的，但是仍然可用。
如果使用Comparator排序某个对象数组，在使用binarySearch（）时必须提供同样的Comparator。
intbinarySearch（Object[]
a,Object
key）//使用二分搜索法来搜索指定数组，以获得指定对象。
toIndex,Object
key）//使用二分搜索法来搜索指定数
//组的范围，以获得指定对象。
例如：
publicintgetNumber
升级会员 