深入瞭解Java核心類庫–Arrays類

Java常用類庫Arrays

類Arrays包含用於操作數組的各種方法(例如排序和搜索)

  • 如果指定的數組引用為null,則此類中的方法都拋出NullPointerException ,除非另有說明

一、常用方法

1.1 toString

返回指定數組內容的字符串形式

舉例

       int[] a1 = {1,2,3,4,5};
       System.out.println(Arrays.toString(a1));//[1, 2, 3, 4, 5]

源碼

	public static String toString(int[] 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(", ");
        }
    }

其它

Modifier and Type Field Description
static String deepToString​(Object[] a) 返回指定數組的“深層內容”的字符串表示形式

1.2 Sort

排序(默認升序)

1.2.1 sort​(T[] a, int fromIndex, int toIndex)

指定區間進行排序

舉例

       int[] a1 = {9,1,3,7,2,5};
       System.out.println(Arrays.toString(a1));//[9, 1, 3, 7, 2, 5]
       Arrays.sort(a1,0,3);//[0,3),對9,1,3進行排序
       System.out.println(Arrays.toString(a1));//[0[1, 3, 9, 7, 2, 5]

源碼

    public static void sort(int[] a, int fromIndex, int toIndex) {
        rangeCheck(a.length, fromIndex, toIndex);
        DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
    }

1.2.2 Sort(T[] a)

對整個數組進行排序

舉例

       int[] a1 = {0,7,8,2,4,1};
       System.out.println(Arrays.toString(a1));//[0, 7, 8, 2, 4, 1]
       Arrays.sort(a1);
       System.out.println(Arrays.toString(a1));//[0, 1, 2, 4, 7, 8]

源碼

    public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
    }

1.2.3 其它

Modifier and Type Field Description
static void sort​(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) 根據指定比較器引發的順序對指定對象數組的指定范圍進行排序。
static void sort​(T[] a, Comparator<? super T> c) 根據指定比較器引發的順序對指定的對象數組進行排序。
static void parallelSort​(T[] a) 將指定的數組按升序排序。
static void parallelSort​(T[] a, int fromIndex, int toIndex) 將指定的數組范圍按數字升序排序。
static <T extends Comparable<? super T>>void parallelSort​(T[] a) 根據元素的natural ordering對指定的對象數組按升序排序。
static <T extends Comparable<? super T>>void parallelSort​(T[] a, int fromIndex, int toIndex) 根據元素的natural ordering ,將指定對象數組的指定范圍按升序排序。
static void parallelSort​(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp) 根據指定比較器引發的順序對指定對象數組的指定范圍進行排序。
static void parallelSort​(T[] a, Comparator<? super T> cmp) 根據指定比較器引發的順序對指定的對象數組進行排序。

1.3 copyOf

復制(常用於數組擴容)

舉例

       int[] a = {1,2,3};
       System.out.println(a.length);//output:3
       a = Arrays.copyOf(a,15);
       System.out.println(a.length);//output:15

源碼

  public static int[] copyOf(int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
        return copy;
    }

其它

Modifier and Type Field Description
static T[] copyOf​(T[] original, int newLength) 使用空值復制指定的數組,截斷或填充(如有必要),以使副本具有指定的長度
static <T,​U>T[] copyOf​(U[] original, int newLength, 類<? extends T[]> newType) 使用空值復制指定的數組,截斷或填充(如有必要),以使副本具有指定的長度

1.4 mismatch

舉例

       int[] a1 = {0,1,2,3,4,5};
       int[] a2 = {0,1,2,3,4,5};//與a1相同
       int[] a3 = {0,1,2,3,0,5};//從索引4開始與a1不同
       System.out.println(Arrays.mismatch(a1,a2));//output:-1
       System.out.println(Arrays.mismatch(a1,a3));//output:4

源碼

 public static int mismatch(int[] a, int[] b) {
        int length = Math.min(a.length, b.length); // Check null array refs
        if (a == b)
            return -1;
        int i = ArraysSupport.mismatch(a, b, length);
        return (i < 0 && a.length != b.length) ? length : i;
    }

其它

Modifier and Type Field Description
static int mismatch​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) 查找並返回指定范圍內兩個 Object數組之間第一個不匹配的相對索引,否則如果未找到不匹配則返回-1。
static int mismatch​(T[] a, T[] b, Comparator<? super T> cmp) 查找並返回兩個 Object數組之間第一個不匹配的索引,否則如果未找到不匹配則返回-1。

1.5 binarySearch

二分查找,搜索,返回下標

1.5.1 binarySearch​(T[] a, int fromIndex, int toIndex, T key)

限定瞭搜索的范圍[fromIndex, toIndex)

舉例

  int[] a = {1,2,3,4,5};
       int x1 = Arrays.binarySearch(a,2,3,4);//在a數組下標[2,3)中查找值為4的下標
       System.out.println(x1);//output:<0的隨機數

源碼

	public static int binarySearch(int[] a, int fromIndex, int toIndex,int key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }
    private static int binarySearch0(int[] a, int fromIndex, int toIndex,int key) {
        int low = fromIndex;
        int high = toIndex - 1;
        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];
            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

1.5.2 binarySearch​(T[] a, T key)

與上述相同,隻是沒有限定范圍,fromIndex=0, toIndex=length

舉例

       int[] a = {1,2,3,4,5};
       int x1 = Arrays.binarySearch(a,3);//在a數組中查找值為3的下標
       int x2 = Arrays.binarySearch(a,-6);//在a數組中查找值為6的下標
       System.out.println(x1);//output:2
       System.out.println(x2);//output:<0的隨機數

源碼

    public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }
	private static int binarySearch0(int[] a, int fromIndex, int toIndex,int key) {
        int low = fromIndex;
        int high = toIndex - 1;
        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];
            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

1.5.3 其它

Modifier and Type Field Description
static int binarySearch​(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c) 使用二進制搜索算法搜索指定對象的指定數組范圍
static int binarySearch​(T[] a, T key, Comparator<? super T> c) 使用二進制搜索算法在指定的數組中搜索指定的對象

1.6 equals

1.6.1 equals​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)

如果兩個指定數組在指定范圍內相等 ,則返回true

舉例

       int[] a1 = {1,2,3,4,5};
       int[] a2 = {1,2,0,0,4,5};
       System.out.println(Arrays.equals(a1,0,2,a2,0,2));//true
       System.out.println(Arrays.equals(a1,3,5,a2,4,6));//true

源碼

public static boolean equals(int[] a, int aFromIndex, int aToIndex,int[] b, int bFromIndex, int bToIndex) {
        rangeCheck(a.length, aFromIndex, aToIndex);
        rangeCheck(b.length, bFromIndex, bToIndex);
        int aLength = aToIndex - aFromIndex;
        int bLength = bToIndex - bFromIndex;
        if (aLength != bLength)
            return false;
        return ArraysSupport.mismatch(a, aFromIndex, b, bFromIndex,aLength) < 0;
    }

1.6.2 equals​(T[] a, T[] a2)

如果兩個指定數組相等,則返回 true

舉例

       int[] a1 = {1,2,3,4,5};
       int[] a2 = {1,2,3,4,5};
       int[] a3 = {1,2,0,4,5};
       System.out.println(Arrays.equals(a1,a2));//true
       System.out.println(Arrays.equals(a1,a3));//false

源碼

 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;
        return ArraysSupport.mismatch(a, a2, length) < 0;
    }

1.6.3 其它

Modifier and Type Field Description
static boolean deepEquals​(Object[] a1, Object[] a2) 如果兩個指定的數組彼此 深度相等 ,則返回 true
static boolean equals​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) 如果在指定范圍內指定的兩個Object數組彼此 相等 ,則返回true
static boolean equals​(T[] a, T[] a2, Comparator<? super T> cmp) 如果兩個指定的Objects數組彼此 相等 ,則返回 true

1.7 fills

1.7.1 fill​(T[] a, int fromIndex, int toIndex, T val)

將指定的T值分配給指定的T類型數組的指定范圍的每個元素

舉例

       int[] a1 = new int[10];
       Arrays.fill(a1,1,4,8);
       char[] a2 = new char[10];
       Arrays.fill(a2,0,3,'s');
       System.out.println(Arrays.toString(a1));//[0, 8, 8, 8, 0, 0, 0, 0, 0, 0]
       System.out.println(Arrays.toString(a2));//[s, s, s,  ,  ,  ,  ,  ,  ,  ]

源碼

    public static void fill(char[] a, int fromIndex, int toIndex, char val) {
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i = fromIndex; i < toIndex; i++)
            a[i] = val;
    }

1.7.2 fill​(T[] a, T val)

將指定的T值分配給指定的T類型數組的每個元素

舉例

       int[] a1 = new int[10];
       Arrays.fill(a1,8);
       char[] a2 = new char[10];
       Arrays.fill(a2,'s');
       System.out.println(Arrays.toString(a1));//[8, 8, 8, 8, 8, 8, 8, 8, 8, 8]
       System.out.println(Arrays.toString(a2));//[s, s, s, s, s, s, s, s, s, s]

源碼

	public static void fill(int[] a, int val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }

二、其他方法

Modifier and Type Field Description
static List asList​(T… a) 返回由指定數組支持的固定大小的列表。
static int compare​(T[] a, T[] b) 字典順序比較兩個T陣列
static int compare​(T[] a, int aFromIndex, int aToIndex,T[] b, int bFromIndex, int bToIndex) 在指定范圍內按字典順序比較兩個T陣列
static <T extends Comparable<? super T>>int compare​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex) 在指定范圍內按字典順序比較兩個 Object陣列。
static int compare​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) 在指定范圍內按字典順序比較兩個 Object陣列。
static <T extends Comparable<? super T>>int compare​(T[] a, T[] b) 按 Object順序比較兩個 Object陣列,在可比元素中。
static int compare​(T[] a, T[] b, Comparator<? super T> cmp) 使用指定的比較器按字典順序比較兩個 Object陣列
static int compareUnsigned​(T[] a, T[] b) byte字典順序比較兩個T陣列,數字處理元素為無符號
static int compareUnsigned​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex) 在指定范圍內按字典順序比較兩個 T陣列,將元素數字處理為無符號
static T[] copyOfRange​(T[] original, int from, int to) 將指定數組的指定范圍復制到新數組中
static T[] copyOfRange​(T[] original, int from, int to) 將指定數組的指定范圍復制到新數組中
static <T,​U>T[] copyOfRange​(U[] original, int from, int to, 類<? extends T[]> newType) 將指定數組的指定范圍復制到新數組中
static int hashCode​(T[] a) 根據指定數組的內容返回哈希碼
static int deepHashCode​(Object[] a) 返回基於指定數組的“深層內容”的哈希碼
static void parallelPrefix​(T[] array, int fromIndex, int toIndex,TBinaryOperator op) 對於給定的數組子范圍執行parallelPrefix(T[], TBinaryOperator)
static void parallelPrefix​(dT[] array, TBinaryOperator op) 使用提供的函數並行地累積給定數組的每個元素
static void parallelPrefix​(T[] array, int fromIndex, int toIndex, BinaryOperator op) 對於給定的數組子范圍執行 parallelPrefix(Object[], BinaryOperator)
static void parallelPrefix​(T[] array, BinaryOperator op) 使用提供的函數並行地累積給定數組的每個元素
static void parallelSetAll​(double[] array, IntToDoubleFunction generator) 使用提供的生成器函數並行設置指定數組的所有元素以計算每個元素
static void parallelSetAll​(int[] array, IntUnaryOperator generator) 使用提供的生成器函數並行設置指定數組的所有元素以計算每個元素
static void parallelSetAll​(long[] array, IntToLongFunction generator) 使用提供的生成器函數並行設置指定數組的所有元素以計算每個元素
static void parallelSetAll​(T[] array, IntFunction<? extends T> generator) 使用提供的生成器函數並行設置指定數組的所有元素以計算每個元素
static void setAll​(double[] array, IntToDoubleFunction generator) 使用提供的生成器函數設置指定數組的所有元素以計算每個元素
static void setAll​(int[] array, IntUnaryOperator generator) 使用提供的生成器函數設置指定數組的所有元素以計算每個元素
static void setAll​(long[] array, IntToLongFunction generator) 使用提供的生成器函數設置指定數組的所有元素以計算每個元素
static void setAll​(T[] array, IntFunction<? extends T> generator) 使用提供的生成器函數設置指定數組的所有元素以計算每個元素
static Spliterator.OfDouble spliterator​(double[] array) 返回覆蓋所有指定數組的Spliterator.OfDouble
static Spliterator.OfDouble spliterator​(double[] array, int startInclusive, int endExclusive) 返回覆蓋指定數組的指定范圍的Spliterator.OfDouble
static Spliterator.OfInt spliterator​(int[] array) 返回覆蓋所有指定數組的Spliterator.OfInt
static Spliterator.OfInt spliterator​(int[] array, int startInclusive, int endExclusive) 返回覆蓋指定數組的指定范圍的Spliterator.OfInt
static Spliterator.OfLong spliterator​(long[] array) 返回覆蓋所有指定數組的Spliterator.OfLong
static Spliterator.OfLong spliterator​(long[] array, int startInclusive, int endExclusive) 返回覆蓋指定數組的指定范圍的Spliterator.OfLong
static Spliterator spliterator​(T[] array) 返回覆蓋所有指定數組的Spliterator
static Spliterator spliterator​(T[] array, int startInclusive, int endExclusive) 返回覆蓋指定數組的指定范圍的Spliterator
static DoubleStream stream​(double[] array) 返回以指定數組作為源的順序DoubleStream
static DoubleStream stream​(double[] array, int startInclusive, int endExclusive) 返回指定數組的指定范圍作為其源的順序DoubleStream
static IntStream stream​(int[] array) 返回以指定數組作為源的順序IntStream
static IntStream stream​(int[] array, int startInclusive, int endExclusive) 返回指定數組的指定范圍作為其源的順序IntStream
static LongStream stream​(long[] array) 返回以指定數組作為源的順序LongStream
static LongStream stream​(long[] array, int startInclusive, int endExclusive) 返回指定數組的指定范圍作為其源的順序LongStream
static Stream stream​(T[] array) 返回以指定數組作為源的順序Stream
static Stream stream​(T[] array, int startInclusive, int endExclusive) 返回指定數組的指定范圍作為其源的順序Stream

總結

本篇文章就到這裡瞭,希望能給你帶來幫助,也希望您能夠多多關註WalkonNet的更多內容!

推薦閱讀: