Java类库系列--Arrays

其他网址

Class -- 02 -- Arrays类常用方法解析_Gene Xu-CSDN博客_arrays类

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 实现,我们可以发现底层实际使用了原始数组。

解决方法

法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() 方法的源码,对了解该方法有很大的帮助

 从源码中可以看到

  • 当搜索元素是数组元素时,返回该元素的索引值
  • 当搜索元素不是数组元素时,返回 - (索引值 + 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]

 

 

©️2020 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值