转载

Java-Arrays类常用方法详解

一、Arrays类的定义

Arrays类位于 java.util 包中，主要包含了操纵数组的各种方法

二、Arrays类的常用方法

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

将数组转换为集合，接收一个可变参

List<Integer> list = Arrays.asList(1, 2, 3);
list.forEach(System.out::println); // 1 2 3
  
  
   
   1
   
   2

Integer[] data = {1, 2, 3};
List<Integer> list = Arrays.asList(data);
list.forEach(System.out::println); // 1 2 3
  
  
   
   1
   
   2
   
   3

如果将基本数据类型的数组作为参数传入，
该方法会把整个数组当作返回的List中的第一个元素

int[] data = {1, 2, 3};
List<int[]> list = Arrays.asList(data);
System.out.println(list.size()); // 1
System.out.println(Arrays.toString(list.get(0))); // [1, 2, 3]
  
  
   
   1
   
   2
   
   3
   
   4

2、Arrays.fill()

Arrays.fill(Object[] array, Object obj)
用指定元素填充整个数组（会替换掉数组中原来的元素）

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

Arrays.fill(Object[] array, int fromIndex, int toIndex, Object obj)
用指定元素填充数组，从起始位置到结束位置，取头不取尾（会替换掉数组中原来的元素）

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

3、Arrays.sort()

Arrays.sort(Object[] array)
对数组元素进行排序（串行排序）

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

Arrays.sort(T[] array, Comparator<? super T> comparator)
使用自定义比较器，对数组元素进行排序（串行排序）

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

Arrays.sort(Object[] array, int fromIndex, int toIndex)
对数组元素的指定范围进行排序（串行排序）

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

Arrays.sort(T[] array, int fromIndex, int toIndex, Comparator<? super T> c)
使用自定义比较器，对数组元素的指定范围进行排序（串行排序）

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

4、Arrays.parallelSort()
注意：其余重载方法与 sort() 相同

Arrays.parallelSort(T[] array)
对数组元素进行排序（并行排序），当数据规模较大时，会有更好的性能

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

5、Arrays.binarySearch()
注意：在调用该方法之前，必须先调用sort()方法进行排序，如果数组没有排序，
那么结果是不确定的，此外如果数组中包含多个指定元素，则无法保证将找到哪个元素

Arrays.binarySearch(Object[] array, Object key)
使用二分法查找数组内指定元素的索引值
这里需要先看下binarySearch()方法的源码，对了解该方法有很大的帮助
从源码中可以看到

当搜索元素是数组元素，则返回该元素的索引值
如果不是数组元素，则返回 - (索引值 + 1)，具体的用法可以看下面的例子

搜索元素是数组元素，返回该元素索引值

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
System.out.println(Arrays.binarySearch(data, 1)); // 0
  
  
   
   1
   
   2
   
   3

搜索元素不是数组元素，且小于数组中的最小值

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
  
  
   
   1
   
   2
   
   3
   
   4

搜索元素不是数组元素，且大于数组中的最大值

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, 8)); // -5
  
  
   
   1
   
   2
   
   3
   
   4

搜索元素不是数组元素，但在数组范围内

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
   
   3
   
   4

Arrays.binarySearch(Object[] array, int fromIndex, int toIndex, Object obj)
使用二分法查找数组内指定范围内的指定元素的索引值

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
// {1, 3}，3的索引值为1
System.out.println(Arrays.binarySearch(data, 0, 2, 3)); // 1
  
  
   
   1
   
   2
   
   3
   
   4

6、Arrays.copyOf()

Arrays.copyOf(T[] original, int newLength)
拷贝数组，其内部调用了 System.arraycopy() 方法，从下标0开始，如果超过原数组长度，会用null进行填充

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

7、Arrays.copyOfRange(T[] original, int from, int to)

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

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

8、Arrays.equals(Object[] array1, Object[] array2)

判断两个数组是否相等，实际上比较的是两个数组的哈希值，即 Arrays.hashCode(data1) == Arrays.hashCode(data2)

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

9、Arrays.deepEquals(Object[] array1, Object[] array2)

判断两个多维数组是否相等，实际上比较的是两个数组的哈希值，即 Arrays.hashCode(data1) == Arrays.hashCode(data2)

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

10、Arrays.hashCode(Object[] array)

返回数组的哈希值

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

11、Arrays.deepHashCode(Object[] array)

返回多维数组的哈希值

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

12、Arrays.toString(Object[] array)

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

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

13、Arrays.deepToString(Object[] array)

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

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

14、Arrays.setAll(T[] array, IntFunction

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

15、Arrays.parallelSetAll(T[] array, IntFunction

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

16、Arrays.spliterator(T[] array)

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

public class Students {

    private String name;

    private Integer age;

    public Students(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    // 省略get、set方法
}

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

17、Arrays.stream(T[] array)

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

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

Arrays Java-Arrays类常用方法详解

Java-Arrays类常用方法详解

一、Arrays类的定义

二、Arrays类的常用方法

猜你喜欢