【Java8新特性系列】 List接口新特性示例源码分析

本文链接：https://blog.youkuaiyun.com/wang2leee/article/details/132957830

Java8 List接口新特性示例源码分析

文章目录

Java8 List接口新特性示例源码分析

由来

在Java 8之前，接口只能定义抽象方法，即不带实现的方法。这限制了接口的功能，并导致使用接口的类需要重复实现相同的代码。为了解决这个问题，Java 8引入了默认方法（default method）的概念，允许在接口中定义带有默认实现的方法。

签名

List接口新增的默认方法有以下几个：

default void forEach(Consumer<? super E> action)：对列表中的每个元素执行指定操作。
default Spliterator<E> spliterator()：创建一个用于遍历列表的Spliterator。
default boolean removeIf(Predicate<? super E> filter)：根据指定的条件删除满足条件的元素。
default void replaceAll(UnaryOperator<E> operator)：使用指定的操作符替换列表中的每个元素。
default void sort(Comparator<? super E> c)：使用指定的比较器对列表进行排序。

原理

默认方法通过在接口中添加具体的方法实现来工作。当一个类实现了一个接口，并且没有提供默认方法的实现时，它将继承接口中的默认方法实现。如果一个类实现了多个接口，并且这些接口都包含具有相同签名的默认方法，那么实现类必须覆盖这个默认方法，以明确指定使用哪个接口的实现。

用法

List接口新增的默认方法可以直接在实现了List接口的类中使用，无需重新实现。可以通过调用对象的方法来执行相关操作，如遍历、删除、替换和排序等。

示例

import java.util.ArrayList;
import java.util.List;

public class ListExample{

    public static void main(String[] args) {
        List<String> listExample = new ArrayList();
        listExample.add("Java");
        listExample.add("Python");
        listExample.add("C++");

        // 使用forEach遍历列表并打印元素
        listExample.forEach(System.out::println);

        // 使用removeIf删除长度小于3的元素
        listExample.removeIf(s -> s.length() < 3);
        System.out.println(listExample); // 输出：[Java, Python]

        // 使用replaceAll将所有元素转为大写
        listExample.replaceAll(String::toUpperCase);
        System.out.println(listExample); // 输出：[JAVA, PYTHON]

        // 使用sort对元素进行排序
        listExample.sort(String.CASE_INSENSITIVE_ORDER);
        System.out.println(listExample); // 输出：[JAVA, PYTHON]
    }
}

上述示例展示了如何使用List接口新增的默认方法，包括遍历元素、删除元素、替换元素和排序元素等操作。

中文源码

/**
 * 有序集合（也称为<i>序列</i>）。该接口的用户可以精确控制元素在列表中的插入位置。用户可以通过整数索引（在列表中的位置）访问元素，并在列表中搜索元素。<p>
 *
 * 与集合不同，列表通常允许重复元素。更正式地说，列表通常允许一对元素<tt>e1</tt>和<tt>e2</tt>，使得<tt>e1.equals(e2)</tt>，如果列表允许空元素，则它们通常允许多个空元素。有人可能希望通过在用户尝试插入重复元素时抛出运行时异常来实现禁止重复元素的列表，但我们预计这种用法很少见。<p>
 *
 * <tt>List</tt>接口在<tt>Collection</tt>接口指定的合同之外，还对<tt>iterator</tt>、<tt>add</tt>、<tt>remove</tt>、<tt>equals</tt>和<tt>hashCode</tt>方法的合同提供了额外的规定。这里还包括其他继承方法的声明，以方便使用。<p>
 *
 * <tt>List</tt>接口提供了四种对列表元素进行位置（索引）访问的方法。列表（如Java数组）是以零为基础的。请注意，对于某些实现（例如<tt>LinkedList</tt>类），这些操作可能以与索引值成比例的时间执行。因此，如果调用者不知道实现方式，通常优先于遍历列表中的元素，而不是通过索引进行遍历。<p>
 *
 * <tt>List</tt>接口提供了一种特殊的迭代器，称为<tt>ListIterator</tt>，它允许插入和替换元素，并支持双向访问，除了<tt>Iterator</tt>接口提供的正常操作外。还提供了一种方法，用于获取从列表中指定位置开始的列表迭代器。<p>
 *
 * <tt>List</tt>接口提供了两种搜索指定对象的方法。从性能的角度来看，应该谨慎使用这些方法。在许多实现中，它们将执行昂贵的线性搜索。<p>
 *
 * <tt>List</tt>接口提供了两种高效地在列表的任意点插入和删除多个元素的方法。<p>
 *
 * 注意：虽然列表可以包含自身作为元素，但建议极度谨慎：对于此类列表，<tt>equals</tt>和<tt>hashCode</tt>方法不再定义明确。
 *
 * <p>某些列表实现对它们可能包含的元素有限制。例如，某些实现禁止空元素，而其他实现对其元素的类型有限制。尝试添加不合格的元素会引发未经检查的异常，通常是<tt>NullPointerException</tt>或<tt>ClassCastException</tt>。尝试查询不合格元素的存在可能会引发异常，或者它可能只返回false；某些实现将表现出前一种行为，而其他实现将表现出后一种行为。更一般地说，对于不合格元素上的操作（其完成不会导致将不合格元素插入列表），根据实现的选择，可能会引发异常，也可能成功执行。在此接口的规范中，这些异常被标记为“可选”。
 *
 * <p>该接口是
 * <a href="{@docRoot}/../technotes/guides/collections/index.html">
 * Java Collections Framework</a>的成员。
 *
 * @param <E> 列表中的元素类型
 *
 * @author  Josh Bloch
 * @author  Neal Gafter
 * @see Collection
 * @see Set
 * @see ArrayList
 * @see LinkedList
 * @see Vector
 * @see Arrays#asList(Object[])
 * @see Collections#nCopies(int, Object)
 * @see Collections#EMPTY_LIST
 * @see AbstractList
 * @see AbstractSequentialList
 * @since 1.2
 */
public interface List<E> extends Collection<E> {
    // 查询操作

    /**
     * 返回列表中的元素数。如果此列表包含超过<tt>Integer.MAX_VALUE</tt>个元素，则返回<tt>Integer.MAX_VALUE</tt>。
     *
     * @return 列表中的元素数
     */
    int size();

    /**
     * 如果此列表不包含元素，则返回<tt>true</tt>。
     *
     * @return 如果此列表不包含元素，则返回<tt>true</tt>
     */
    boolean isEmpty();

    /**
     * 如果此列表包含指定的元素，则返回<tt>true</tt>。更正式地说，当且仅当此列表包含至少一个元素<tt>e</tt>，使得<tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>时，返回<tt>true</tt>。
     *
     * @param o 要在此列表中测试其存在的元素
     * @return 如果此列表包含指定的元素，则返回<tt>true</tt>
     * @throws ClassCastException 如果指定元素的类型与此列表不兼容
     *         (<a href="Collection.html#optional-restrictions">可选的</a>)
     * @throws NullPointerException 如果指定的元素为空，并且此列表不允许空元素
     *         (<a href="Collection.html#optional-restrictions">可选的</a>)
     */
    boolean contains(Object o);

    /**
     * 返回以正确顺序在此列表中的元素上进行迭代的迭代器。
     *
     * @return 以正确顺序在此列表中的元素上进行迭代的迭代器
     */
    Iterator<E> iterator();

    /**
     * 返回一个数组，其中包含此列表中所有元素（从第一个元素到最后一个元素）。
     *
     * <p>返回的数组将是“安全的”，因为此列表不维护对它的引用。（换句话说，即使此列表由数组支持，该方法也必须分配一个新的数组）。因此，调用者可以自由地修改返回的数组。
     *
     * <p>此方法充当基于数组和基于集合的API之间的桥梁。
     *
     * @return 包含此列表中所有元素的数组
     * @see Arrays#asList(Object[])
     */
    Object[] toArray();

    /**
     * 返回以正确顺序在此列表中的元素上进行迭代的数组，从第一个元素到最后一个元素；返回数组的运行时类型是指定数组的类型。如果列表适合指定的数组，则返回其中。否则，将使用指定数组的运行时类型和此列表的大小分配一个新数组。
     *
     * <p>如果列表适合具有多余空间的指定数组（即数组的元素比列表多），则数组中紧接列表末尾之后的元素将设置为<tt>null</tt>。（只有当调用者知道列表不包含任何空元素时，这才对确定列表长度有用。）
     *
     * <p>与{@link #toArray()}方法一样，此方法充当基于数组和基于集合的API之间的桥梁。此外，此方法允许精确控制输出数组的运行时类型，并且在某些情况下，可用于节省分配成本。
     *
     * <p>假设<tt>x</tt>是一个已知仅包含字符串的列表。以下代码可用于将列表转储到新分配的<tt>String</tt>数组中：
     *
     * <pre>{@code
     *     String[] y = x.toArray(new String[0]);
     * }</pre>
     *
     * 注意，<tt>toArray(new Object[0])</tt>在功能上与<tt>toArray()</tt>相同。
     *
     * @param a 存储此列表元素的数组，如果足够大；否则，将为此目的分配一个具有相同运行时类型的新数组。
     * @return 包含此列表元素的数组
     * @throws ArrayStoreException 如果指定数组的运行时类型不是该列表中每个元素的超类型
     * @throws NullPointerException 如果指定数组为空
     */
    <T> T[] toArray(T[] a);


    // 修改操作

    /**
     * 将指定的元素追加到此列表的末尾（可选操作）。
     *
     * <p>支持此操作的列表可能对可以添加到此列表的元素设置限制。特别地，一些列表将拒绝添加空元素，而其他列表将对可添加的元素类型施加限制。列表类应在其文档中明确指定可以添加哪些元素的限制。
     *
     * @param e 要追加到此列表的元素
     * @return <tt>true</tt>（由{@link Collection#add}指定）
     * @throws UnsupportedOperationException 如果此列表不支持<tt>add</tt>操作
     * @throws ClassCastException 如果指定元素的类阻止其添加到此列表中
     * @throws NullPointerException 如果指定元素为空，并且此列表不允许空元素
     * @throws IllegalArgumentException 如果此元素的某些属性阻止其添加到此列表中
     */
    boolean add(E e);

    /**
     * 从此列表中删除指定元素的第一个匹配项（可选操作）。如果此列表不包含该元素，则它保持不变。更正式地说，删除最低索引<tt>i</tt>的元素，使得<tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>（如果存在这样的元素）。（如果此列表因调用而更改，则返回<tt>true</tt>）。
     *
     * @param o 如果存在，则要从此列表中删除的元素
     * @return 如果此列表包含指定的元素，则返回<tt>true</tt>
     * @throws ClassCastException 如果指定元素的类型与此列表不兼容
     *         (<a href="Collection.html#optional-restrictions">可选的</a>)
     * @throws NullPointerException 如果指定元素为空，并且此列表不允许空元素
     *         (<a href="Collection.html#optional-restrictions">可选的</a>)
     * @throws UnsupportedOperationException 如果此列表不支持<tt>remove</tt>操作
     */
    boolean remove(Object o);


    // 批量修改操作

    /**
     * 如果此列表包含指定集合的所有元素，则返回<tt>true</tt>。
     *
     * @param  c 要在此列表中检查其包含性的集合
     * @return 如果此列表包含指定集合的所有元素，则返回<tt>true</tt>
     * @throws ClassCastException 如果指定集合中的一个或多个元素的类型与此列表不兼容
     *         (<a href="Collection.html#optional-restrictions">可选的</a>)
     * @throws NullPointerException 如果指定集合包含一个或多个空元素，并且此列表不允许空元素
     *         (<a href="Collection.html#optional-restrictions">可选的</a>)，
     *         或者如果指定集合为空
     * @see #contains(Object)
     */
    boolean containsAll(Collection<?> c);
}

/**
 * 将指定集合中的所有元素追加到列表末尾（可选操作）。此操作的行为在进行操作时如果指定集合被修改则是不确定的。（注意，如果指定集合是该列表，并且非空，则会发生这种情况。）
 *
 * @param c 包含要添加到此列表的元素的集合
 * @return 如果此列表因调用而更改，则返回<tt>true</tt>
 * @throws UnsupportedOperationException 如果此列表不支持<tt>addAll</tt>操作
 * @throws ClassCastException 如果指定集合中的一个或多个元素的类阻止其添加到此列表中
 * @throws NullPointerException 如果指定集合包含一个或多个空元素，并且此列表不允许空元素；或者指定集合为空
 * @throws IllegalArgumentException 如果指定集合的某个元素的某些属性阻止其添加到此列表中
 * @see #add(Object)
 */
boolean addAll(Collection<? extends E> c);

/**
 * 将指定集合中的所有元素插入到列表的指定位置（可选操作）。将该位置（如果存在）的元素和随后的任何元素向右移动（增加其索引）。新元素将按照它们在指定集合的迭代器返回的顺序出现在此列表中。此操作在进行操作时如果指定集合被修改则是不确定的。（注意，如果指定集合是该列表，并且非空，则会发生这种情况。）
 *
 * @param index 要将指定集合中的第一个元素插入到的索引
 * @param c 包含要添加到此列表的元素的集合
 * @return 如果此列表因调用而更改，则返回<tt>true</tt>
 * @throws UnsupportedOperationException 如果此列表不支持<tt>addAll</tt>操作
 * @throws ClassCastException 如果指定集合中的一个或多个元素的类阻止其添加到此列表中
 * @throws NullPointerException 如果指定集合包含一个或多个空元素，并且此列表不允许空元素；或者指定集合为空
 * @throws IllegalArgumentException 如果指定集合的某个元素的某些属性阻止其添加到此列表中
 * @throws IndexOutOfBoundsException 如果索引超出范围（<tt>index &lt; 0 || index &gt; size()</tt>）
 */
boolean addAll(int index, Collection<? extends E> c);

/**
 * 从此列表中删除包含在指定集合中的所有元素（可选操作）。
 *
 * @param c 包含要从此列表中删除的元素的集合
 * @return 如果此列表因调用而更改，则返回<tt>true</tt>
 * @throws UnsupportedOperationException 如果此列表不支持<tt>removeAll</tt>操作
 * @throws ClassCastException 如果此列表中的一个或多个元素的类与指定集合不兼容
 * （<a href="Collection.html#optional-restrictions">可选的</a>）
 * @throws NullPointerException 如果此列表包含空元素，并且指定集合不允许空元素
 * （<a href="Collection.html#optional-restrictions">可选的</a>），
 * 或者指定集合为null
 * @see #remove(Object)
 * @see #contains(Object)
 */
boolean removeAll(Collection<?> c);

/**
 * 仅保留此列表中包含在指定集合中的元素（可选操作）。换句话说，删除此列表中所有不包含在指定集合中的元素。
 *
 * @param c 包含要在此列表中保留的元素的集合
 * @return 如果此列表因调用而更改，则返回<tt>true</tt>
 * @throws UnsupportedOperationException 如果此列表不支持<tt>retainAll</tt>操作
 * @throws ClassCastException 如果此列表中的一个或多个元素的类与指定集合不兼容
 * （<a href="Collection.html#optional-restrictions">可选的</a>）
 * @throws NullPointerException 如果此列表包含空元素，并且指定集合不允许空元素
 * （<a href="Collection.html#optional-restrictions">可选的</a>），
 * 或者指定集合为null
 * @see #remove(Object)
 * @see #contains(Object)
 */
boolean retainAll(Collection<?> c);

/**
 * 使用操作符将列表中的每个元素替换为应用该操作符后的结果。操作符引发的错误或运行时异常会传递给调用者。
 *
 * @implSpec
 * 默认实现相当于对于此{@code list}：
 * <pre>{@code
 *     final ListIterator<E> li = list.listIterator();
 *     while (li.hasNext()) {
 *         li.set(operator.apply(li.next()));
 *     }
 * }</pre>
 *
 * 如果列表的列表迭代器不支持{@code set}操作，则在替换第一个元素时会抛出{@code UnsupportedOperationException}。
 *
 * @param operator 应用于每个元素的操作符
 * @throws UnsupportedOperationException 如果此列表是不可修改的。如果无法替换元素，或者一般情况下不支持修改，则实现可能会抛出此异常。
 * @throws NullPointerException 如果指定的操作符为null，或者操作符的结果是null值，而此列表不允许null元素（<a href="Collection.html#optional-restrictions">可选的</a>）
 * @since 1.8
 */
default void replaceAll(UnaryOperator<E> operator) {}

/**
 * 根据指定的{@link Comparator}对该列表进行排序。
 *
 * <p>该列表中的所有元素必须使用指定的比较器进行相互比较（即，对于列表中的任何元素{@code e1}和{@code e2}，{@code c.compare(e1, e2)}不能引发{@code ClassCastException}）。
 *
 * <p>如果指定的比较器为{@code null}，则该列表中的所有元素必须实现{@link Comparable}接口，并且应使用元素的{@linkplain Comparable natural ordering}。
 *
 * <p>该列表必须是可修改的，但不需要是可调整大小的。
 *
 * @implSpec
 * 默认实现获取包含该列表中所有元素的数组，对数组进行排序，并迭代该列表，从数组中相应位置重置每个元素。（这样做可以避免在原地对链表进行排序时出现n<sup>2</sup> log(n)的性能问题。）
 *
 * @implNote
 * 该实现是稳定的、自适应的、迭代式合并排序算法，在部分排序的输入数组上执行比n lg(n)更少的比较，同时在输入数组随机排序时提供传统合并排序的性能。如果输入数组几乎有序，则该实现需要大约n次比较。临时存储要求因近似排序的输入数组而变化，对于随机排序的输入数组，临时存储要求为n/2个对象引用。
 *
 * <p>该实现在其输入数组中等量利用升序和降序，并且可以在同一输入数组的不同部分中利用升序和降序。它非常适用于合并两个或多个已排序数组：只需连接数组并对结果数组进行排序即可。
 *
 * <p>该实现改编自Python的Tim Peters的列表排序（<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">TimSort</a>）。它使用了Peter McIlroy的“Optimistic Sorting and Information Theoretic Complexity”中的技术，
 * 在Discrete Algorithms的第四届ACM-SIAM Symposium上，467-474页，1993年1月发表。
 *
 * @param c 用于比较列表元素的{@code Comparator}。如果该比较器为{@code null}，则使用元素的{@linkplain Comparable natural ordering}
 * @throws ClassCastException 如果列表包含不是<i>mutually comparable</i>的元素，并使用指定的比较器进行比较
 * @throws UnsupportedOperationException 如果列表的列表迭代器不支持{@code set}操作
 * @throws IllegalArgumentException （<a href="Collection.html#optional-restrictions">可选的</a>），
 * 如果发现比较器违反了{@link Comparator}的合同
 * @since 1.8
 */
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {}

/**
 * 从此列表中删除所有元素（可选操作）。此调用返回后，列表将为空。
 *
 * @throws UnsupportedOperationException 如果<tt>clear</tt>操作不受此列表支持
 */
void clear();

// 比较和哈希

/**
 * 将指定对象与此列表进行比较以确定是否相等。当且仅当指定对象也是一个列表、两个列表具有相同的大小，并且两个列表中对应的元素对都是相等的时候，返回true。（两个元素e1和e2相等，如果(e1==null ? e2==null : e1.equals(e2))）。换句话说，当它们以相同的顺序包含相同的元素时，定义了两个列表相等。这个定义确保equals方法在不同的List接口的实现之间正常工作。
 *
 * @param o 要与此列表进行相等比较的对象
 * @return 如果指定对象等于此列表，则返回true
 */
boolean equals(Object o);

/**
 * 返回此列表的哈希码值。列表的哈希码定义为以下计算结果：
 * <pre>{@code
 *     int hashCode = 1;
 *     for (E e : list)
 *         hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
 * }</pre>
 * 这样确保了对于任何两个列表list1和list2，如果list1.equals(list2)，则要求list1.hashCode()==list2.hashCode()，符合Object.hashCode的通用约定。
 *
 * @return 此列表的哈希码值
 * @see Object#equals(Object)
 * @see #equals(Object)
 */
int hashCode();


// 位置访问操作

/**
 * 返回此列表中指定位置的元素。
 *
 * @param index 要返回的元素的索引
 * @return 此列表中指定位置的元素
 * @throws IndexOutOfBoundsException 如果索引超出范围（<tt>index &lt; 0 || index &gt;= size()</tt>）
 */
E get(int index);

/**
 * 用指定元素替换此列表中指定位置的元素（可选操作）。
 *
 * @param index 要替换的元素的索引
 * @param element 要在指定位置存储的元素
 * @return 先前位于指定位置的元素
 * @throws UnsupportedOperationException 如果此列表不支持set操作
 * @throws ClassCastException 如果指定元素的类阻止其添加到此列表中
 * @throws NullPointerException 如果指定元素为null，并且此列表不允许null元素
 * @throws IllegalArgumentException 如果指定元素的某些属性阻止其添加到此列表中
 * @throws IndexOutOfBoundsException 如果索引超出范围（<tt>index &lt; 0 || index &gt;= size()</tt>）
 */
E set(int index, E element);

/**
 * 在此列表的指定位置插入指定元素（可选操作）。将当前位于该位置的元素（如果有）和任何后续元素向右移动（索引加一）。
 *
 * @param index 要插入指定元素的索引
 * @param element 要插入的元素
 * @throws UnsupportedOperationException 如果此列表不支持add操作
 * @throws ClassCastException 如果指定元素的类阻止其添加到此列表中
 * @throws NullPointerException 如果指定元素为null，并且此列表不允许null元素
 * @throws IllegalArgumentException 如果指定元素的某些属性阻止其添加到此列表中
 * @throws IndexOutOfBoundsException 如果索引超出范围（<tt>index &lt; 0 || index &gt; size()</tt>）
 */
void add(int index, E element);

/**
 * 删除此列表中指定位置的元素（可选操作）。将任何后续元素向左移动（索引减一）。返回从列表中删除的元素。
 *
 * @param index 要删除的元素的索引
 * @return 先前位于指定位置的元素
 * @throws UnsupportedOperationException 如果此列表不支持remove操作
 * @throws IndexOutOfBoundsException 如果索引超出范围（<tt>index &lt; 0 || index &gt;= size()</tt>）
 */
E remove(int index);


// 搜索操作

/**
 * 返回此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则返回-1。更正式地说，返回最低索引i使得(o==null ? get(i)==null : o.equals(get(i)))，如果没有这样的索引，则返回-1。
 *
 * @param o 要搜索的元素
 * @return 指定元素在此列表中第一次出现的索引；如果此列表不包含该元素，则返回-1
 * @throws ClassCastException 如果指定元素的类型与此列表不兼容
 * （<a href="Collection.html#optional-restrictions">可选的</a>）
 * @throws NullPointerException 如果指定元素为null，并且此列表不允许null元素
 * （<a href="Collection.html#optional-restrictions">可选的</a>）
 */
int indexOf(Object o);

/**
 * 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。更正式地说，返回最高索引i使得(o==null ? get(i)==null : o.equals(get(i)))，如果没有这样的索引，则返回-1。
 *
 * @param o 要搜索的元素
 * @return 指定元素在此列表中最后一次出现的索引；如果此列表不包含该元素，则返回-1
 * @throws ClassCastException 如果指定元素的类型与此列表不兼容
 * （<a href="Collection.html#optional-restrictions">可选的</a>）
 * @throws NullPointerException 如果指定元素为null，并且此列表不允许null元素
 * （<a href="Collection.html#optional-restrictions">可选的</a>）
 */
int lastIndexOf(Object o);


// 列表迭代器

/**
 * 返回在此列表中元素上进行迭代的列表迭代器（按适当顺序）。
 *
 * @return 在此列表中元素上进行迭代的列表迭代器（按适当顺序）
 */
ListIterator<E> listIterator();

/**
 * 返回在此列表中元素上进行迭代的列表迭代器（按适当顺序），从列表中的指定位置开始。指定的索引表示初始调用{@link ListIterator#next next}将返回的第一个元素。对{@link ListIterator#previous previous}的初始调用将返回具有指定索引减一的元素。
 *
 * @param index 从列表迭代器返回的第一个元素的索引
 * @return 在此列表中元素上进行迭代的列表迭代器（按适当顺序），从列表中的指定位置开始
 * @throws IndexOutOfBoundsException 如果索引超出范围（<tt>index &lt; 0 || index &gt; size()</tt>）
 */
ListIterator<E> listIterator(int index);

// 视图

/**
 * 返回此列表在指定的fromIndex（包括）和toIndex（排除）之间的部分的视图。（如果fromIndex和toIndex相等，则返回的列表为空。）返回的列表由此列表支持，因此在返回列表中进行非结构性更改会反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可选列表操作。
 *
 * 这个方法消除了对显式范围操作（通常存在于数组中）的需求。任何期望列表的操作都可以通过传递子列表视图而不是整个列表来使用作为范围操作。例如，以下习语从列表中删除了一系列元素：
 * <pre>{@code
 *      list.subList(from, to).clear();
 * }</pre>
 * 类似的习语可以用于indexOf和lastIndexOf，Collections类中的所有算法都可以应用于子列表。
 *
 * 如果通过返回的列表以外的方式结构性修改了支持列表（即此列表），则此方法返回的列表的语义变为未定义。（结构性修改是改变此列表的大小或以其他方式扰动它，以使正在进行的迭代可能会产生错误结果。）

 * @param fromIndex 子列表的低端点（包括）
 * @param toIndex 子列表的高端点（排除）
 * @return 此列表指定范围内的视图
 * @throws IndexOutOfBoundsException 对于非法的端点索引值（<tt>fromIndex &lt; 0 || toIndex &gt; size ||
 *         fromIndex &gt; toIndex</tt>）
 */
List<E> subList(int fromIndex, int toIndex);

/**
 * 在此列表上创建一个Spliterator。
 *
 * <p>Spliterator报告{@link Spliterator#SIZED}和{@link Spliterator#ORDERED}。实现应该记录其他特征值的报告。
 *
 * @implSpec
 * 默认实现从列表的Iterator创建一个late-binding spliterator。spliterator继承列表迭代器的fail-fast属性。
 *
 * @implNote
 * 创建的Spliterator还报告{@link Spliterator#SUBSIZED}。
 *
 * @return 这个列表中元素的Spliterator
 * @since 1.8
 */
@Override
default Spliterator<E> spliterator() {
    return Spliterators.spliterator(this, Spliterator.ORDERED);
}