闲聊List

闲聊List

List是平时开发过程中最常使用的集合类型之一；平时只是使用，却没有好好思考List的实现，说起来真是惭愧。
首先放上List的类型关系图

从类型关系图中可以看出List是一个接口，继承自Collection，Collection又继承自Iterable。

首先来看下Iterable的源码，源码很简单，只定义了三个方法。目前我只知道如果一个类实现了Iterable接口，那么这个类的对象就可以foreach(E e : a)的语法进行迭代

public interface Iterable<T> {
    // 返回一个迭代器
    Iterator<T> iterator();

    // 遍历所有的元素，如果有异常发生则中止
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    // 返回一个并行迭代器
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

接下来再看看Collection的源码，可以看到Collection中定义了很多集合操作的方法

public interface Collection<E> extends Iterable<E> {

    // 返回集合中元素的数量
    int size();

    // 返回集合是否为空
    boolean isEmpty();

    // 返回集合中是否包含指定元素
    boolean contains(Object o);

    // 返回一个包含此集合中所有元素的数组
    Object[] toArray();

    // 返回一个指定类型的，包含此集合中所有元素的数组
    <T> T[] toArray(T[] a);

    // 向集合中添加一个元素
    boolean add(E e);

    // 从集合中删除一个指定的元素
    boolean remove(Object o);

    // 判断集合是否包含另一个集合中的所有元素
    boolean containsAll(java.util.Collection<?> c);

    // 向集合中添加另一个集合中所有的元素
    boolean addAll(java.util.Collection<? extends E> c);

    // 从集合中删除当前集合与指定集合的交集元素
    boolean removeAll(java.util.Collection<?> c);

    // 从集合中删除满足断言的元素
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }

    // 从集合中删除当前集合与指定集合的余集元素，也就是只保留当前集合与指定集合的交集元素
    boolean retainAll(java.util.Collection<?> c);

    // 清空集合
    void clear();

    // 返回一个流
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    // 通过并行迭代器返回一个流
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

最后就list的源码

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

    // 将list中所有的元素改为通过UnaryOperator计算之后的值
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

    // 通过一个Comparator对list中的元素进行排序
    @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);
        }
    }

    // 返回指定索引位置的元素
    E get(int index);

    // 设置指定索引位置的元素，如果这个索引位置之前有值将被覆盖
    E set(int index, E element);

    // 在指定索引位置添加元素，如果这个索引位置之前有值的话，将这个索引位置(含)开始往后的所有元素向右移动一位
    void add(int index, E element);

    // 删除指定位置的元素，之后的元素将向左移一位
    E remove(int index);

    // 返回第一个匹配指定元素的索引，如果不存在返回-1
    int indexOf(Object o);

    // 返回最后一个匹配指定元素的索引，如果不存在返回-1
    int lastIndexOf(Object o);

    // 1.使用范围不同，Iterator可以应用于所有的集合，Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型。
    // 2.ListIterator有add方法，可以向List中添加对象，而Iterator不能。
    // 3.ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator不可以。
    // 4.ListIterator可以定位当前索引的位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。
    // 5.都可实现删除操作，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改。
    ListIterator<E> listIterator();

    // 从指定位置开始返回一个listIterator
    ListIterator<E> listIterator(int index);

    // 1，该方法返回的是父list的一个视图，从fromIndex（包含），到toIndex（不包含）。fromIndex=toIndex 表示子list为空
    // 2，父子list做的非结构性修改（non-structural changes）都会影响到彼此：所谓的“非结构性修改”，是指不涉及到list的大小改变的修改。相反，结构性修改，指改变了list大小的修改。
    // 3，对于结构性修改，子list的所有操作都会反映到父list上。但父list的修改将会导致返回的子list失效。
    // 4，tips：如何删除list中的某段数据：
    // list.subList(from, to).clear();
    java.util.List<E> subList(int fromIndex, int toIndex);
}

看完源码才知道这其中还有一些方法从来没有用过，就更别说搞懂了，只是夜已至深，只好暂且记下，留待明日再战。
Iterable

spliterator()

Collection

stream()
parallelStream()

List

listIterator(int index)
removeIf(Predicate<? super E> filter)