第3篇 Java中的数组及Array工具类

数组

1、数组的几个重要特征

• 连续存储空间（方便查找）

• 数组长度固定（灵活性差）

• 数组中只能存放相同的数据类型

• 数组下标从0开始计算

2、数组的声明定义

//定义int型数组ary0并声明长度为4
int ary0[] = new int[4];
//定义int型数组ary1同时赋初始值
int ary1[] = new int[]{1,2,3,4};

在上面对两个数组的定义中：赋值运算左边为对数组的定义，包括有数组类型、数组名；赋值运算右边为对数组开辟相应数据类型、对应长度的内存空间。

3、数组的遍历

通过ary0.length可以获取数组的长度

int ary0[] = new int[10];
//以数组长度为边界，根据下标对应赋值
for (int i = 0; i < ary0.length; i++) {
    ary0[i] = i;
}
//加强for循环，i依次指向数组每个元素，打印输出
for (int i : ary0) {
    System.out.println("ary0中第"+i+"个元素："+ary0[i]);
}

输出结果为：

ary0中第0个元素：0
ary0中第1个元素：1
ary0中第2个元素：2
ary0中第3个元素：3
ary0中第4个元素：4
ary0中第5个元素：5
ary0中第6个元素：6
ary0中第7个元素：7
ary0中第8个元素：8
ary0中第9个元素：9

 Arrays工具类

 Arrays类为java.util包里的一个工具类，提供对数组的一些操作方法，常用的有排序（sort）、填充（fill）、拷贝（copyOf）、查找（binarySearch）、判断相等（equals）等

1、排序（sort）

Arrays.sort() 支持的类型有char、double、int、byte、float等，同时还支持泛型，但需要自己实现Comparator接口

int ary1[] = new int[]{5,23,15,33,24,6,79,19};
//使用Arrys.sort()对ary1进行从小到大排序
Arrays.sort(ary1);
for (int i : ary1) {
    System.out.print(i+" ");
}

打印结果为：

5 6 15 19 23 24 33 79 

2、填充（fill）

将数组所有元素赋值为统一的填充值，如果对应元素已经有值了，则将覆盖原来的值

//Arrays.fill(int[] a, int val) 的实现：
public static void fill(int[] a, int val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
}

对数组ary2进行填充，将所有元素填充为9：

int ary2[] = new int[10];
Arrays.fill(ary2, 9);
for (int i : ary2) {
    System.out.print(i+" ");
}

最后填充所得到的结果为：

9 9 9 9 9 9 9 9 9 9 

3、拷贝（copyOf）

参数：

　　int[] original：被拷贝的数组

　　int newLength：被拷贝的长度，即original中被拷贝元素的长度

Arrays.copyOf() 函数会返回一个全新的数组，数组中的元素依次被赋值为orignal数组中前n个元素的值，n即被拷贝的长度，当n大于original数组的长度时，可用来对数组长度进行扩展，扩展部分元素值为0

int ary0[] = new int[]{1,2,3,4,5,6};
int ary1[];
//将ary0前三个元素拷贝给ary1
ary1 = Arrays.copyOf(ary0, 3);
//打印ary1的长度与元素值
System.out.println(ary1.length);
for (int i : ary1) {
    System.out.print(i+" ");
}

打印结果为：

3
1 2 3 

表明ary0中前3个元素【1，2，3】被复制给了一块新的内存空间，同时ary1指向该空间：

4、二分查找（binarySearch）

• 使用二分查找时，必须先将数组排序
• 一般用在查找元素是否存在
• 如果数组没有排序，结果无法确定
• 如果包含多个指定值，无法保证找到的是哪一个，如果找不到，则返回负数

int ary0[] = new int[]{1,2,5,4,3,6};
//对ary0中3这个元素进行查找
int index = Arrays.binarySearch(ary0, 3);
System.out.println("未排序的数组为：");
showAry(ary0);
System.out.println("未排序进行查找结果："+index);
//对ary0进行排序，再次查找
Arrays.sort(ary0);
System.out.println("排序的数组为：");
showAry(ary0);
index = Arrays.binarySearch(ary0, 3);
System.out.println("排序后进行查找结果："+index);
//ary0指向新的、存在多个相同元素数组
ary0 = new int[]{1,2,3,4,5,2,6,3,8};
//再次进行查找
Arrays.sort(ary0);
System.out.println("多值相同且排序过的数组：");
showAry(ary0);
index = Arrays.binarySearch(ary0, 3);
System.out.println("多值相同进行查找结果："+index);

打印结果为：

未排序的数组为：
1 2 5 4 3 6
未排序进行查找结果：-3
排序的数组为：
1 2 3 4 5 6
排序后进行查找结果：2
多值相同且排序过的数组：
1 2 2 3 3 4 5 6 8
多值相同进行查找结果：4

5、判断相等（equals）

使用Arrays.equals() 判断相等时，进行的是数组各元素的值的比对，而非对ary0和ary1所指向地址的比对，具体实现如下：

public static boolean equals(int[] a, int[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
}

区别如下：

int ary0[] = new int[]{1,2,3,4,5};
int ary1[] = new int[]{1,2,3,4,5};
//根据地址判断相等
System.out.println(ary0==ary1);        
//根据值判断相等
System.out.println(Arrays.equals(ary0, ary1));

所得打印结果为：

false
true

在这里要注意不要将其与object类下的equals()方法搞混了，因为object类的equals方法本质上还是使用的 ”==“ 比较运算符，所以所得结果还将是false

最后是一些练习

将数组 ary0={1,2,3,4,5}、ary1={6,7,8,9,10} 整合成一个新的数组并打印

int ary0[] = new int[]{1,2,3,4,5};
int ary1[] = new int[]{6,7,8,9,10};

//先将ary0拷贝进ary2，数组长度为两数组长度之和
int []ary2 = Arrays.copyOf(ary0,ary0.length+ary1.length);
//打印ary2
showAry(ary2);
//再将ary1中元素通过赋值的方法依次拷贝
for (int i = 0; i < ary1.length; i++) {
    ary2[i+ary0.length] = ary1[i];
}
//得到最后结果，打印ary2
showAry(ary2);

得到打印结果如下：

1 2 3 4 5 0 0 0 0 0 
1 2 3 4 5 6 7 8 9 10