前言

2022/10/25

路漫漫其修远兮,吾将上下而求索

本文是根据jdk学习所做笔记

仅供学习交流使用，转载注明出处

说明

以下内容是结合很多资料进行编写的

源码为jdk1.8的

斜体样式 为自己的思考

下划线为自己所画的重点

Arrays类

基本信息

java.util

类 Arrays

java.lang.Object

继承者 java.util.Arrays

public class Arraysextends Object此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

此类中所含方法的文档都包括对实现的简短描述。应该将这些描述视为实现注意事项，而不应将它们视为规范的一部分。实现者应该可以随意替代其他算法，只要遵循规范本身即可。（例如，sort(Object[]) 使用的算法不必是一个合并排序算法，但它必须是稳定的。）

此类是 Java Collections Framework 的成员。

从以下版本开始：

1.2

成员

binarySearch

public static int binarySearch(int[] a,

int key)

使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

参数：

a - 要搜索的数组

key - 要搜索的值

如果它包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点被定义为将键插入数组的那一点：即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为 a.length。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

   public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }

binarySearch

public static int binarySearch(int[] a,

int fromIndex,

int toIndex,

int key)

使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。必须在进行此调用之前对范围进行排序（通过 sort(int[], int, int) 方法）。如果没有对范围进行排序，则结果是不确定的。如果范围包含多个带有指定值的元素，则无法保证找到的是哪一个。

参数：

a - 要搜索的数组

fromIndex - 要搜索的第一个元素的索引（包括）

toIndex - 要搜索的最后一个元素的索引（不包括）

key - 要搜索的值

如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

从以下版本开始：

1.6

    public static int binarySearch(int[] a, int fromIndex, int toIndex,
                                   int key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }

binarySearch0

   // Like public version, but without range checks.
    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.
    }

copyOf

public static int[] copyOf(int[] original,

int newLength)

复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 0。当且仅当指定长度大于原数组的长度时，这些索引存在。

参数：

original - 要复制的数组

newLength - 要返回的副本的长度

原数组的副本，截取或用 0 填充以获得指定的长度

抛出：

NegativeArraySizeException - 如果 newLength 为负

NullPointerException - 如果 original 为 null

从以下版本开始：

1.6

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

System

    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

copyOfRange

public static int[] copyOfRange(int[] original,

int from,

int to)

将指定数组的指定范围复制到一个新数组。该范围的初始索引 (from) 必须位于 0 和 original.length（包括）之间。original[from] 处的值放入副本的初始元素中（除非 from = = original.length 或 from == to）。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to)（必须大于等于 from）可以大于 original.length，在这种情况下，0 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from。

参数：

original - 将要从其复制一个范围的数组

from - 要复制的范围的初始索引（包括）

to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。

包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度

抛出：

ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length()

IllegalArgumentException - 如果 from > to

NullPointerException - 如果 original 为 null

从以下版本开始：

1.6

    public static int[] copyOfRange(int[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        int[] copy = new int[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

sort

public static void sort(int[] a,

int fromIndex,

int toIndex)

对指定 int 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）

该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：

a - 要排序的数组

fromIndex - 要排序的第一个元素的索引（包括）

toIndex - 要排序的最后一个元素的索引（不包括）

抛出：

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

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

asList

public static List asList(T… a)

返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。

此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素：

 List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

参数：

a - 支持列表的数组。

指定数组的列表视图。

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

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) {
            a = Objects.requireNonNull(array);
        }
        @Override
        public int size() {
            return a.length;
        }
        @Override
        public Object[] toArray() {
            return a.clone();
        }
        @Override
        @SuppressWarnings("unchecked")
        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;
        }
        @Override
        public E get(int index) {
            return a[index];
        }
        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }
        @Override
        public int indexOf(Object o) {
            E[] a = this.a;
            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;
        }
        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }
        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }
        @Override
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }
        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }
        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }
    }

hashCode

public static int hashCode(int[] a)

基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的非 null int 型数组 a 和 b，也可以说 Arrays.hashCode(a) == Arrays.hashCode(b)。

此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的 Integer 实例的序列。如果 a 为 null，则此方法返回 0。

参数：

a - 要计算其哈希值的数组

a 数组基于内容的哈希码

从以下版本开始：

1.5

    public static int hashCode(int a[]) {
        if (a == null)
            return 0;
        int result = 1;
        for (int element : a)
            result = 31 * result + element;
        return result;
    }

toString

public static String toString(int[] a)

返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成，括在方括号（“[]”）中。相邻元素用字符 ", "（逗号加空格）分隔。这些元素通过 String.valueOf(int) 转换为字符串。如果 a 为 null，则返回 “null”。

参数：

a - 返回其字符串表示形式的数组

a 的字符串表示形式

从以下版本开始：

1.5

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

另外

DualPivotQuicksort.sort

双轴快排

  /**
     * Sorts the specified range of the array using the given
     * workspace array slice if possible for merging
     *
     * @param a the array to be sorted
     * @param left the index of the first element, inclusive, to be sorted //留下要排序的第一个元素的索引
     * @param right the index of the last element, inclusive, to be sorted //要排序的最后一个元素的索引
     * @param work a workspace array (slice)
     * @param workBase origin of usable space in work array
     * @param workLen usable size of work array
     */
    static void sort(long[] a, int left, int right,
                     long[] work, int workBase, int workLen) {
        // Use Quicksort on small arrays
        if (right - left < QUICKSORT_THRESHOLD) {
            sort(a, left, right, true);
            return;
        }
        /*
         * Index run[i] is the start of i-th run
         * (ascending or descending sequence).
         */
        int[] run = new int[MAX_RUN_COUNT + 1];
        int count = 0; run[0] = left;
        // Check if the array is nearly sorted
        for (int k = left; k < right; run[count] = k) {
            if (a[k] < a[k + 1]) { // ascending
                while (++k <= right && a[k - 1] <= a[k]);
            } else if (a[k] > a[k + 1]) { // descending
                while (++k <= right && a[k - 1] >= a[k]);
                for (int lo = run[count] - 1, hi = k; ++lo < --hi; ) {
                    long t = a[lo]; a[lo] = a[hi]; a[hi] = t;
                }
            } else { // equal
                for (int m = MAX_RUN_LENGTH; ++k <= right && a[k - 1] == a[k]; ) {
                    if (--m == 0) {
                        sort(a, left, right, true);
                        return;
                    }
                }
            }
            /*
             * The array is not highly structured,
             * use Quicksort instead of merge sort.
             */
            if (++count == MAX_RUN_COUNT) {
                sort(a, left, right, true);
                return;
            }
        }
        // Check special cases
        // Implementation note: variable "right" is increased by 1.
        if (run[count] == right++) { // The last run contains one element
            run[++count] = right;
        } else if (count == 1) { // The array is already sorted
            return;
        }
        // Determine alternation base for merge
        byte odd = 0;
        for (int n = 1; (n <<= 1) < count; odd ^= 1);
        // Use or create temporary array b for merging
        long[] b;                 // temp array; alternates with a
        int ao, bo;              // array offsets from 'left'
        int blen = right - left; // space needed for b
        if (work == null || workLen < blen || workBase + blen > work.length) {
            work = new long[blen];
            workBase = 0;
        }
        if (odd == 0) {
            System.arraycopy(a, left, work, workBase, blen);
            b = a;
            bo = 0;
            a = work;
            ao = workBase - left;
        } else {
            b = work;
            ao = 0;
            bo = workBase - left;
        }
        // Merging
        for (int last; count > 1; count = last) {
            for (int k = (last = 0) + 2; k <= count; k += 2) {
                int hi = run[k], mi = run[k - 1];
                for (int i = run[k - 2], p = i, q = mi; i < hi; ++i) {
                    if (q >= hi || p < mi && a[p + ao] <= a[q + ao]) {
                        b[i + bo] = a[p++ + ao];
                    } else {
                        b[i + bo] = a[q++ + ao];
                    }
                }
                run[++last] = hi;
            }
            if ((count & 1) != 0) {
                for (int i = right, lo = run[count - 1]; --i >= lo;
                    b[i + bo] = a[i + ao]
                );
                run[++last] = right;
            }
            long[] t = a; a = b; b = t;
            int o = ao; ao = bo; bo = o;
        }
    }

测试

package testutil;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
 * @author CSDN@日星月云
 * @date 2022/10/25 19:58
 */
public class TestArrays {
    public static void main(String[] args) {
        int[] a =new int[]{
                1,2,3,4,5,9,8,7,6,0
        };
        //copyOf
        int[] b = Arrays.copyOf(a, a.length);
        System.out.println(Arrays.toString(b));//[1, 2, 3, 4, 5, 9, 8, 7, 6, 0]
        //copyOfRange
        int[] c = Arrays.copyOfRange(b, 0, 5);
        System.out.println(Arrays.toString(c));//[1, 2, 3, 4, 5]
        List<Integer> ints = Arrays.asList(1,2,3,4,5);
        ints.forEach(System.out::print);//12345
        System.out.println();
        //先排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        //二分查找先排序
        // return mid
        System.out.println(Arrays.binarySearch(a, 5));//5
        //return -(low + 1);
        System.out.println(Arrays.binarySearch(a, 11));//-11
        System.out.println(Arrays.binarySearch(a, -1));//-1
    }
}

总结

关键词：

asList
binarySearch0

二分查找

sort
copyOf

最后

开源=为爱发电

Arrays类【JDK源码分析】

前言

推荐

说明

Arrays类

基本信息

成员

binarySearch

binarySearch

binarySearch0

copyOf

copyOfRange

sort

asList

ArrayList 内部类

hashCode

toString

另外

DualPivotQuicksort.sort

测试

总结

最后

热门文章

最新文章

相关课程

相关电子书