【Java】【常用类】 Arrays工具类 源码学习

虽然在数组的随笔中有说过，但实际上应该仔细深入一下源码进行分析

源码没有想象中的高大上，代码终究还是写给人看的，可读性大于执行性

最小阵列排序：1 乘 2的13次方 =  8192

学识浅薄，暂时还不明白这个常量在数组工具类的意义

通过翻译的介绍，说明这是并行排序最小长度的要求

【并行排序的最小数组长度】

- 算法不会进一步划分排序任务。使用

- 较小的大小通常会导致

- 使并行加速不太可能的任务。

private static final int MIN_ARRAY_SORT_GRAN = 1 << 13;

私有化的构造器，因为是工具类，设计者认为不应该产生实例

【抑制默认构造函数，确保不可实例化。】

// Suppresses default constructor, ensuring non-instantiability.
    private Arrays() {}

一个固定的静态内部类 叫自然顺序类

实现了可比较接口，和重写了比较方法，暂时还不知道其中的用意

static final class NaturalOrder implements Comparator<Object> {
        @SuppressWarnings("unchecked")
        public int compare(Object first, Object second) {
            return ((Comparable<Object>)first).compareTo(second);
        }
        static final NaturalOrder INSTANCE = new NaturalOrder();
    }

长度范围检查

设计者认为所有工具方法，都应该先确认一下参数注入的数组的正确性

所以设计了长度检查，如果不符合描述，直接丢异常出去交给调用者处理检查

- 如果起始索引大于截至索引，抛出不合理的参数异常，并指明错误参数

- 如果起始位置小于0，也就是小于第一个元素的位置索引 ，抛出越界异常

- 如果截至位置大于数组的长度 抛出越界异常

    /**
     * Checks that {@code fromIndex} and {@code toIndex} are in
     * the range and throws an exception if they aren't.
     */
    private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
        if (fromIndex > toIndex) {
            throw new IllegalArgumentException(
                    "fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")");
        }
        if (fromIndex < 0) {
            throw new ArrayIndexOutOfBoundsException(fromIndex);
        }
        if (toIndex > arrayLength) {
            throw new ArrayIndexOutOfBoundsException(toIndex);
        }
    }

可以看到这个排序调用的是一个名叫【双枢轴快速排序类的排序方法】

只看过快速排序，哪儿见过这算法，打个mark留意一下把，

因为只注入一个数组的参数，所以不需要上面范围检查

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

如果是针对数组的一个片段的排序，这个排序的重载就会调用范围检查

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

基本类型的重载

除了对基本类型排序之外，还有对引用类型排序的支持！

但是具体实现的算法还是没看懂，只能标记一下了

    public static void sort(Object[] a) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a);
        else
            ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
    }

    /** To be removed in a future release. */
    private static void legacyMergeSort(Object[] a) {
        Object[] aux = a.clone();
        mergeSort(aux, a, 0, a.length, 0);
    }

并行排序、又称串行排序，用于多线程相关的排序

看不懂，我太菜了。。。。

备注说明了这个方法是从1.8开始有的

    public static void parallelSort(byte[] a) {
        int n = a.length, p, g;
        if (n <= MIN_ARRAY_SORT_GRAN ||
            (p = ForkJoinPool.getCommonPoolParallelism()) == 1)
            DualPivotQuicksort.sort(a, 0, n - 1);
        else
            new ArraysParallelSortHelpers.FJByte.Sorter
                (null, a, new byte[n], 0, n, 0,
                 ((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
                 MIN_ARRAY_SORT_GRAN : g).invoke();
    }

也是配备了基本类型和引用类型的重载

并行前缀方法

跟并行排序配套使用的方法... 依旧不懂

    public static <T> void parallelPrefix(T[] array, BinaryOperator<T> op) {
        Objects.requireNonNull(op);
        if (array.length > 0)
            new ArrayPrefixHelpers.CumulateTask<>
                    (null, op, array, 0, array.length).invoke();
    }

对应的类型只有这么几个重载

官方的二分查找，在获取中轴游标时采用的位运算 无符号右移1，也就是除2

    // Like public version, but without range checks.
    private static int binarySearch0(long[] a, int fromIndex, int toIndex,
                                     long key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            long 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.
    }

对应的基本和引用类型的重载

比较两个数组之间是否相同  地址一样 或者 数组的长度和元素都是一样

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

复制数组直接调用的是系统类给的

然而系统类的复制方法是调用C++的方法

关于native描述的方法

https://www.cnblogs.com/b3051/p/7484501.html

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

片段复制

public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

转换成List集合，List是一个接口，实际上应该是由实现类完成的转换

　　@SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

转换成字符串形式

- 空指针打印null

- 如果索引个数，也就是没有元素，返回空

- 使用Buider拼接字符串，遍历到最后返回

还有个深转换的，针对对象设计的方法...

    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(", ");
        }
    }

就先看到这儿了，剩下的几个方法都还没看懂是干嘛的