【Java】ArrayList＜＞()和Collections.emptyList()的区别_return new arraylist<>(); 和 collections.emptylist(-CSDN博客

本文探讨了ArrayList无参构造器与Collections.emptyList()创建空列表的异同。相同点在于两者都能返回空列表，不同点在于Collections.emptyList()是类型安全且不可变的，而ArrayList无参构造器则预留了容量，可能造成内存浪费。因此，建议在需要空列表时使用Collections.emptyList()以节省资源。

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

一、先看源码

1.ArrayList<>()

  public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

构造一个具有指定初始容量的空列表。
参数：
initialCapacity – 列表的初始容量
抛出：
IllegalArgumentException – 如果指定的初始容量为负

这里我们可以发现，如果初始化的size是0，就会得到一个EMPTY_ELEMENTDATA。

2.Collections.emptyList()

Collections类官方的注释是这样的

此类仅包含对集合进行操作或返回集合的静态方法。它包含对集合进行操作的多态算法、“包装器”，它返回由指定集合支持的新集合，以及其他一些零碎的东西。
如果提供给它们的集合或类对象为空，则该类的方法都将抛出 NullPointerException。
此类中包含的多态算法的文档通常包括对实现的简要说明。此类描述应被视为实现说明，而不是规范的一部分。只要遵守规范本身，实现者应该可以随意替换其他算法。（例如，sort 使用的算法不一定是归并排序，但它必须是稳定的。）
此类中包含的“破坏性”算法，即修改它们操作的集合的算法，如果集合不支持适当的变异原语（例如 set 方法），则指定为抛出 UnsupportedOperationException。如果调用对集合没有影响，则这些算法可能（但不是必需）抛出此异常。例如，对已排序的不可修改列表调用 sort 方法可能会也可能不会抛出 UnsupportedOperationException。

Collections是聚合的工具类，我们调用的emptyList()的源码如下

    @SuppressWarnings("unchecked")
    public static final <T> List<T> emptyList() {
        return (List<T>) EMPTY_LIST;
    }

其中EMPTY_LIST实例化了一个EmptyList，EmptyList的源码如下

    private static class EmptyList<E>
        extends AbstractList<E>
        implements RandomAccess, Serializable {
        private static final long serialVersionUID = 8842843931221139166L;

        public Iterator<E> iterator() {
            return emptyIterator();
        }
        public ListIterator<E> listIterator() {
            return emptyListIterator();
        }

        public int size() {return 0;}
        public boolean isEmpty() {return true;}

        public boolean contains(Object obj) {return false;}
        public boolean containsAll(Collection<?> c) { return c.isEmpty(); }

        public Object[] toArray() { return new Object[0]; }

        public <T> T[] toArray(T[] a) {
            if (a.length > 0)
                a[0] = null;
            return a;
        }

        public E get(int index) {
            throw new IndexOutOfBoundsException("Index: "+index);
        }

        public boolean equals(Object o) {
            return (o instanceof List) && ((List<?>)o).isEmpty();
        }

        public int hashCode() { return 1; }

        @Override
        public boolean removeIf(Predicate<? super E> filter) {
            Objects.requireNonNull(filter);
            return false;
        }
        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
        }
        @Override
        public void sort(Comparator<? super E> c) {
        }

        // Override default methods in Collection
        @Override
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
        }

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

        // Preserves singleton property
        private Object readResolve() {
            return EMPTY_LIST;
        }
    }