轉載自：https://www.cnblogs.com/dengyungao/p/7525067.html

java：陣列操作工具類 java.util.Arrays包 主要方法詳解

Arrays類位於Java.util包下，是一個對陣列操作的工具類，現將Arrays類中的方法做一個總結（JDK版本：1.6.0_34）。Arrays類中的方法可以分為八類：

• sort(對陣列排序)
• binarySearch（二分法查詢陣列中的元素）
• equals（比較兩個陣列是否相等）
• fill（對陣列中的指定位置填充相同的內容）
• copyOf（陣列拷貝）
• asList（將陣列轉換為一個固定的List物件）
• hashCode（計算陣列的雜湊值）
• toString（以特定格式輸出陣列）

（1）簡單例子示範

1.array轉化為List ，利用java.util.Arrays中的asList方法

Integer []arr = {1,2,3};

System.out.println(arr);

List<Integer> list = Arrays.asList(arr);

System.out.println(list);

輸出結果：

[Ljava.lang.Integer;@659e0bfd

[1, 2, 3]

2.array的排序問題，利用java.util.Arrays中的sort方法排序

Integer a[]={1,5,3,8,4};

Arrays.sort(a);//實現了對陣列從小到大的排序

List<Integer> aList = Arrays.asList(a);

System.out.println(Arrays.asList(aList));

3.陣列元素的定位查詢，返回陣列的下標

使用java.util.Arrays中的binarySearch方法搜尋該值的下標

int find;

int b[]={1,5,3,8,4};

find=Arrays.binarySearch(b , 8);

System.out.println(find);

輸出：3

4.列印陣列array的數值

int c[]={1,5,3,8,4};

String aString =Arrays.toString(c);//String 前的a和括號中的a均表示陣列名稱

System.out.println(aString);//String 前的a表示陣列名稱

輸出：[1, 5, 3, 8, 4]

5.檢視陣列中是否包含特定的值，使用java.util.Arrays的array的轉化為List的方法，然後使用list中的contains方法

int a[]={1,5,3,8,4}; boolean b=Arrays.asList(a).contains(1); System.out.println(b);//注意：b的值只可能是true或false

輸出：true

（2）方法的通用寫法示範

說明：以下的程式碼均為摘抄的java.util.Arrays類中的原始碼，註釋為本人所加。

sort

//對陣列a進行排序
public static void sort(long[] a) {
        sort1(a, 0, a.length);
    }
//對陣列a中的從fromIndex(包含）至toIndex(不包含)的值進行排序
public static void sort(long[] a, int fromIndex, int toIndex) {
        rangeCheck(a.length, fromIndex, toIndex);
        sort1(a, fromIndex, toIndex-fromIndex);
    }
/**
對基本型別陣列的排序有以上兩種方法，這裡只摘出了long型別的。sort1方法篇幅原因沒有摘出來，在sort1方法中使用的是經過調優的快速排序演算法（tuned quicksort）。
**/
..........
..........
..........
//對物件型別進行排序
public static void sort(Object[] a) {
        Object[] aux = (Object[])a.clone();
        mergeSort(aux, a, 0, a.length, 0);
    }
//對物件a中的從fromIndex(包含）至toIndex(不包含)的值進行排序
public static void sort(Object[] a, int fromIndex, int toIndex) {
        rangeCheck(a.length, fromIndex, toIndex);
        Object[] aux = copyOfRange(a, fromIndex, toIndex);
        mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
    }
/**
對物件型別陣列的排序有以上兩種方法，在mergeSort方法中使用的是經過修改的歸併排序演算法（modified mergesort）。
**/

binarySearch

 public static int binarySearch(long[] a, long key) {
    return binarySearch0(a, 0, a.length, key);
    }
 public static int binarySearch(long[] a, int fromIndex, int toIndex,
                   long key) {
    rangeCheck(a.length, fromIndex, toIndex);
    return binarySearch0(a, fromIndex, toIndex, key);
    }
/**
對陣列中元素的查詢有以上兩種方法，在binarySearch0方法中使用的是二分查詢法。並且對基本型別和物件型別的陣列查詢是同樣的操作。
**/

equals

//比較基本型別陣列是否相等
 public static boolean equals(long[] a, long[] 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;
/**
        對於double型別，使用的是： 
        if (Double.doubleToLongBits(a[i])!=Double.doubleToLongBits(a2[i]))
        return false;
        對於float型別，使用的是：
         if (Float.floatToIntBits(a[i])!=Float.floatToIntBits(a2[i]))
                return false;
這樣做是為了精確比較。
        **/
        return true;
    }
.....
.....
.....
//比較Object型別陣列是否相等
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;
    }
.....
.....
.....
//深度比較兩個陣列是否相等
 public static boolean deepEquals(Object[] a1, Object[] a2) {
        if (a1 == a2)
            return true;
        if (a1 == null || a2==null)
            return false;
        int length = a1.length;
        if (a2.length != length)
            return false;

        for (int i = 0; i < length; i++) {
            Object e1 = a1[i];
            Object e2 = a2[i];

            if (e1 == e2)
                continue;
            if (e1 == null)
                return false;

            // Figure out whether the two elements are equal
            boolean eq;
            if (e1 instanceof Object[] && e2 instanceof Object[])
                eq = deepEquals ((Object[]) e1, (Object[]) e2);
            else if (e1 instanceof byte[] && e2 instanceof byte[])
                eq = equals((byte[]) e1, (byte[]) e2);
            else if (e1 instanceof short[] && e2 instanceof short[])
                eq = equals((short[]) e1, (short[]) e2);
            else if (e1 instanceof int[] && e2 instanceof int[])
                eq = equals((int[]) e1, (int[]) e2);
            else if (e1 instanceof long[] && e2 instanceof long[])
                eq = equals((long[]) e1, (long[]) e2);
            else if (e1 instanceof char[] && e2 instanceof char[])
                eq = equals((char[]) e1, (char[]) e2);
            else if (e1 instanceof float[] && e2 instanceof float[])
                eq = equals((float[]) e1, (float[]) e2);
            else if (e1 instanceof double[] && e2 instanceof double[])
                eq = equals((double[]) e1, (double[]) e2);
            else if (e1 instanceof boolean[] && e2 instanceof boolean[])
                eq = equals((boolean[]) e1, (boolean[]) e2);
            else
                eq = e1.equals(e2);

            if (!eq)
                return false;
        }
        return true;
    }

fill

//使用val對a陣列進行資料填充
  public static void fill(long[] a, long val) {
        fill(a, 0, a.length, val);
    }
//使用val對a陣列從fromIndex(包含）至toIndex（不包含）位置進行資料填充
 public static void fill(long[] a, int fromIndex, int toIndex, long val) {
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i=fromIndex; i<toIndex; i++)
            a[i] = val;
    }

copyOf

//拷貝從0開始的newLength個
public static byte[] copyOf(byte[] original, int newLength) {
        byte[] copy = new byte[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
.....
.....
.....
//拷貝從from（包含）位置到to(不包含）的元素
public static byte[] copyOfRange(byte[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        byte[] copy = new byte[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }
/**
拷貝方法有以上兩種，對於基本型別和物件操作是一樣的。而System.arraycopy()方法為淺拷貝，故如果是物件陣列的拷貝，只是拷貝了物件的引用，沒有重新new每一個物件。
**/

asList

沒有深究。。。。。。

hashCode

//對基本資料型別的hashcode的計算
    public static int hashCode(long a[]) {
        if (a == null)
            return 0;

        int result = 1;
        for (long element : a) {
        //對於不同的基本資料型別，計算hashcode的具體操作是不一樣的
            int elementHash = (int)(element ^ (element >>> 32));
            result = 31 * result + elementHash;
        }

        return result;
    }
....
....
....
//對於Object型別陣列的hashcode的計算
public static int hashCode(Object a[]) {
        if (a == null)
            return 0;

        int result = 1;

        for (Object element : a)
            result = 31 * result + (element == null ? 0 : element.hashCode());

        return result;
    }
....
....
....
//對於陣列的hashcode值的深度計算
public static int deepHashCode(Object a[]) {
        if (a == null)
            return 0;

        int result = 1;

        for (Object element : a) {
            int elementHash = 0;
            if (element instanceof Object[])
                elementHash = deepHashCode((Object[]) element);
            else if (element instanceof byte[])
                elementHash = hashCode((byte[]) element);
            else if (element instanceof short[])
                elementHash = hashCode((short[]) element);
            else if (element instanceof int[])
                elementHash = hashCode((int[]) element);
            else if (element instanceof long[])
                elementHash = hashCode((long[]) element);
            else if (element instanceof char[])
                elementHash = hashCode((char[]) element);
            else if (element instanceof float[])
                elementHash = hashCode((float[]) element);
            else if (element instanceof double[])
                elementHash = hashCode((double[]) element);
            else if (element instanceof boolean[])
                elementHash = hashCode((boolean[]) element);
            else if (element != null)
                elementHash = element.hashCode();

            result = 31 * result + elementHash;
        }

        return result;
    }

toString

​

//基本資料型別轉字串
    public static String toString(long[] a) {
        if (a == null)
            return "null";
    int iMax = a.length - 1;
    if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
        if (i == iMax)
        return b.append(']').toString();
            b.append(", ");
        }
    }
.....
.....
.....
//Object型別使用valueOf方法轉字串
public static String toString(Object[] a) {
        if (a == null)
            return "null";
    int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
    b.append('[');
        for (int i = 0; ; i++) {
            b.append(String.valueOf(a[i]));
            if (i == iMax)
        return b.append(']').toString();
        b.append(", ");
        }
    }
.....
.....
.....
//深度轉換字串
public static String deepToString(Object[] a) {
        if (a == null)
            return "null";

        int bufLen = 20 * a.length;
        if (a.length != 0 && bufLen <= 0)
            bufLen = Integer.MAX_VALUE;
        StringBuilder buf = new StringBuilder(bufLen);
        deepToString(a, buf, new HashSet());
        return buf.toString();
    }

private static void deepToString(Object[] a, StringBuilder buf,
                                     Set<Object[]> dejaVu) {
        if (a == null) {
            buf.append("null");
            return;
        }
        dejaVu.add(a);
        buf.append('[');
        for (int i = 0; i < a.length; i++) {
            if (i != 0)
                buf.append(", ");

            Object element = a[i];
            if (element == null) {
                buf.append("null");
            } else {
                Class eClass = element.getClass();

                if (eClass.isArray()) {
                    if (eClass == byte[].class)
                        buf.append(toString((byte[]) element));
                    else if (eClass == short[].class)
                        buf.append(toString((short[]) element));
                    else if (eClass == int[].class)
                        buf.append(toString((int[]) element));
                    else if (eClass == long[].class)
                        buf.append(toString((long[]) element));
                    else if (eClass == char[].class)
                        buf.append(toString((char[]) element));
                    else if (eClass == float[].class)
                        buf.append(toString((float[]) element));
                    else if (eClass == double[].class)
                        buf.append(toString((double[]) element));
                    else if (eClass == boolean[].class)
                        buf.append(toString((boolean[]) element));
                    else { // element is an array of object references
                        if (dejaVu.contains(element))
                            buf.append("[...]");
                        else
                            deepToString((Object[])element, buf, dejaVu);
                    }
                } else {  // element is non-null and not an array
                    buf.append(element.toString());
                }
            }
        }
        buf.append(']');
        dejaVu.remove(a);
    }