Arrays：有一套用于数组的static实用方法，在java.util类库

asList(T… data)

该方法返回的是 Arrays 内部静态类 ArrayList，而不是我们平常使用的 ArrayList,，该静态类 ArrayList 没有覆盖父类的 add(), remove() 等方法，所以如果直接调用，会报 UnsupportedOperationException 异常

  1. // 将数组转换为集合，接收一个可变参数
  2. List<Integer> list = Arrays.asList(1, 2, 3);
  3. list.forEach(System.out::println); // 1 2 3
  5. Integer[] data = {1, 2, 3};
  6. List<Integer> list = Arrays.asList(data);
  7. list.forEach(System.out::println); // 1 2 3
  9. // 如果将基本数据类型的数组作为参数传入，该方法会把整个数组当作一个元素
  10. int[] data = {1, 2, 3};
  11. List<int[]> list = Arrays.asList(data);
  12. System.out.println(list.size()); // 1
  13. System.out.println(Arrays.toString(list.get(0))); // [1, 2, 3]

fill(Object[] array, Object obj)

用指定元素填充整个数组 (会替换掉数组中原来的元素)

  1. Integer[] data = {1, 2, 3, 4};
  2. Arrays.fill(data, 9);
  3. System.out.println(Arrays.toString(data)); // [9, 9, 9, 9]

fill(Object[] array, int fromIndex, int toIndex, Object obj)

用指定元素填充数组，从起始位置到结束位置，取头不取尾 (会替换掉数组中原来的元素)

  1. Integer[] data = {1, 2, 3, 4};
  2. Arrays.fill(data, 0, 2, 9);
  3. System.out.println(Arrays.toString(data)); // [9, 9, 3, 4]

sort(Object[] array)

对数组元素进行排序 (串行排序)

  1. String[] data = {"1", "4", "3", "2"};
  2. System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
  3. Arrays.sort(data);
  4. System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]

**

sort(T[] array, Comparator<? super T> comparator)

使用自定义比较器，对数组元素进行排序 (串行排序)

  1. String[] data = {"1", "4", "3", "2"};
  2. System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
  3. // 实现降序排序，返回-1放左边，1放右边，0保持不变
  4. Arrays.sort(data, (str1, str2) -> {
  5.     if (str1.compareTo(str2) > 0) {
  6.         return -1;
  7.     } else {
  8.         return 1;
  9.     }
  10. });
  11. System.out.println(Arrays.toString(data)); // [4, 3, 2, 1]

**

sort(Object[] array, int fromIndex, int toIndex)

对指定范围内的数组元素进行排序 (串行排序)

  1. String[] data = {"1", "4", "3", "2"};
  2. System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
  3. // 对下标[0, 3)的元素进行排序，即对1，4，3进行排序，2保持不变
  4. Arrays.sort(data, 0, 3);
  5. System.out.println(Arrays.toString(data)); // [1, 3, 4, 2]

**

sort(T[] array, int fromIndex, int toIndex, Comparator c)

使用自定义比较器，对指定范围内的数组元素进行排序 (串行排序)

  1. String[] data = {"1", "4", "3", "2"};
  2. System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
  3. // 对下标[0, 3)的元素进行降序排序，即对1，4，3进行降序排序，2保持不变
  4. Arrays.sort(data, 0, 3, (str1, str2) -> {
  5.     if (str1.compareTo(str2) > 0) {
  6.         return -1;
  7.     } else {
  8.         return 1;
  9.     }
  10. });
  11. System.out.println(Arrays.toString(data)); // [4, 3, 1, 2]

parallelSort(T[] array)

其余重载方法与 Arrays.sort() 相同
对数组元素进行排序 (并行排序)，当数据规模较大时，会有更好的性能

  1. String[] data = {"1", "4", "3", "2"};
  2. Arrays.parallelSort(data);
  3. System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]

**

binarySearch(Object[] array, Object key)

用于已排序的数组中二分查找数组元素。即调用该方法前，必须先调用Arrays.sort() 方法进行排序
如果数组中包含多个指定元素，则无法保证将找到哪个元素
binarySearch()源码如下：

  1. public static int binarySearch(Object[] array, Object key){
  2.     return binarySearch(array,0,array.length,key);
  3. }
  4. public static int binarySearch(Object[] array, int fromIndex, int toIndex, Object obj){
  5.     int low = fromIndex;
  6.     int high = toIndex - 1;
  8.     while (low <= high) {
  9.         int mid = (low + high) >>> 1;
  10.         int midVal = a[mid];
  12.         if (midVal < key)
  13.             low = mid + 1;
  14.         else if (midVal > key)
  15.             high = mid - 1;
  16.         else
  17.             return mid; // key found
  18.     }
  19.     return -(low + 1);  // key not found.
  20. }
  • 从源码中可以看到
    • 当搜索元素是数组元素时，返回该元素的索引值
    • 当搜索元素不是数组元素时，返回 - (索引值 + 1) ```java // 搜索元素是数组元素，返回该元素索引值 Integer[] data = {1, 3, 5, 7}; Arrays.sort(data); System.out.println(Arrays.binarySearch(data, 1)); // 0

// 搜索元素不是数组元素，且小于数组中的最小值 Integer[] data = {1, 3, 5, 7}; Arrays.sort(data); // 此时程序会把数组看作 {0, 1, 3, 5, 7}，此时0的索引值为0，则搜索0时返回 -(0 + 1) = -1 System.out.println(Arrays.binarySearch(data, 0)); // -1

// 搜索元素不是数组元素，且大于数组中的最大值 Integer[] data = {1, 3, 5, 7}; Arrays.sort(data); // 此时程序会把数组看作 {1, 3, 5, 7， 9}，此时9的索引值为4，则搜索8时返回 -(4 + 1) = -5 System.out.println(Arrays.binarySearch(data, 9)); // -5

// 搜索元素不是数组元素，但在数组范围内 Integer[] data = {1, 3, 5, 7}; Arrays.sort(data); // 此时程序会把数组看作 {1, 2, 3, 5, 7}，此时2的索引值为1，则搜索2时返回 -(1 + 1) = -2 System.out.println(Arrays.binarySearch(data, 2)); // -2

  1. **
  2. <a name="6BW5E"></a>
  3. ### binarySearch(Object[] array, int fromIndex, int toIndex, Object obj)
  4. 使用**二分法**查找数组内指定范围内的指定元素的索引值
  5. ```java
  6. Integer[] data = {1, 3, 5, 7};
  7. Arrays.sort(data);
  8. // {1, 3}，3的索引值为1
  9. System.out.println(Arrays.binarySearch(data, 0, 2, 3)); // 1

copyOf(T[] original, int newLength)

拷贝数组，其内部调用了 System.arraycopy() 方法，从下标 0 开始，如果超过原数组长度，则会用 null 进行填充

  1. Integer[] data1 = {1, 2, 3, 4};
  2. Integer[] data2 = Arrays.copyOf(data1, 2);
  3. System.out.println(Arrays.toString(data2)); // [1, 2]
  4. Integer[] data3 = Arrays.copyOf(data1, 5);
  5. System.out.println(Arrays.toString(data3)); // [1, 2, 3, 4, null]
  1.         // 浅拷贝
  2.         Integer[] i1 = {1,2,3};
  3.         Integer[] i2 = Arrays.copyOf(i1,3);
  4.         System.out.println(Arrays.toString(i1));
  5.         System.out.println(Arrays.toString(i2));
  6.         System.out.println("--------------------");
  7.         i2[2]=0;
  8.         System.out.println(Arrays.toString(i1));
  9.         System.out.println(Arrays.toString(i2));
  11.         // 深拷贝
  12.         System.out.println("--------------------");
  13.         Student[] students = new Student[2];
  14.         students[0]= new Student("1","zhang1");
  15.         students[1]= new Student("2","zhang2");
  16.         Student[] copy = Arrays.copyOf(students,2);
  17.         for (Student s :students){
  18.             System.out.println(s.toString());
  19.         }
  20.         for (Student s :copy){
  21.             System.out.println(s.toString());
  22.         }
  23.         System.out.println("------------------------");
  24.         copy[1].setName("zhang");
  25.         for (Student s :students){
  26.             System.out.println(s.toString());
  27.         }
  28.         for (Student s :copy){
  29.             System.out.println(s.toString());
  30.         }
  32.         // 浅拷贝
  33.         System.out.println("------------------------");
  34.         String[] s1 = {"1","2","3"};
  35.         String[] s2 = Arrays.copyOf(s1,3);
  36.         System.out.println(Arrays.toString(s1));
  37.         System.out.println(Arrays.toString(s2));
  38.         System.out.println("--------------------");
  39.         s2[2]="0";
  40.         System.out.println(Arrays.toString(s1));
  41.         System.out.println(Arrays.toString(s2));

copyOfRange(T[] original, int fromIndex, int toIndex)

拷贝数组，指定起始位置和结束位置，如果超过原数组长度，则会用 null 进行填充

  1. Integer[] data1 = {1, 2, 3, 4};
  2. Integer[] data2 = Arrays.copyOfRange(data1, 0, 2);
  3. System.out.println(Arrays.toString(data2)); // [1, 2]
  4. Integer[] data2 = Arrays.copyOfRange(data1, 0, 5);
  5. System.out.println(Arrays.toString(data2)); // [1, 2, 3, 4, null]

equals(Object[] array1, Object[] array2)

判断两个数组是否相等

  • 数组元素为基本数据类型时，依次比较值
  • 数组元素为引用数据类型时，依次调用元素的 equals() 方法进行比较

即如果两个数组被认为是相等的，则两个数组中应包含相同顺序的相同元素

  1. Integer[] data1 = {1, 2, 3};
  2. Integer[] data2 = {1, 2, 3};
  3. System.out.println(Arrays.equals(data1, data2)); // true

**

deepEquals(Object[] array1, Object[] array2)

判断两个多维数组是否相等

  • 数组元素为基本数据类型时，依次比较值
  • 数组元素为引用数据类型时，依次调用元素的 equals() 方法进行比较

即如果两个多维数组被认为是相等的，则两个多维数组中应包含相同顺序的相同元素

  1. Integer[][] data1 = {{1,2,3}, {1,2,3}};
  2. Integer[][] data2 = {{1,2,3}, {1,2,3}};
  3. System.out.println(Arrays.deepEquals(data1, data2)); // true

hashCode(Object[] array)

返回数组的哈希值

  1. Integer[] data = {1, 2, 3};
  2. System.out.println(Arrays.hashCode(data)); // 30817

**

deepHashCode(Object[] array)

返回多维数组的哈希值

  1. Integer[][] data = {{1, 2, 3}, {1, 2, 3}};
  2. System.out.println(Arrays.deepHashCode(data)); // 987105

**

toString(Object[] array)

返回数组元素的字符串形式
toString()源码如下：

  1. public static String toString(int[] a) {
  2.     if (a == null)
  3.         return "null";
  4.     int iMax = a.length - 1;
  5.     if (iMax == -1)
  6.         return "[]";
  8.     StringBuilder b = new StringBuilder();
  9.     b.append('[');
  10.     for (int i = 0; ; i++) {
  11.         b.append(a[i]);
  12.         if (i == iMax)
  13.             return b.append(']').toString();
  14.         b.append(", ");
  15.     }
  16. }
  1. Integer[] data = {1, 2, 3};
  2. System.out.println(Arrays.toString(data)); // [1, 2, 3]

**

deepToString(Object[] array)

返回数组元素的字符串形式

  1. Integer[][] data = {{1, 2, 3}, {1, 2, 3}};
  2. System.out.println(Arrays.deepToString(data)); // [[1, 2, 3], [1, 2, 3]]

**

setAll(T[] array, IntFunction<? extends T> generator)

让数组中的所有元素，串行地使用方法提供的生成器函数来计算每个元素 (一元操作)

  1. Integer[] data = {1, 2, 3, 4};
  2. // i为索引值
  3. Arrays.setAll(data, i -> data[i] * 2);
  4. System.out.println(Arrays.toString(data)); // [2, 4, 6, 8]

**

parallelSetAll(T[] array, IntFunction<? extends T> generator)

让数组中的所有元素，并行地使用方法提供的生成器函数来计算每个元素 (一元操作)，当数据规模较大时，会有更好的性能

  1. Integer[] data = {1, 2, 3, 4};
  2. // i为索引值
  3. Arrays.parallelSetAll(data, i -> data[i] * 2);
  4. System.out.println(Arrays.toString(data)); // [2, 4, 6, 8]

**

parallelPrefix(T[] array, BinaryOperator op)

让数组中的所有元素，并行地使用方法提供的生成器函数来计算每个元素 (二元操作)，当数据规模较大时，会有更好的性能

  1. Integer[] data = {2, 3, 4, 5};
  2. // 第一个元素2不变，将其与第二个元素3一起作为参数x, y传入，得到乘积6，作为数组新的第二个元素
  3. // 再将6和第三个元素4一起作为参数x, y传入，得到乘积24，作为数组新的第三个元素，以此类推
  4. Arrays.parallelPrefix(data, (x, y) -> x * y);
  5. System.out.println(Arrays.toString(data)); // [2, 6, 24, 120]

**

parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator op)

让指定范围内的数组元素，并行地使用方法提供的生成器函数来计算每个元素 (二元操作)，当数据规模较大时，会有更好的性能

  1. Integer[] data = {2, 3, 4, 5};
  2. // 第一个元素2不变，将其与第二个元素3一起作为参数x, y传入，得到乘积6，作为数组新的第二个元素
  3. // 再将6和第三个元素4一起作为参数x, y传入，得到乘积24，作为数组新的第三个元素，以此类推
  4. Arrays.parallelPrefix(data, 0, 3, (x, y) -> x * y);
  5. System.out.println(Arrays.toString(data)); // [2, 6, 24, 5]

**

spliterator(T[] array)

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

  1. public class Students {
  2.     private String name;
  3.     private Integer age;
  5.     public Students(String name, Integer age) {
  6.         this.name = name;
  7.         this.age = age;
  8.     }
  9.     // 省略get、set方法
  10. }
  12. public static void main(String[] args) {
  13.     Students[] data = new Students[5];
  14.     IntStream.range(0,5).forEach(i -> data[i] = new Students("小明"+i+"号", i));
  15.     // 返回分片迭代器
  16.     Spliterator<Students> spliterator = Arrays.spliterator(data);
  17.     spliterator.forEachRemaining(stu -> {
  18.         System.out.println("学生姓名: " + stu.getName() + "  " + "学生年龄: " + stu.getAge());
  19.         // 学生姓名: 小明0号  学生年龄: 0
  20.         // 学生姓名: 小明1号  学生年龄: 1
  21.         // 学生姓名: 小明2号  学生年龄: 2
  22.         // 学生姓名: 小明3号  学生年龄: 3
  23.         // 学生姓名: 小明4号  学生年龄: 4
  24.     });
  25. }

**

stream(T[] array)

返回数组的流 (Stream)，然后我们就可以使用 Stream 相关的许多方法了

  1. Integer[] data = {1, 2, 3, 4};
  2. List<Integer> list = Arrays.stream(data).collect(toList());
  3. System.out.println(list); // [1, 2, 3, 4]