Java工具类系列--Arrays的用法

迈不过友情╰ 2023-10-02 13:04 26阅读 0赞

原文网址：[Java工具类系列--Arrays的用法\_IT利刃出鞘的博客-CSDN博客][Java_--Arrays_IT_-CSDN]

## 简介 ##

本文用示例介绍Java中的Arrays的常用方法。

Java中的Arrays是用来操作数组的工具类，支持如下功能：拷贝数组、转换为list、填充等。

## asList ##

**数组/多个类都可以**

package org.example.a;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) throws ClassNotFoundException {
            String s1 = "abcd";
            String s2 = "efg";
            String[] strings = {"hi", "jk", "lm"};
            List<String> list1 = Arrays.asList(s1, s2);
            List<String> list2 = Arrays.asList(strings);
            //下边这样就不可以了
            //List<String> list3 = Arrays.asList(s1, s2, strings);
    
            System.out.println(list1);
            System.out.println(list2);
        }
    }

执行结果

[abcd, efg]
    [hi, jk, lm]

**基础数组会作为一个元素**

package org.example.a;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) throws ClassNotFoundException {
            int[] a = {1, 2, 3};
            List<int[]> list = Arrays.asList(a);
    
            System.out.println(Arrays.toString(list.get(0)));
        }
    }

**执行结果**

[1, 2, 3]

**不支持增删，元素共享**

Arrays$`ArrayList`：不支持增删操作；共享原始数据（Arrays$`ArrayList`元素与Arrays的数组元素是共享的）。

源码（增加）

package org.example.a;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) {
            String[] strings = {"1", "2", "3"};
            List<String> list = Arrays.asList(strings);
            list.add("abc");
            System.out.println(list);
        }
    }

**运行结果**

Exception in thread "main" java.lang.UnsupportedOperationException  
at java.util.AbstractList.add(AbstractList.java:148)  
at java.util.AbstractList.add(AbstractList.java:108)  
at org.example.a.Demo.main(Demo.java:10)

**分析**

Arrays\#asList 返回的 ArrayList 只是 Arrays 一个内部类，并非真正的 java.util.ArrayList。

java.util.ArrayList和Arrays$ArrayList都继承自 AbstractList。而 java.util.Arrays$ArrayList 并没有重写父类的add/remove方法。而父类方法恰恰都会抛出 UnsupportedOperationException。

**源码（修改）**

package org.example.a;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) {
            String[] strings = {"1", "2", "3"};
            List<String> list = Arrays.asList(strings);
            list.set(0, "modify_1");
            strings[1] = "modify_2";
            System.out.println(list);
        }
    }

**执行结果**

\[modify\_1, modify\_2, 3\]

**原因**

查看 `java.util.Arrays$ArrayList` 实现，我们可以发现底层实际使用了原始数组。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70][]

**解决方法**

法1：外边套一层ArrayList

List<String> list = new ArrayList<>(Arrays.asList(arrays));

法2：使用谷歌的Guava包的Lists.newArrayList

List<String> list = Lists.newArrayList(arrays);

## binarySearch ##

**Arrays.binarySearch(Object\[\] array, Object key)**

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

使用**二分法**查找数组内指定元素的索引值

当搜索元素是数组元素时，返回该元素的索引值  
当搜索元素不是数组元素时，返回 - (索引值 + 1)

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

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

**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

**看下 binarySearch() 方法的源码，对了解该方法有很大的帮助**

![aHR0cHM6Ly9ub3RlLnlvdWRhby5jb20veXdzL3B1YmxpYy9yZXNvdXJjZS9mZTAzNjhhZjUxYmU0OGM1NDNiYzEzMGUwMmY1ZmVjYi94bWxub3RlL0EwQjNDNEIwM0U4MzQ1Q0I5N0VEMzFBMjIyODQxMDU5LzMzMTgw][]

![aHR0cHM6Ly9ub3RlLnlvdWRhby5jb20veXdzL3B1YmxpYy9yZXNvdXJjZS9mZTAzNjhhZjUxYmU0OGM1NDNiYzEzMGUwMmY1ZmVjYi94bWxub3RlL0M5NTBEODkwRjA5MTRCRURCMkQ0OUQ0NUFFOUYwNkU4LzMzMTgy][]

从源码中可以看到

*  当搜索元素是数组元素时，返回该元素的索引值
 *  当搜索元素不是数组元素时，返回 - (索引值 + 1)

## 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[] data3 = Arrays.copyOf(data1, 5);
    System.out.println(Arrays.toString(data3)); // [1, 2, 3, 4, null]

**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]

## equals ##

**Arrays.equals(Object\[\] array1, Object\[\] array2)**

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

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

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

**Arrays.deepEquals(Object\[\] array1, Object\[\] array2)**

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

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

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

## 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]

**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]

## **hashCode** ##

**Arrays.hashCode(Object\[\] array)**

返回数组的哈希值

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

**Arrays.deepHashCode(Object\[\] array)**

返回多维数组的哈希值

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

## **parallelPrefix** ##

**Arrays.parallelPrefix(T\[\] array, BinaryOperator op)**

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

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]

**Arrays.parallelPrefix(T\[\] array, int fromIndex, int toIndex, BinaryOperator op)**

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

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

## setAll ##

**Arrays.setAll(T\[\] array, IntFunction<? extends T> generator)**

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

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

**Arrays.parallelSetAll(T\[\] array, IntFunction<? extends T> generator)**

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

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

## **spliterator** ##

**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

## 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]

**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]

**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]

**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]

**Arrays.parallelSort(T\[\] array)**

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

对数组元素进行排序 **(并行排序)**，当数据规模较大时，会有更好的性能

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

## toString ##

**Arrays.toString(Object\[\] array)**

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

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

**Arrays.deepToString(Object\[\] array)**

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

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

## stream ##

**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]

## 其他网址 ##

[Class -- 02 -- Arrays类常用方法解析\_Gene Xu-CSDN博客\_arrays类][Class -- 02 -- Arrays_Gene Xu-CSDN_arrays]

[Java_--Arrays_IT_-CSDN]: https://knife.blog.csdn.net/article/details/121004653
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200620133321539.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc=,size_16,color_FFFFFF,t_70
[aHR0cHM6Ly9ub3RlLnlvdWRhby5jb20veXdzL3B1YmxpYy9yZXNvdXJjZS9mZTAzNjhhZjUxYmU0OGM1NDNiYzEzMGUwMmY1ZmVjYi94bWxub3RlL0EwQjNDNEIwM0U4MzQ1Q0I5N0VEMzFBMjIyODQxMDU5LzMzMTgw]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9ub3RlLnlvdWRhby5jb20veXdzL3B1YmxpYy9yZXNvdXJjZS9mZTAzNjhhZjUxYmU0OGM1NDNiYzEzMGUwMmY1ZmVjYi94bWxub3RlL0EwQjNDNEIwM0U4MzQ1Q0I5N0VEMzFBMjIyODQxMDU5LzMzMTgw
[aHR0cHM6Ly9ub3RlLnlvdWRhby5jb20veXdzL3B1YmxpYy9yZXNvdXJjZS9mZTAzNjhhZjUxYmU0OGM1NDNiYzEzMGUwMmY1ZmVjYi94bWxub3RlL0M5NTBEODkwRjA5MTRCRURCMkQ0OUQ0NUFFOUYwNkU4LzMzMTgy]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9ub3RlLnlvdWRhby5jb20veXdzL3B1YmxpYy9yZXNvdXJjZS9mZTAzNjhhZjUxYmU0OGM1NDNiYzEzMGUwMmY1ZmVjYi94bWxub3RlL0M5NTBEODkwRjA5MTRCRURCMkQ0OUQ0NUFFOUYwNkU4LzMzMTgy
[Class -- 02 -- Arrays_Gene Xu-CSDN_arrays]: https://blog.csdn.net/Goodbye_Youth/article/details/81003817