Java-List

List接口实现了Collection接口，主要有以下函数：

//返回大小
int size();

//判空
boolean isEmpty();

//判断是否包含
boolean contains(Object o);


Iterator<E> iterator();


Object[] toArray();


<T> T[] toArray(T[] a);



boolean add(E e);

boolean remove(Object o);



boolean containsAll(Collection<?> c);


boolean addAll(Collection<? extends E> c);


boolean addAll(int index, Collection<? extends E> c);


boolean removeAll(Collection<?> c);

//删除掉不在c中的元素
boolean retainAll(Collection<?> c);



default void replaceAll(UnaryOperator<E> operator) {
    Objects.requireNonNull(operator);
    final ListIterator<E> li = this.listIterator();
    while (li.hasNext()) {
        li.set(operator.apply(li.next()));
    }
}




@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}


void clear();
boolean equals(Object o);


int hashCode();


//下面是比Collection多的方法
E get(int index);


E set(int index, E element);


void add(int index, E element);


E remove(int index);


int indexOf(Object o);



int lastIndexOf(Object o);


// List Iterators
ListIterator<E> listIterator();


ListIterator<E> listIterator(int index);

// View


List<E> subList(int fromIndex, int toIndex);


//重写了Collection的可分割迭代器
@Override
default Spliterator<E> spliterator() {
    if (this instanceof RandomAccess) {
        return new AbstractList.RandomAccessSpliterator<>(this);
    } else {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}


//下面的暂时还没看
static <E> List<E> of() {
    return ImmutableCollections.emptyList();
}


static <E> List<E> of(E e1) {
    return new ImmutableCollections.List12<>(e1);
}


static <E> List<E> of(E e1, E e2) {
    return new ImmutableCollections.List12<>(e1, e2);
}


static <E> List<E> of(E e1, E e2, E e3) {
    return new ImmutableCollections.ListN<>(e1, e2, e3);
}


static <E> List<E> of(E e1, E e2, E e3, E e4) {
    return new ImmutableCollections.ListN<>(e1, e2, e3, e4);
}


static <E> List<E> of(E e1, E e2, E e3, E e4, E e5) {
    return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5);
}


static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
    return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                            e6);
}


static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
    return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                            e6, e7);
}


static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
    return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                            e6, e7, e8);
}


static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
    return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                            e6, e7, e8, e9);
}


static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
    return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                            e6, e7, e8, e9, e10);
}


@SafeVarargs
@SuppressWarnings("varargs")
static <E> List<E> of(E... elements) {
    switch (elements.length) { // implicit null check of elements
        case 0:
            return ImmutableCollections.emptyList();
        case 1:
            return new ImmutableCollections.List12<>(elements[0]);
        case 2:
            return new ImmutableCollections.List12<>(elements[0], elements[1]);
        default:
            return new ImmutableCollections.ListN<>(elements);
    }
}


static <E> List<E> copyOf(Collection<? extends E> coll) {
    return ImmutableCollections.listCopy(coll);
}