数组详解

在平时开发中，经常选用ArrayList容器来存放序列，确很少用数组，容器中已经包装了非常多的实用方法。由于数组是一个简单的线性序列，使元素的访问非常快，数组较容器还是有优点的：

1. 数组的访问效率比ArrayList高。 ArrayList的底层就是用数组实现的，如果new ArrayList()一个容器时没有指定一个容器的长度，那么默认容器初始化为10的长度，一旦向容器中放置的对象超过10个时，就要实现动态扩容，即需要另开辟一块大的内存，把原来容器中的对象搬过来。而数组在生命周期内是被固定大小的。
2. 数组可以持有基本类型，容器不可以。容器可以持有基本类型的包装类。

在开发中，数组较容器的唯一优点就是效率了，如果忽略这一特性，建议还是选用容器，毕竟数组一旦确定大小后，是不能更改的。

一、数组的两种基本用法

1、编译期限定数组具体类型
在堆上创建数组时就可以限定数组的类型，如果向数组中放置其它类型数据，在编译期就可以排错。

    public static void main(String[] args) {
        int[] iArrays = new int[5];
        iArrays[0] = 1;
        iArrays[1] = 2;
//      iArrays[2] = "abc"; //编译期出错
        System.out.println("数组长度：" + iArrays.length); //5
    }

注意：调用数组的length属性，得到的是数组的大小，而不是数组中实际元素的个数。

2、编译期不限定数组具体类型，即为Object类型
向Object类型的数组中放入对象后，如果用的时候不进行强制转型，不管在编译期还是运行期，都不能确定对象的具体类型，因而不能调用对象的方法。因此用的时候要在编译期进行强制转型。

    public static void main(String[] args) {
        Object[] oArrays = {new Dog(), new Cat()}; //初始数组长度为2
        Dog dog = (Dog) oArrays[0]; //编译期要强制转型
        Cat cat = (Cat) oArrays[1]; //编译期要强制转型
        dog.show();
        cat.show();
    }

二、数组实用方法

在java.util类库中已经提供了Arrays类，该类专门提供了操作数组的众多方法，下面举一些常用的方法。
1、数组填充
对创建的数组填充数据。

    public static void main(String[] args) {
        String[] str = new String[5];
        Arrays.fill(str, "00");
        System.out.println(Arrays.toString(str));
    }

输出：[00, 00, 00, 00, 00]

Arrays提供了各种数据类型的填充方法

2、复制数组

    public static void main(String[] args) {
        int[] iArrays = {1, 2, 3, 4, 5};
        int[] jArrays = {11, 12, 13, 14, 15, 16, 17};
        System.arraycopy(iArrays, 0, jArrays, 0, iArrays.length);
        System.out.println("iArrays : " + Arrays.toString(iArrays));
        System.out.println("jArrays : " + Arrays.toString(jArrays));
    }

输出：

iArrays : [1, 2, 3, 4, 5]
jArrays : [1, 2, 3, 4, 5, 16, 17]

3、比较数组是否相等
比较两个数组是否相等，首先保证两个数组的元素个数必须相等。然后分别比较其中的元素是否相等。

    public static void main(String[] args) {
        int[] iArrays = {1, 2, 3, 4, 5};
        int[] jArrays = {11, 12, 13, 14, 15};
        int[] kArrays = {1, 2, 3, 4, 5};
        System.out.println("iArrays == jArrays ? " + Arrays.equals(iArrays, jArrays)); //false
        System.out.println("iArrays == kArrays ? " + Arrays.equals(iArrays, kArrays)); //true
    }

本实例是比较的两个基本类型数组，如果是比较两个对象，jdk中自带的类对象或第三方创建的类对象，都是通过对象中的equal方法进行比较的，JDK中自带的类很多已经覆写了equal方法，自己创建的也应覆写。以String对象为例

    public static void main(String[] args) {
        String[] s1Arrays = {"aa", "bb", "cc"};
        String[] s2Arrays = {"aa", "bb", "cc"};
        System.out.println("s1Arrays == s2Arrays ? " + Arrays.equals(s1Arrays, s2Arrays)); //true
    }

Arrays类中还提供了其它类型数组的比较方法

4、数组排序
对于一个顺序凌乱的数组，可以调用Arrays中的sort方法进行排序。对于基本类型的数组，sort方法直接对数组进行排序；对于对象（包括自定义的类对象和JDK自带的类对象）类型的数组，sort通过实现Comparable接口中的compareTo方法进行判断排序的。

    public static void main(String[] args) {
        String[] s1Arrays = {"aa", "cc", "ee", "bb"};
        Arrays.sort(s1Arrays);
        System.out.println(Arrays.toString(s1Arrays));
    }

输出：[aa, bb, cc, ee]

Arrays还提供了其它数据类型的排序

5、在排序数组中查找元素
Arrays提供了binarySearch方法用于在数组中查找指定的元素，返回元素所在的位置。

    public static void main(String[] args) {
        int[] iArrays = {1, 8, 2, 10, 15, 9, 16, 3};
        Arrays.sort(iArrays);
        System.out.println(Arrays.toString(iArrays));
        /*排完序， 3在第2号位上*/
        System.out.println(Arrays.binarySearch(iArrays, 3)); //2
    }

排好序的数组，便于用二分法进行查找序列。但是如果数组没进行排序就直接进行查找，那么返回的结果是不可预知的。

    public static void main(String[] args) {
        int[] iArrays = {1, 8, 2, 10, 15, 9, 16, 3};
        System.out.println(Arrays.toString(iArrays));
        /*排完序， 3在第2号位上*/
        System.out.println(Arrays.binarySearch(iArrays, 3)); 
    }

输出：

[1, 8, 2, 10, 15, 9, 16, 3]
-2

可见，查找3元素所在的位置，实际却返回了-2。

Arrays还提供了其它类型的排序数组中查找元素

文章参考： Thinking in java