java Arrays.asList得到的是静态内部类ArrayList,并没有实现add方法

本文解析了将Array转换为ArrayList的常见误区,指出使用Arrays.asList()生成的ArrayList并非真正可变,而是Arrays类的静态内部类,仅实现了部分方法。为创建可动态调整大小的ArrayList,应使用ArrayList构造函数配合Arrays.asList()。文章提供了源代码,深入理解两种ArrayList的区别。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

当需要把Array转成ArrayList的时候,经常这样做:

List<String> list = Arrays.asList(arr);

Arrays.asList()会返回一个ArrayList,但是要特别注意,这个ArrayList是Arrays类的静态内部类,并不是java.util.ArrayList类。java.util.Arrays.ArrayList类实现了set(), get(),contains()方法,但是并没有实现增加元素的方法(事实上是可以调用add方法,但是没有具体实现,仅仅抛出UnsupportedOperationException异常),因此它的大小也是固定不变的。为了创建一个真正的java.util.ArrayList,你应该这样做:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

ArrayList的构造方法可以接收一个Collection类型,而java.util.Arrays.ArrayList已经实现了该接口。

 

Arrays.asList源代码:

    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }
  private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

        @Override
        public int size() {
            return a.length;
        }

        @Override
        public Object[] toArray() {
            return a.clone();
        }

        @Override
        @SuppressWarnings("unchecked")
        public <T> T[] toArray(T[] a) {
            int size = size();
            if (a.length < size)
                return Arrays.copyOf(this.a, size,
                                     (Class<? extends T[]>) a.getClass());
            System.arraycopy(this.a, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }

        @Override
        public E get(int index) {
            return a[index];
        }

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

        @Override
        public int indexOf(Object o) {
            E[] a = this.a;
            if (o == null) {
                for (int i = 0; i < a.length; i++)
                    if (a[i] == null)
                        return i;
            } else {
                for (int i = 0; i < a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }

        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }

        @Override
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }

        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }
    }

 

<think>嗯,用户想了解JavaArrays.asList()的用途。我得先回忆一下这个方法的用法。记得Arrays有很多静态方法asList()应该是用来把数组转换成List的。但可能有一些注意事项,比如返回的列表是不是可变的。 首先,我应该确认方法的基本功能。没错,Arrays.asList()确实将数组转换为一个固定大小的List。这里的关键点是,返回的列表是基于原数组的,所以对列表的修改会反映到数组上,比如set方法。但是不能进行结构性修改,比如添加或删除元素,否则会抛异常。 然后,用户可能想知道使用场景。比如,快速创建列表进行遍历或者作为其他集合的初始化参数。例如,new ArrayList<>(Arrays.asList(...)) 可以创建一个可变的ArrayList。这可能是一个常见用法。 还要注意基本型数组的问题。如果传入一个int数组,由于自动装箱的问题,asList()会把整个数组当作一个元素,导致列表的大小为1。这时候应该使用包装数组,比如Integer数组,才能正确转换。 另外,可能需要提醒用户这个方法返回的是Arrays内部类,而不是java.util.ArrayList,所以有些方法可能表现不同。比如,add和remove不可用,调用会抛出UnsupportedOperationException。 总结一下,回答的结构应该包括用途、注意事项、常见用法示例以及可能遇到的坑,比如基本型处理的问题。这样用户能全面了解这个方法的使用和限制。</think>`Arrays.asList()` 是 Java 中 `java.util.Arrays` 一个静态方法,主要用途是**将数组转换为一个固定长度的列表(List)**。以下是它的核心特点和典型用法: --- ### 一、核心特点 1. **快速转换** 将数组转换为 `List` 的便捷方法,适合快速初始化一个列表: ```java String[] arr = {"Apple", "Banana", "Orange"}; List<String> list = Arrays.asList(arr); // 将数组转为 List ``` 2. **固定长度** 返回的列表是**固定大小**的(基于原始数组),不可增删元素(会抛出 `UnsupportedOperationException`): ```java list.add("Grape"); // 报错!UnsupportedOperationException list.remove(0); // 报错!UnsupportedOperationException ``` 3. **视图机制** 列表与原始数组共享数据,修改数组或列表会影响彼此: ```java list.set(0, "Peach"); // 修改列表元素 System.out.println(arr[0]); // 输出 "Peach"(原数组也被修改) ``` --- ### 二、典型用途 1. **快速构建只读列表** 适合需要临时遍历或读取数据的场景: ```java for (String fruit : Arrays.asList("Apple", "Banana")) { System.out.println(fruit); } ``` 2. **作为集合初始化参数** 结合 `new ArrayList<>()` 创建可变的列表: ```java List<String> mutableList = new ArrayList<>(Arrays.asList("A", "B", "C")); mutableList.add("D"); // 允许增删操作 ``` --- ### 三、注意事项 1. **基本型数组的陷阱** 如果传入基本型数组(如 `int[]`),`asList()` 会将整个数组视为单个元素,导致列表长度为 1: ```java int[] nums = {1, 2, 3}; List<int[]> list = Arrays.asList(nums); // List 型是 int[] System.out.println(list.size()); // 输出 1(而非 3) ``` **解决方案**:使用包装数组: ```java Integer[] nums = {1, 2, 3}; List<Integer> list = Arrays.asList(nums); // 正确转换 ``` 2. **不支持结构性修改** 返回的列表是 `Arrays` 的内部类实现没有实现 `add()`、`remove()` 等方法。 --- ### 总结 - **用途**:快速将数组转为固定大小的列表,适合只读操作或作为中间结果。 - **慎用场景**:需要增删元素时,应通过 `new ArrayList<>(Arrays.asList(...))` 创建可变列表。 - **注意**:对基本型数组的处理可能不符合预期。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值