Java 常用类库之 Arrays

Posted alterwl

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 常用类库之 Arrays相关的知识,希望对你有一定的参考价值。

完整名:java.util.Arrays

该类包含用于操作数组的各种方法(如排序和搜索)。该类还包含一个静态工厂,可以将数组视为列表。

如无另外说明,该类中的方法指定的数组引用为空时都会抛出一个NullPointerException 异常。

  1. sort()

    public static void sort(int[] a) {}
    public static void sort(int[] a, int fromIndex, int toIndex) {}
    

    只有一个参数的sort()对给定的数组参数按照升序排序。有三个参数的sort()对第一个数组参数的指定索引范围进行排序,该范围由后两个参数指定,从第二个参数fromIndex到第三个参数toIndex(不包含该索引)。

    Arrays中的sort()方法对除boolean外的所有 7 基本数据类型进行了重载,所以这里的int可以替换为其它 6 种基本数据类型种的任何一种。这些sort()方法使用的排序算法属于快速排序。

    public static void sort(Object[] a) {}
    public static void sort(Object[] a, int fromIndex, int toIndex) {}
    

    输入参数为Object类型的sort()方法,所有参数数组中的元素都必须实现Comparable接口,并且所有的元素之间必须可以相互比较(即e1.compareTo(e2)对任意的两个数组元素e1e2都不能产生异常ClassCastException)。其排序方式属于归并排序。

    public static <T> void sort(T[] a, Comparator<? super T> c) {}
    public static <T> void sort(T[] a, int fromIndex, int toIndex,
                                Comparator<? super T> c) {}
    

    这是使用泛型的sort()方法,它需要根据给定的比较器Comparator所得到的顺序对给定数组进行排序。其排序方式属于归并排序。

  2. parallelSort()

    public static void parallelSort(byte[] a) {}
    public static void parallelSort(byte[] a, int fromIndex, int toIndex) {}
    

    parallelSort()的各参数意义同sort()一样,返回数组的升序排序结果。parallelSort()通过并行的方式使用归并排序,它将原数组不断分解为子数组,分别对子数组进行排序。当子数组长度达到一个最小粒度时,则通过适当的Array.sort()方法对其进行排序。该算法需要一个不大于原始数组大小的工作空间。

    sort()一样,Arrays中的parallelSort()方法对除boolean外的所有 7 基本数据类型进行了重载,所以这里的byte可以替换为其它 6 种基本数据类型种的任何一种。

    public static <T extends Comparable<? super T>> void parallelSort(T[] a) {}
    public static <T extends Comparable<? super T>>
        void parallelSort(T[] a, int fromIndex, int toIndex) {}
    

    输入参数为泛型的parallelSort()方法,所有参数数组中的元素都必须实现Comparable接口,并且所有的元素之间必须可以相互比较(即e1.compareTo(e2)对任意的两个数组元素e1e2都不能产生异常ClassCastException)。其排序方式属于归并排序。

    public static <T> void parallelSort(T[] a, Comparator<? super T> cmp) {}
    public static <T> void parallelSort(T[] a, int fromIndex, int toIndex,
                                            Comparator<? super T> cmp) {}
    

    这是使用泛型的parallelSort()方法,它需要根据给定的比较器Comparator所得到的顺序对给定数组进行排序。其排序方式属于归并排序。

  3. parallelPrefix()

    public static <T> void parallelPrefix(T[] array, BinaryOperator<T> op) {}
    public static <T> void parallelPrefix(T[] array, int fromIndex,
                                          int toIndex, BinaryOperator<T> op) {
    

    使用提供的函数操作,对数组进行累积操作,相当于连续空间种的积分。比如输入的原始数组是[2, 1, 0, 3],那么累积操作后的数组是[2, 3, 3, 6]。对于含有两个参数的parallelPrefix,第一个参数array是原始数组,第二个参数op提供执行累积操作的函数。对于含有四个参数的parallelPrefixarray是原始数组,第二和第三个参数指定进行累积操作数组范围为从fromIndextoIndex(不包含该索引),第四个参数op提供执行累积操作的函数。

    Arrays还提供了这两种形式的parallelPrefix()方法对于int/long/double的重载方法,参数意义和方法作用类似。

  4. binarySearch()

    // 使用二分搜索在整个有序数组 a 中寻找 key 值的所在位置索引
    public static int binarySearch(long[] a, long key) {}
    // 使用二分搜索在整个有序数组 a 的指定范围 [fromIndex, toIndex) 中寻找 key 值的所在位置索引
    public static int binarySearch(long[] a, int fromIndex, int toIndex, long key) {}
    

    使用二分搜索在有序数组a中寻找指定参数key值的所在位置索引。如果找得到,则返回找到的索引值;如果没有找到,则返回值为(-(insertion point)-1),这里的insertion point就是key应该插入到有序数组a中的位置,保证数组a仍然有序。这个返回方式确实有些怪异,它的目的是保证只有在数组a中找到key时,返回值才一定时整数,而没找到情况下返回值一定是负数(该负数包含了key的插入点信息)。

    Arrays中的binarySearch()方法对除boolean外的所有 7 基本数据类型进行了重载,所以这里的long可以替换为其它 6 种基本数据类型种的任何一种。

    Arrays还提供了binarySearch()方法对Object类型以及泛型的重载方法。提供的方式和sort()类似,具体形式如下。

    public static int binarySearch(Object[] a, Object key){}
    public static binarySearch(Object[] a, int fromIndex, int toIndex, Object key) {}
    public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c) {}
    public static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c) {}
    
  5. equals()

    // 判断对于两个数组中的所有元素时候满足相等的要求。
    public static boolean equals(long[] a, long[] a2) {}
    // 判断对于两个参数指定范围中的元素是否满足相等的要求。
    public static boolean equals(long[] a, int aFromIndex, int aToIndex,
                                     long[] b, int bFromIndex, int bToIndex) {
    

    判断两个数组是否相等,它的涵义是,两个数组中是否包含相同的元素且排列顺序也相同。

    Arrays提供了equals()方法对 8 种基本数据类型的重载方法。

    Arrays还提供了equals()方法对Object类型以及泛型的重载方法。作用相同,不再赘述。对于使用泛型的重载方法,需要提供一个Comparator<? super T>参数作为比较器判断两个元素是否相等, cmp.compare(e1, e2) == 0表示e1e2相等。

    public static boolean equals(Object[] a, Object[] a2) {}
    public static boolean equals(Object[] a, int aFromIndex, int aToIndex,
                                 Object[] b, int bFromIndex, int bToIndex) {}
    public static <T> boolean equals(T[] a, T[] a2, Comparator<? super T> cmp) {}
    public static <T> boolean equals(T[] a, int aFromIndex, int aToIndex,
                                     T[] b, int bFromIndex, int bToIndex,
                                     Comparator<? super T> cmp) {
    
  6. fill()

    public static void fill(long[] a, long val) {}
    public static void fill(long[] a, int fromIndex, int toIndex, long val) {}
    

    使用指定数值val填充数组a。对于两个参数的fill()方法,表示使用val赋值a中的每个元素。对于四个参数的fill()方法,表示使用val赋值指定a中范围的元素,即从fromIndextoIndex(不包含该索引)。

    Arrays提供了fill()方法对 8 种基本数据类型以及Object类型的重载方法。作用相同,不再赘述。

  7. copyOf()

    public static boolean[] copyOf(boolean[] original, int newLength) {}
    

    复制数组original到长度为newLength的新数组中。在原数组和新数组中同时有效的索引处,两者具有相等的元素值,在新数组中有效而在原数组中无效的索引处,元素置为默认值。

    Arrays提供了copyOf()方法对 8 种基本数据类型以及泛型的重载方法。作用相同,不再赘述。

  8. copyOfRange()

    public static byte[] copyOfRange(byte[] original, int from, int to) {}
    

    复制数组original指定范围(从from to(不包含to索引))的元素到新数组中。from的值必须处于 0 到 original.length之间,它对应于新数组的起始索引。to的值必须大于或等于from的值,to可以超过original.length,超出原数组范围的索引,其对应的新数组中的索引处元素置为默认值。

    Arrays提供了copyOf()方法对 8 种基本数据类型以及泛型的重载方法。作用相同,不再赘述。

  9. asList()

    public static <T> List<T> asList(T... a) {}
    

    通过给定数组a得到一个定长的List对象,即将一个数组转换为一个List。此方法还可以方便地创建一个初始状态包含多个元素的定长List对象,像这样:

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

    public static int hashCode(long a[]) {}
    

    根据参数数组a的内容计算一个哈希码。

    对于任意两个数组abhashCode(a)==hashCode(b)Arrays.equals(a, b)结果相同。

    该方法返回的哈希码,跟包含与a相同元素且排列顺序相同的List对象调用hashCode()方法得到的哈希码,具有相同的值。如果anull,则方法返回 0。

    Arrays提供了hashCode()方法对 8 种基本数据类型以及Object类型的重载方法。作用相同,不再赘述。

  11. deepHashCode()

    public static int deepHashCode(Object a[]) {}
    

    根据参数数组a的深层内容计算一个哈希码。如果数组a的元素也是数组,哈希值的计算也会考虑到该数组的内容。

    对于任意两个数组abdeepHashCode(a)==deepHashCode(b)Arrays.deepEquals(a, b)结果相同。

  12. deepEquals()

    public static boolean deepEquals(Object[] a1, Object[] a2) {}
    

    判断两个数组a1a2是否深层相等。返回true则相等,返回false则不相等。与equals()方法不同,该方法适用于任意深度嵌套的数组。

  13. toString()

    public static String toString(long[] a) {}
    

    返回数组a内容的字符串表示形式。

    Arrays提供了toString()方法对 8 种基本数据类型以及Object类型的重载方法。作用相同,不再赘述。

  14. deepToString()

    public static String deepToString(Object[] a) {}
    

    返回数组a的深层内容的字符串表示形式。就是说,如果数组a的元素也是数组,那么返回的字符串中也表示除了其包含的内容。

    如果数组a的某个元素是它本身的引用,返回的字符串中对应位置表示为[...]的形式。

  15. setAll()

    public static <T> void setAll(T[] array, IntFunction<? extends T> generator) {}
    

    通过给定的生成器函数generator,设置数组array的所有元素。

    Arrays提供了``setAll()方法对int/long/double`类型的重载方法。

  16. parallelSetAll()

    public static <T> void parallelSetAll(T[] array, IntFunction<? extends T> generator) {}
    

    通过给定的生成器函数generator,并行地设置数组array的所有元素。

    Arrays提供了parallelSetAll()方法对int/long/double类型的重载方法。

  17. spliterator()

    // 返回一个覆盖整个数组的 Spliterator 对象
    public static <T> Spliterator<T> spliterator(T[] array) {}
    // 回一个覆盖数组指定范围(从 startInclusive 到 endExclusive (不包含该索引))的 Spliterator 对象。
    public static <T> Spliterator<T> spliterator(T[] array, int startInclusive, int endExclusive) {}
    

    返回一个覆盖数组arraySpliterator对象。

    Arrays提供了spliterator()方法对int/long/double类型的重载方法。

  18. stream()

    // 返回一个以整个数组作为源的 Stream 对象
    public static <T> Stream<T> stream(T[] array) {}
    // 返回一个以数组指定范围(从 startInclusive 到 endExclusive(不包含该索引))作为源的 Stream 对象
    public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {}
    

    返回以数组array作为源的顺序Stream

    Arrays提供了stream()方法对int/long/double类型的重载方法。

以下是从 Java 9 开始加入的方法:

  1. compare()

    // 按字典序比较两个数组 a 和 b
    public static int compare(boolean[] a, boolean[] b) {}
    // 按字典序比较数组 a 的指定范围 [aFromIndex, aToIndex) 和 b 的指定范围 [bFromIndex, bToIndex)
    public static int compare(boolean[] a, int aFromIndex, int aToIndex,
                              boolean[] b, int bFromIndex, int bToIndex) {}
    

    按字典序比较两个数组ab。简单来说,就是比较两数组按索引从前到后第一个不相同的元素值之间的大小。返回 0 表示连个数组含有相同值且按相同顺序排列的元素;返回负数值表示第一个参数数组按字典序小于第二个参数数组;返回正数值表示第一个参数数组按字典序大于第二个参数数组。

    Arrays提供了compare()方法对 8 种基本数据类型的重载方法。

    Arrays提供了compare()方法使用泛型的重载方法,形式如下:

    // 前提是 T[] 中的元素都是可比较的
    public static <T extends Comparable<? super T>> int compare(T[] a, T[] b) {}
    public static <T extends Comparable<? super T>> int compare(
                T[] a, int aFromIndex, int aToIndex,
                T[] b, int bFromIndex, int bToIndex) {}
    // 使用给定的比较器 cmp 对数组中的元素进行比较
    public static <T> int compare(T[] a, T[] b,
                                      Comparator<? super T> cmp) {}
    public static <T> int compare(
                T[] a, int aFromIndex, int aToIndex,
                T[] b, int bFromIndex, int bToIndex,
                Comparator<? super T> cmp) {}
    
  2. compareUnsigned()

    public static int compareUnsigned(byte[] a, byte[] b) {}
    public static int compareUnsigned(byte[] a, int aFromIndex, int aToIndex,
    byte[] b, int bFromIndex, int bToIndex) {}
    

    作用与compare()差不多,区别是compareUnsigned()方法将数组中的元素视为无符号数。

    Arrays提供了compareUnsigned()方法对byte/short/int/long四种有符号数据类型的重载方法。

  3. mismatch()

    // 将数组元素看作无符号数,按字典序比较两个数组 a 和 b
    public static int mismatch(boolean[] a, boolean[] b) {}
    // 将数组元素看作无符号数,按字典序比较数组 a 的指定范围 [aFromIndex, aToIndex) 和 b 的指定范围 [bFromIndex, bToIndex)
    public static int mismatch(boolean[] a, int aFromIndex, int aToIndex,
    boolean[] b, int bFromIndex, int bToIndex) {}
    

    找到两个数组ab按照索引顺序从前到后第一个不相同的元素位置,返回该位置的索引。如果没有找到不同的元素,则返回 -1,这表示两数组完全相同。

    Arrays提供了mismatch()方法对 8 种基本数据类型的重载方法。

    Arrays提供了mismatch()方法对Object类型以及使用泛型的重载方法,形式如下:

    public static int mismatch(Object[] a, Object[] b) {}
    public static int mismatch(
    Object[] a, int aFromIndex, int aToIndex,
    Object[] b, int bFromIndex, int bToIndex) {}
    public static <T> int mismatch(T[] a, T[] b, Comparator<? super T> cmp) {}
    public static <T> int mismatch(
    T[] a, int aFromIndex, int aToIndex,
    T[] b, int bFromIndex, int bToIndex,
    Comparator<? super T> cmp) {}
    

以上是关于Java 常用类库之 Arrays的主要内容,如果未能解决你的问题,请参考以下文章

Java 常用类库之util包和text包

Java SE基础部分——常用类库之NumberFormat

Java 常用类库之 Objects

Java 常用类库之 Math

Java 常用类库之util包和text包

Java 常用类库之lang包