Arrays 和 Collections是分别操作数组和集合的两个工具类。今天就来对 Arrays 中的内容作个总结。

Arrays 类位于 java.util包中。Arrays 继承 Object

  1. java.lang.Object
  2.  ↳ java.util.Arrays

Arrays 类中的静态方法可以对数组进行排序、查询、搜索等等操作。

该方法返回一个 ArrayList , 其返回的 ArrayList 从下面的代码可以看出不是我们平常 new 出来的动态可扩展的 ArrayList。可以看这篇 ArrayList

  1. @SafeVarargs
  2. @SuppressWarnings("varargs")
  3. public static <T> List<T> asList(T... a) {
  4.     return new ArrayList<>(a);
  5. }
  7. /**
  8.      * @serial include
  9.      */
  10. private static class ArrayList<E> extends AbstractList<E>
  11.     implements RandomAccess, java.io.Serializable
  12. {
  13.     private static final long serialVersionUID = -2764017481108945198L;
  14.     private final E[] a;
  16.     ArrayList(E[] array) {
  17.         a = Objects.requireNonNull(array);
  18.     }
  20.     @Override
  21.     public int size() {
  22.         return a.length;
  23.     }
  25.     @Override
  26.     public Object[] toArray() {
  27.         return a.clone();
  28.     }
  30.     @Override
  31.     @SuppressWarnings("unchecked")
  32.     public <T> T[] toArray(T[] a) {
  33.         int size = size();
  34.         if (a.length < size)
  35.             return Arrays.copyOf(this.a, size,
  36.                                  (Class<? extends T[]>) a.getClass());
  37.         System.arraycopy(this.a, 0, a, 0, size);
  38.         if (a.length > size)
  39.             a[size] = null;
  40.         return a;
  41.     }
  43.     @Override
  44.     public E get(int index) {
  45.         return a[index];
  46.     }
  48.     @Override
  49.     public E set(int index, E element) {
  50.         E oldValue = a[index];
  51.         a[index] = element;
  52.         return oldValue;
  53.     }
  55.     @Override
  56.     public int indexOf(Object o) {
  57.         E[] a = this.a;
  58.         if (o == null) {
  59.             for (int i = 0; i < a.length; i++)
  60.                 if (a[i] == null)
  61.                     return i;
  62.         } else {
  63.             for (int i = 0; i < a.length; i++)
  64.                 if (o.equals(a[i]))
  65.                     return i;
  66.         }
  67.         return -1;
  68.     }
  70.     @Override
  71.     public boolean contains(Object o) {
  72.         return indexOf(o) != -1;
  73.     }
  75.     @Override
  76.     public Spliterator<E> spliterator() {
  77.         return Spliterators.spliterator(a, Spliterator.ORDERED);
  78.     }
  80.     @Override
  81.     public void forEach(Consumer<? super E> action) {
  82.         Objects.requireNonNull(action);
  83.         for (E e : a) {
  84.             action.accept(e);
  85.         }
  86.     }
  88.     @Override
  89.     public void replaceAll(UnaryOperator<E> operator) {
  90.         Objects.requireNonNull(operator);
  91.         E[] a = this.a;
  92.         for (int i = 0; i < a.length; i++) {
  93.             a[i] = operator.apply(a[i]);
  94.         }
  95.     }
  97.     @Override
  98.     public void sort(Comparator<? super E> c) {
  99.         Arrays.sort(a, c);
  100.     }
  101. }
  1. public static void main(String[] args) {
  2.     //创建一个数组
  3.     int[] a = {1,2,3};
  4.     //new 一个 ArrayList
  5.     ArrayList<Integer> list = new ArrayList<>();
  6.     list.add(1);
  7.     list.add(2);
  8.     list.add(3);
  9.     
  10.     
  11.     System.out.println(list);//[1, 2, 3]
  12.     
  13.     System.out.println(a); //[I@1540e19d
  14.     System.out.println(Arrays.toString(a));//[1, 2, 3]
  15.     
  16.     /*如果将基本数据类型的数组作为参数传入，该方法会把整个数组当成一个元素*/
  17.     System.out.println(Arrays.asList(a));//[[I@1540e19d] 
  18.     System.out.println(Arrays.asList(1,2,3));//[1, 2, 3]
  19. }

对数组所有元素进行升序排序，没有返回值。

  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. Arrays.sort(a);
  3. System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5, 6, 7, 8, 9]

对数组特定序列进行升序排序，从 [fromIndex, endIndex]区域的数组元素进行排序

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

利用自定义的比较器，来对数组元素进行排序

  2. // Java program to demonstrate working of Comparator
  3. // interface
  4. import java.util.*;
  5. import java.lang.*;
  6. import java.io.*;
  8. // A class to represent a student.
  9. class Student {
  10.     int rollno;
  11.     String name, address;
  13.     // Constructor
  14.     public Student(int rollno, String name,
  15.                    String address)
  16.     {
  17.         this.rollno = rollno;
  18.         this.name = name;
  19.         this.address = address;
  20.     }
  22.     // Used to print student details in main()
  23.     public String toString()
  24.     {
  25.         return this.rollno + " "
  26.             + this.name + " "
  27.             + this.address;
  28.     }
  29. }
  30. //自定义的比较器，对两个对象的 rollno 属性进行比较
  31. class Sortbyroll implements Comparator<Student> {
  32.     // Used for sorting in ascending order of
  33.     // roll number
  34.     public int compare(Student a, Student b)
  35.     {
  36.         return a.rollno - b.rollno;
  37.     }
  38. }
  40. // Driver class
  41. class Main {
  42.     public static void main(String[] args)
  43.     {
  44.         Student[] arr = { new Student(1, "bbbb", "london"),
  45.                          new Student(3, "aaaa", "nyc"),
  46.                          new Student(2, "cccc", "jaipur") };
  48.         System.out.println("Unsorted-未排序前");
  49.         for (int i = 0; i < arr.length; i++)
  50.             System.out.println(arr[i]);
  52.         Arrays.sort(arr, new Sortbyroll());
  54.         System.out.println("\nSorted by rollno-排序后");
  55.         for (int i = 0; i < arr.length; i++)
  56.             System.out.println(arr[i]);
  57.     }
  58. }
  59. /** 输出结果：
  60. *Unsorted-未排序前
  61. *1 bbbb london
  62. *3 aaaa nyc
  63. *2 cccc jaipur
  64. *
  65. *Sorted by rollno-排序后
  66. *1 bbbb london
  67. *2 cccc jaipur
  68. *3 aaaa nyc
  69. *
  70. **/

利用自定义的比较器，来对数组中指定范围元素进行排序

把4中代码换成

  1. Arrays.sort(arr, 1, 2, new Sortbyroll());//对第一、二个元素进行比较
  2. /** 输出结果：
  3. *Unsorted-未排序前
  4. *1 bbbb london
  5. *3 aaaa nyc
  6. *2 cccc jaipur
  7. *
  8. *Sorted by rollno-排序后
  9. *1 bbbb london
  10. *3 aaaa nyc
  11. *2 cccc jaipur
  12. *
  13. **/

对数组元素进行升序排序，当数据规模较大时，性能更好（并行排序）。

  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. Arrays.parallelSort(a);
  3. System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 9, 5, 6, 7, 8]

用 fillValue 值来填充数组。前一个函数填充所有，后面的函数填充指定范围。

  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. Arrays.fill(a,1);//[1, 1, 1, 1, 1, 1, 1, 1, 1]
  3. Arrays.fill(a,1,3,1);//[1, 1, 1, 9, 4, 5, 6, 7, 8]

判断两个数组是否相等, 返回布尔值

equals()主要针对基本数据和Object 一维数组，其比较规则如下：

  1. if (a==a2)
  2.     return true;
  3. if (a==null || a2==null)
  4.     return false;
  6. int length = a.length;
  7. if (a2.length != length)
  8.     return false;
  10. for (int i=0; i<length; i++) {
  11.     Object o1 = a[i];
  12.     Object o2 = a2[i];
  13.     if (!(o1==null ? o2==null : o1.equals(o2)))
  14.         return false;
  15. }
  17. return true;

deepEquals()主要是多维数组的比较，其比较规则为：

  1. if (a1 == a2)
  2.     return true;
  3. if (a1 == null || a2==null)
  4.     return false;
  5. int length = a1.length;
  6. if (a2.length != length)
  7.     return false;
  9. for (int i = 0; i < length; i++) {
  10.     Object e1 = a1[i];
  11.     Object e2 = a2[i];
  13.     if (e1 == e2)
  14.         continue;
  15.     if (e1 == null)
  16.         return false;
  18.     // Figure out whether the two elements are equal
  19.     boolean eq = deepEquals0(e1, e2);
  21.     if (!eq)
  22.         return false;
  23. }
  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. int[] b = {1,2};
  3. int[][] c = {{1,2},{1,3}};
  4. int[][] d = {{1,2},{1,3}};
  5. Arrays.equals(a,b);//false
  6. Arrays.equals(c,d);//true

返回该数组的哈希值

前面一个函数是返回一维数组，后面是多维数组

  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. int[][] c = {{1,2},{1,3}};
  3. System.out.println(Arrays.hashCode(a));//887857437
  4. System.out.println(Arrays.deepHashCode(c));//31776

方法一：在数组中对某值进行二分查找（注意要先对数组排序！），如果存在返回其下标，否则返回 -（数组极值下标 +1）。

方法二：方法中的参数限定数组的范围，Comparator 是自定义的比较器

  1. int[] a = {1,2,3,4,5,9,6,7,8};
  2. Arrays.sort(a);
  3. System.out.println(Arrays.binarySearch(a,1));//0
  4. System.out.println(Arrays.binarySearch(a,0));//-1
  5. System.out.println(Arrays.binarySearch(a,10));//-10

方法一：拷贝数组，newLength 是拷贝的长度，如果超过原数组的长度，则用 null 进行填充。并返回一个新数组。

方法二：拷贝数组，fromIndex 和 endIndex 是数组的范围下标。并返回一个新数组。

  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. System.out.println(Arrays.toString(Arrays.copyOf(a,3)));//[1,2,3]
  3. System.out.println(Arrays.toString(Arrays.copyOfRange(a,0,3)));//[1,2,3]

返回数组元素的字符串形式，方法一是一维数组，方法二是多维数组。

  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. System.out.println(Arrays.toString(a));//[1,2,3,9,4,5,6,7,8]
  3. int[][] c = {{1,2},{3}};
  4. System.out.println(Arrays.deepToString(c));//[[1, 2], [3]]

方法一：将数组中的所有元素，串行的使用方法提供的生成器函数来计算每个元素（一元操作）

方法二：将数组中的所有元素，串行的使用方法提供的生成器来计算每个元素（一元操作）适用于大规模数据

  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. Arrays.setAll(a, i -> a[i] * 2);
  3. System.out.println(Arrays.toString(a));//[2,4,6,18,8,10,12,14,16]
  5. Arrays.parallelSetAll(a, i  -> a[i] * 2);
  6. System.out.println(Arrays.toString(a));//[2,4,6,18,8,10,12,14,16]

方法一：将数组中所有元素，并行使用生成器函数来计算每个元素（二元操作）

方法二：将数组中部分序列元素，并行使用生成器函数来计算每个元素（二元操作）

  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. Arrays.parallelPrefix(a, (x,y) -> x*y);//依次累乘
  3. System.out.println(Arrays.toString(a));//[1, 2, 6, 54, 216, 1080, 6480, 45360, 362880]
  5. Arrays.parallelPrefix(a, 0, 3, (x,y) -> x*y);//依次累乘
  6. System.out.println(Arrays.toString(a));//[1, 2, 6, 9, 4, 5, 6, 7, 8]

返回数组的分片迭代器，用于并行的遍历数组

  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. Spliterator<Integer> s = Arrays.spliterator(a);
  3. s.forEachRemaining(System.out::println);
  4. /**
  5. *
  6. *1
  7. *2
  8. *3
  9. *9
  10. *4
  11. *5
  12. *6
  13. *7
  14. *8
  15. **/

返回数组的流，可以对数组使用 Stream 相关的方法。

  1. int[] a = {1,2,3,9,4,5,6,7,8};
  2. List<Integer> list = Arrays.stream(a).collect(toList());
  3. System.out.println(list);//[1,2,3,9,4,5,6,7,]

Arrays class in Java

Java Collections – Arrays.spliterator() Example

Arrays 类常用方法解析

版权声明：本文为EthanWong原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/EthanWong/p/15240299.html