Java数组操作利器：Arrays工具类

java.util.Arrays提供大量的工具方法来操作数组，这些方法全是静态方法。

1 便捷创建List

public static <T> List<T> asList(T... a)

返回一个受指定数组支持的固定大小的列表。

public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

典型用法：List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

2 二分查找

有多个重载的方法。比如，

public static int binarySearch(long[] a,long key)
public static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
public static <T> int binarySearch(T[] a,int fromIndex,int toIndex,T key,Comparator<? super T> c)

二分查找要求数组是有序的，并且数组中的元素是可以比较大小的。

3 复制数组

有多个重载的版本。

（1）public static <T> T[] copyOf(T[] original, int newLength)
复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。这个方法会把original数组复制成一个新数组，其中length是新数组的长度。如果length小于original数组的长度，则新数组就是原数组的前面length个元素，如果length大于original数组的长度，则新数组就是原数组的所有元素，后面补充0，false或者null。

（2）public static <T> T[] copyOfRange(T[] original, int from, int to)

与上面的方法类似，只是这个方法只复制original数组的from索引到to索引的元素。

System.arraycopy方法

System类的arraycopy方法签名如下：

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

Arrays类中所有复制数组的方法底层都是调用System.arraycopy方法，这是一个本地静态方法。对于基本类型数组，该方法实现了深复制；然而对于对象数组而言，System.arraycopy方法只是浅复制。也就是说这个方法只是将原来的数组对象本身复制一份，并没有将该数组中各个数据元素所指向的对象复制一份。也就是说，新的数组中的各个数组元素仍然和原数组中的各个元素指向的是同一个对象。这样的话就会产生一个问题：修改新数组中的某个数组元素所指向的对象的属性的话，那么以前的那个数组对应的数组元素的对象也被修改了。

看例子:

import java.util.Arrays;

class Student {
    private static int count = 1000;
    private int id = count++;
    private String name = "No." + id;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + "]";
    }

}

public class ArraycopyTest {

    public static void main(String[] args) {

        Student[] old = new Student[] { new Student(), new Student(),
                new Student(), };
        Student[] fresh = new Student[5];

        System.arraycopy(old, 0, fresh, 0, old.length);

        System.out.println("  old:" + Arrays.toString(old));
        System.out.println("fresh:" + Arrays.toString(fresh));

        fresh[2].setName("Obama");
        fresh[2].setId(9999);

        System.out.println("  old:" + Arrays.toString(old));
        System.out.println("fresh:" + Arrays.toString(fresh));
    }
}

输出结果：

old:[Student [id=1000, name=No.1000], Student [id=1001, name=No.1001], Student [id=1002, name=No.1002]]
fresh:[Student [id=1000, name=No.1000], Student [id=1001, name=No.1001], Student [id=1002, name=No.1002], null, null]
   old:[Student [id=1000, name=No.1000], Student [id=1001, name=No.1001], Student [id=9999, name=Obama]]
fresh:[Student [id=1000, name=No.1000], Student [id=1001, name=No.1001], Student [id=9999, name=Obama], null, null]

程序本来是想修改fresh数组的fresh[2]中的Student的信息，结果old数组中的对应的Student的信息也被修改了。

先看看内存图，这是程序执行fresh[2].setName("Obama");fresh[2].setId(9999);两行代码之前的内存布局：

下面是程序执行fresh[2].setName("Obama");fresh[2].setId(9999);两行代码之后的内存布局：

原因很显然，不多说了。

补充资料：Object中的clone方法

Object中的clone方法也与System.arraycopy类似，clone是一个protected方法。如果对象中的所有数据域都属于数值或者基本类型，这样的拷贝没有问题。但是如果在对象中包含了子对象的引用，拷贝的结果会使得两个域引用指向同一个子对象，因此原始对象和克隆对象共享这部分信息。也就是说，默认的clone操作是浅拷贝，它没有克隆包含在对象中的内部对象。

由于clone方法被声明为protected，所以只有子类能调用受保护的clone方法克隆它自己。其他对象不能调用某个对象的clone方法。

解决方案：重新定义clone方法，并将它声明为public，并实现一个标记接口Cloneable，告诉其他对象可以调用该类的clone方法。

比如可以对上述的Student类重写如下clone方法：

@Override
    public Student clone() throws CloneNotSupportedException{
        Student cloned = (Student)super.clone();
        cloned.name = new String(name); //对于非基本类型的数据域要重新赋值
        return cloned;
    }

4 打印数组元素

public static String toString(Object[] a)
返回指定数组内容的字符串表示形式。形如[element[0].toString,element[1].toString,...]

public static String deepToString(Object[] a)
此方法是为了将多维数组转换为字符串而设计的。

5 两个数组是否相等

public static boolean equals(Object[] a,Object[] a2)
如果两个指定的 Objects 数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。如果 (e1==null ? e2==null : e1.equals(e2))，则认为 e1 和 e2 这两个对象是相等的 。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。

public static boolean deepEquals(Object[] a1, Object[] a2)
如果两个指定数组彼此是深层相等 的，则返回 true。此方法适用于任意深度的嵌套数组。

6 哈希值

public static int hashCode(Object[] a)
基于指定数组的内容返回哈希码。这个哈希码有数组元素的哈希码组成。

public static int deepHashCode(Object[] a)
基于指定数组的“深层内容”返回哈希码。

7 数组赋值

public static void fill(Object[] a, Object val)
将数组的所有数组元素取值设置为val。

8 排序

public static void sort(short[] a)
根据元素的自然顺序对指定对象数组按升序进行排序。数组中的所有元素都必须实现 Comparable 接口。

public static <T> void sort(T[] a,Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组进行排序。