JDK源码 – 容器 – List

JDK源码 – 容器 – List

本章介绍的是List，主要学习方式是解读源码，将底层实现暴露给阅读者，这样学习更简单明了。

List是一个继承于Collection的接口，即List是集合中的一种。

List是有序的队列，List中的每一个元素都有一个索引；

第一个元素的索引值是0，往后的元素的索引值依次+1。和Set不同，List中允许有重复的元素。

实现继承Collection：

public interface List<E> extends Collection<E> {}

关于API方面。既然List是继承于Collection接口，它自然就包含了Collection中的全部函数接口；

 由于List是有序队列，它也额外的有自己的API接口。主要有“添加、删除、获取、修改指定位置的元素”、“获取List中的子队列”等。

Collection的API

abstract boolean add(E object)

abstract boolean addAll(Collection<?extends E> collection)

abstract void clear()

abstract boolean contains(Object object)

abstract boolean containsAll(Collection<?> collection)

abstract boolean equals(Object object)

abstract int hashCode()

abstract boolean isEmpty()

abstract Iterator<E> iterator()

abstract boolean remove(Object object)

abstract boolean removeAll(Collection<?> collection)

abstract boolean retainAll(Collection<?> collection)

abstract int size()

abstract<T> T[]toArray(T[]array)

abstract Object[]toArray()

// 相比与Collection，List新增的API：

abstract void add(int location,E object)

abstract boolean addAll(int location,Collection<?extends E> collection)

abstract E get(int location)

abstract int indexOf(Object object)

abstract int lastIndexOf(Object object)

abstract ListIterator<E> listIterator(int location)

abstract ListIterator<E> listIterator()

abstract E remove(int location)

abstract E set(int location,E object)

下面是源码，搂一搂，秒懂：

package java.util;
import java.util.function.UnaryOperator;

//继承collection的list接口
public interface List<E> extends Collection<E> {

//集合内子集个数
    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);
//取集合交集

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();

//得到索引位置元素
    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);
//迭代方法

ListIterator<E> listIterator();
    ListIterator<E> listIterator(int index);
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}