Java 数组

数组与容器的区别：

1）数组是一个简单的线性序列，其存储和随机访问对象引用序列的效率最高。但是数组对象的大小是固定的。
2）数组强调的是性能而不是灵活性，只有当性能成为问题时才使用数组，不然通常都使用容器。
3）数组可以持有基本类型，但有了额外的自动包装机制和泛型，在容器中持有基本类型就很容易了。泛型可以产生类型安全的容器，因此数组在这一方面毫无优势。

1. 基本类型数组直接保存值，而对象数组保存的是引用，且对象数组默认初始化值为null。

　　Arrays.toString(new String[2])       // 输出 [null, null]

2. 数组中构成矩阵的每个向量都可以具有任意的长度，称为粗糙数组。

　　Arrays.deepToString( new int[][]{ {1}, {21, 22} } )      // 输出 [[1], [21, 22]]

3. 使用Arrays.sort()对对象数组进行排序，类需要实现Comparable接口，否则将报异常。也可以编写Comparator实现类，再将其传入sort()方法。

public class Test {

    public static void main(String[] args) {
         Number[] nums = {new Number(2, 3), new Number(1, 4)};
         System.out.println("Before Sort: " + Arrays.toString(nums));
         Arrays.sort(nums);
         System.out.println("Comparable:  " + Arrays.toString(nums));
         Arrays.sort(nums, Collections.reverseOrder());
         System.out.println("Collections.reverseOrder(): " + Arrays.toString(nums));
         Arrays.sort(nums, new NumberComparator());
         System.out.println("Comparator:  " + Arrays.toString(nums));
    }
}

class Number implements Comparable<Number>{
    int i;
    int j;
    public Number(int i, int j){
        this.i = i;
        this.j = j;
    }
    
    @Override
    public int compareTo(Number n) {
        return i - n.i;
    }
    public String toString(){
        return "[" + i + ", " + j +"]";
    }
}

class NumberComparator implements Comparator<Number>{
    @Override
    public int compare(Number n1, Number n2) {
        return n1.j - n2.j;
    }
}

运行结果：

Before Sort:   [[2, 3], [1, 4]]
Comparable:  [[1, 4], [2, 3]]
Collections.reverseOrder():  [[2, 3], [1, 4]]
Comparator:  [[2, 3], [1, 4]]

4. 如果数组已经排好序了，可以使用Arrays.binarySearch()执行快速查找，对未排序的数组执行此方法，将产生不可预料的结果。