monospace;">16.数组

数组为什么特殊

• 数组与其他种类的容易有3方面的的区别：效率类型和保存基本类型的能力；访问速度快，但是对象的大小是固定的；
• 数组和容器如果发生越界，都会得到一个表示程序员错误的RuntimeException 异常；
• 数组在创建时就确定了所持有的类型，如果在编译时发现插入了错误的类型或者抽取不当类型，就会发生编译错误，当然，泛型容器也有相同的编译期检测的功能。

数组的初始化方式

class="cs">Object[] objs1 = new Object[5]
objs1[1] = new Object();
Object[] objes2 = {new Object(),new Object} 

int i = new int[]{1,2,3}

对象数组保存的是对象的引用，儿基本类型数组保存的是基本类型的值；

数组与泛型

通常，数组与泛型不能很好的结合。你不能实例化具有参数化类型的数组：

Peel<Banane> Peels = new Peels<Banana>[10]; //Illegal

檫除会移除参数类型信息，而数组必须知道他们所持有的确切类型，以强制保证类型安全。
但是你可以参数化数组本身：

//参数化类
class ClassParameter<T> {
    public T[] f( T[] arg ){ return arg; }
}

//参数化方法
class MethodParameter {
    public static <T> T[] f( T[] args ) { return args; }
}

public class ParameterizArrayType {
    public static void main(String[] args){
        Integer[] ints = {1,2,3,4,5};
        Double[] doubles = {1.1,1.2,1.3,1.4,1.5};
        //参数化类方式
        Integer ints2 = new ClassParameter<Integer>().f(ints);
        Double doubles2 = new ClassParameter<Double>().f(doubles);
        //参数话方法
        ints2 = MethodParameter.f(ints);
        doubles2 = MethodParameter.f(doubles);
    }
}

Arrays 实用功能

复制数组
用?System.arraycopy()?比用for循环复制要快很多：

int[] i = {1,2,3,4,5,6}
int[] j = {10,20,30,40,50,60,70}
/*
参数说明：1.源数组 2.源数组复制起始位置 3.目标数组 4.目标数组复制起始位置 5.要复制元素的个数
若复制元素长度超出了目标数组边界，会导致异常。
*/
System.arraycopy(i, 0, j, 0, i.length);
Sytem.out,print(Arrays.toString(j)); // j = [1,2,3,4,5,6,70]

如果复制的是对象数组，只会复制对象的引用，而不会拷贝对象本身，这被称作浅复制
System.arraycopy() 不会执行自动包装盒自动拆包，两个数组必须具有相同的确切类型。

数组的比较

Arrays.equals()
数组相等的条件是元素个数必须相等，并且对应位置的元素也相等，这可以通过对每一个元素使用equals做比较来判断（对于基本类型，需要使用基本类型的包装类型的equals()方法，例如，对于int类型使用Integer.equals()做比较）

数组元素的比较（数组排序）

Array.sorts()
Java 有两种方式来提供比较功能:
（1）使类实现java.lang.Comparable接口，使你的类具有比较能力。

public class CompType  implements Comparable<CompType> {
    int i, j;
    public CompType(int n1, int n2){
        i = n1;
        j = n2;
    }
    public int compareTo(CompType rv){
        return (i < rv.i ? -1 : (i == rv.i ? 0 : 1));
    }

    public String toString(){
        return "(i="+i+",j="+j+")";
    }

    public static void main(String[] args){
        CompType[] objs = new CompType[]{new CompType(2,3),new CompType(1,4)};
        Arrays.sort(objs);
        System.out.print(Arrays.toString(objs));
        //[(i=1,j =4 ),(i=2,j=3)]
    }   
}

(2) 创建实现了Comprator接口的单独的类
假设有人给你一个没有实现Comparable的类，或者实现的方式不是你所期望的，你可以创建一个实现了Comparator接口的单独的类，这个类有compare()和equals()两个方法，然而不一定要实现equals方法，因为Object已经有equals的默认实现了。

public class CompTypeComparator implements Comparator<CompType> {
    @Override
    public int compare(CompType o1, CompType o2) {
        return o1.j < o2.j ? -1 : (o1.j == o2.j ? 0 : 1);
    }
}

public class ComparatorTest{
    public static void main(String[] args) {
         CompType[] objs = new CompType[]{new CompType(2,3),new CompType(1,4)};
            Arrays.sort(objs,new CompTypeComparator());
            System.out.print(Arrays.toString(objs));
            //[(i=1,j=4), (i=2,j=3)]
    }
}

Collections.reverseOrder() 方法会产生一个Comparator,他可以翻转自然的排序顺序。

在已排序的数组中查找

如果数组已经排好序了，就可以使用Arrays.binarySearch()执行快速查找。如果要对未排序的数组使用binarySearch(),那么将产生不可预料的结果.
如果使用Comparator排序了某个对象数组，在使用binarySearch()时必须提供同样的Comparator。

public class ArraySearching {
    public static void main(String[] args) {
        int[] ints = {1,3,2,5,9,6};
        Arrays.sort(ints);
        int location = Arrays.binarySearch(ints, 9);
        System.out.println("location of "+ 9 + " is "+ location);
        //如果使用Comparator排序了某个对象数组，在使用binarySearch()时必须提供同样的Comparator
        CompType[] objs = new CompType[]{new CompType(2,3),new CompType(1,4),new CompType(5,5)};
        Arrays.sort(objs,new CompTypeComparator());
        System.out.println(Arrays.toString(objs));
        CompType key = new CompType(5,5);
        location = Arrays.binarySearch(objs, key,new CompTypeComparator());
        System.out.println("location of "+ key + " is "+ location);
    }