为什么java.util.Arrays中有ArrayList声明

在JDK1.7中，有一个

ArrayList

声明，由

asList

使用

为什么他们创建了一个新的

私有静态类

，而没有使用

java.util.ArrayList

：

@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

/**
 * @serial include
 */
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) {
        if (array==null)
            throw new NullPointerException();
        a = array;
    }

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

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

    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;
    }

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

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

    public int indexOf(Object o) {
        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;
    }

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

@SafeVarargs
公共静态列表asList（T…a）{
返回新的ArrayList（a）；
}
/**
*@系列包括
*/
私有静态类ArrayList扩展了AbstractList
实现随机访问，java.io.Serializable
{
私有静态最终长serialVersionUID=-2764017481108945198L；
私人决赛E[]a；
ArrayList（E[]数组）{
if（数组==null）
抛出新的NullPointerException（）；
a=阵列；
}
公共整数大小（）{
返回a.length；
}
公共对象[]toArray（）{
返回a.clone（）；
}
公共T[]toArray（T[]a）{
int size=size（）；
如果（a.长度<尺寸）
返回Arrays.copyOf（this.a，size，
（类因为默认值没有
数组列表（E[]数组）
构造函数。
因为返回的
列表
由给定数组支持。它包装该数组；对数组的更改反映在
列表
中，反之亦然

同样，由于这一点，这里返回的
列表
具有固定的大小。因此，它不能是
ArrayList
，因为
ArrayList
可以增长或收缩。
因为它们在提供的数组周围提供了一个列表包装器，即O（1），而不是从数组中的元素构建一个ArrayList，即O（n）

这是否会给您带来问题？如果是这样，可能是因为您在使用List时将变量声明为ArrayList
声明了
asList（T…a）
方法，以返回由指定数组支持的固定大小的列表，该数组也应可序列化并实现
RandomAccess

java.util.ArrayList
不符合此定义（固定大小），因此应使用另一种类型的
java.util.List
。
如果使用ArrayList，请快速从表中检索数据，因为它是基于索引的，
在需要快速检索数据的地方，我们可以使用Arraylist

但是ArrayList在删除记录时并没有更快，因为重新排列索引更为复杂

在需要更多删除记录的地方，我们可以使用LinkedList，它不是基于索引的

ArrayList声明

java.util.List

ArrayList ArrayList=new ArrayList（）；
但是，既然可以包含在实际的ArrayList中，为什么还要创建一个重复的类呢

返回一个固定大小的数组，这与

java.util.ArrayList

的行为不同。他们也可以调用此内部实现

SomeInternalListImpl

。@MarkrotVeel:我想他们应该将其命名为

ArrayReferenceList

，因为它是对底层数组的引用。列表是源数组的包装器。对列表的更改会影响数组，反之亦然。