Java學習筆記2——Arrays類

一、Arrays工具類
Arrays是針對數組操作的工具類。
Arrays不能實例化。內置了私有的默認構造函數，保證其不能被實例化。
位於java.util包

private Arrays() {}

1、成員方法
（1）排序sort方法：對不同類型進行排序。
A、對基本類型的排序
支持以下基本類型：char,byte,short,int,long,float,double進行排序。以下以int爲例。
①對數組a進行排序：public static void sort(int[] a)
②對數組a進行指定範圍的排序：public static void sort(int[] a, int fromIndex, int toIndex)

對數組a的下標從fromIndex到toIndex-1的元素排序，toIndex位置的元素不參與排序。

例子：

public class ArraysDemo {
    public static void main(String[] args) {
        int[] a = {1,4,2,10,6,9};
        Arrays.sort(a);
        for(int i : a){
            System.out.print(i+" ");
        }
        //結果：1 2 4 6 9 10 
    }
}

public class ArraysDemo {
    public static void main(String[] args) {
        int[] a = {1,4,2,10,6,9};
        Arrays.sort(a,1,4);
        for(int i : a){
            System.out.print(i+" ");
        }
        //結果：1 2 4 10 6 9 
    }
}

B、對Object類型進行排序
它要求傳進來的數組對象必須實現Comparable接口。

①對Object數組進行排序：public static void sort(Object[] a)
②對Object數組進行指定範圍的排序：public static void sort(Object[] a, int fromIndex, int toIndex)
③帶泛型參數的接口，它需要指定一個比較器：public static void sort(T[] a, Comparator c)

例子：
以自定義User類爲例子，實現Comeparable< T >接口，重寫compareTo接口

public class User implements Comparable<User> {
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(User user) {
        return age - user.getAge();
    }

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

public class ArraysDemo {
    public static void main(String[] args) {
        User[] users = new User[5];
        users[0] = new User("A",15);
        users[1] = new User("B",25);
        users[2] = new User("C",18);
        users[3] = new User("D",37);
        users[4] = new User("E",28);
        Arrays.sort(users);
        for(User u : users){
            System.out.println(u);
        }
    }
}

結果：
User [name=A, age=15]
User [name=C, age=18]
User [name=B, age=25]
User [name=E, age=28]
User [name=D, age=37]

在Arrays工具類中，內部還使用了多種排序方法進行排序，例如mergeSort（歸併排序），快速排序等等。

（2）二分查找方法：public static int binarySearch(int[] arr,int value)
使用二分查找的算法進行查找。

例子：

public class ArraysDemo {  
    public static void main(String[] args) {  
        int[] a = { 12, 23, 34, 45, 56, 67 };  
        System.out.println(Arrays.binarySearch(a, 23));  
        System.out.println(Arrays.binarySearch(a, 27));  
    }  
}  

（3）把數組變成字符串：仍然以int爲例子。
public static String toString(int[] a)

（4）將一組對象轉換成列表：public static < T > List< T > asList(T… a)

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

將一組對象轉換成列表，這裏返回的ArrayList並非平常用的java.util.ArrayList ，而是Arrays.java中定義的一個簡單的靜態內部類–ArrayList。它不支持添加和移除元素，不支持擴容。

靜態內部類——ArrayList

 private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, java.io.Serializable{
    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;

    ArrayList(E[] array) {
            if (array==null)
                throw new NullPointerException();
        a = array;
    }

    public int size() {
        return a.length;
    }

    public Object[] toArray() {
        return a.clone();
    }

    public <T> T[] toArray(T[] a) {
        int size = size();
        if (a.length < size)
        return Arrays.copyOf(this.a, size,
                     (Class<? extends T[]>) a.getClass());
        System.arraycopy(this.a, 0, a, 0, size);
        if (a.length > size)
        a[size] = null;
        return a;
    }

    public E get(int index) {
        return a[index];
    }

    public E set(int index, E element) {
        E oldValue = a[index];
        a[index] = element;
        return oldValue;
    }

        public int indexOf(Object o) {
            if (o==null) {
                for (int i=0; i<a.length; i++)
                    if (a[i]==null)
                        return i;
            } else {
                for (int i=0; i<a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

        public boolean contains(Object o) {
            return indexOf(o) != -1;
    }
}

（5） 獲得哈希值：（依然以int爲例）
public static int hashCode(int a[])

例子

public class ArraysDemo {
    public static void main(String[] args) {
        int[] a = {1,3,54,74,22};

        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.hashCode(a));
        System.out.println(Arrays.asList(a));
    }
}

（6）填充：以int爲例
①public static void fill(int[] a, int val)：將數組中的數據替換成val
②public static void fill(int[] a, int fromIndex, int toIndex, int val)：將數組中的數據，從fromIndex到toIndex-1全部替換成val

還有對Object對象的填充，此處省略。

public class ArraysDemo {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6,7,8,9,10};
        Arrays.fill(a, 1);
        for(int i : a){
            System.out.print(i+" ");
        }
        Arrays.fill(a,1,4,2);
        for(int i : a){
            System.out.print(i+" ");
        }

    }
}

（7）比較兩個數組的數據是否相同
public static boolean equals(int[] a, int[] a2)

 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;
}

public static boolean equals(Object[] a, Object[] a2)
具體需要實現什麼邏輯的比較，需要重寫對象中的equals方法。

 public static boolean equals(Object[] a, Object[] 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++) {
            Object o1 = a[i];
            Object o2 = a2[i];
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }
        return true;
    }

---

今天大致看了一下Arrays的部分源碼跟其他人對於Arrays的講解與看法，Arrays工具類具有很多方便的功能，例如sort方法，但是裏面部分是屬於不穩定排序，所以也存在一點的風險吧。然後到Arrays內的hashCode，equals方法，到對object對象的排序需要實現Comparable< T >接口，重寫compareTo方法。Arrays工具類也可以適用於很多方面。