模块 java.base
包 java.util.concurrent

类 ConcurrentLinkedDeque<E>

java.lang.Object
java.util.AbstractCollection <E>
java.util.concurrent.ConcurrentLinkedDeque<E>
类型参数：
E - 此双端队列中包含的元素类型
所有已实现的接口：
Serializable , Iterable<E> , Collection<E> , Deque<E> , Queue<E>
public class ConcurrentLinkedDeque<E> extends AbstractCollection <E> implements Deque <E>, Serializable
基于链接节点的无界并发双端队列。并发插入、删除和访问操作跨多个线程安全执行。当许多线程将共享对公共集合的访问时，ConcurrentLinkedDeque 是一个合适的选择。与大多数其他并发集合实现一样，此类不允许使用 null 元素。

迭代器和拆分器是 弱一致 。

请注意，与大多数集合不同，size 方法是 NOT 恒定时间操作。由于这些双端队列的异步特性，确定当前元素数量需要遍历元素，因此如果在遍历期间修改此集合，则可能会报告不准确的结果。

添加、删除或检查多个元素的批量操作，例如 addAll(java.util.Collection<? extends E>) 、removeIf(java.util.function.Predicate<? super E>) 或 forEach(java.util.function.Consumer<? super E>) ，not 保证以原子方式执行。例如，与 addAll 操作并发的 forEach 遍历可能只会观察到一些添加的元素。

此类及其迭代器实现了 Deque 和 Iterator 接口的所有 optional 方法。

内存一致性影响：与其他并发集合一样，在将对象放入 ConcurrentLinkedDeque 发生在之前 之前线程中的操作是在另一个线程中从 ConcurrentLinkedDeque 访问或删除该元素之后的操作。

此类是 Java 集合框架 的成员。

自从：
1.7
参见：

  • 构造方法总结

    构造方法
    构造方法
    描述
    ConcurrentLinkedDeque()
    构造一个空的双端队列。
    ConcurrentLinkedDeque(Collection<? extends E> c)
    构造一个最初包含给定集合元素的双端队列，按集合迭代器的遍历顺序添加。

  • 方法总结

    修饰符和类型
    方法
    描述
    boolean
    add(E e)
    在此双端队列的尾部插入指定的元素。
    boolean
    addAll(Collection<? extends E> c)
    将指定集合中的所有元素附加到此双端队列的末尾，按照它们由指定集合的迭代器返回的顺序。
    void
    addFirst(E e)
    在此双端队列的前面插入指定的元素。
    void
    addLast(E e)
    在此双端队列的末尾插入指定的元素。
    void
    clear()
    从此双端队列中删除所有元素。
    boolean
    contains(Object o)
    如果此双端队列包含指定元素，则返回 true。
    Iterator<E>
    descendingIterator()
    以相反的顺序返回此双端队列中元素的迭代器。
    E
    element()
    检索但不删除由此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素）。
    void
    forEach(Consumer<? super E> action)
    对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或操作引发异常。
    E
    getFirst()
    检索但不删除此双端队列的第一个元素。
    E
    getLast()
    检索但不删除此双端队列的最后一个元素。
    boolean
    isEmpty()
    如果此集合不包含任何元素，则返回 true。
    Iterator<E>
    iterator()
    以正确的顺序返回此双端队列中元素的迭代器。
    boolean
    offer(E e)
    在此双端队列的尾部插入指定的元素。
    boolean
    offerFirst(E e)
    在此双端队列的前面插入指定的元素。
    boolean
    offerLast(E e)
    在此双端队列的末尾插入指定的元素。
    E
    peek()
    检索但不删除由此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），或者如果此双端队列为空则返回 null。
    E
    peekFirst()
    检索但不删除此双端队列的第一个元素，如果此双端队列为空，则返回 null。
    E
    peekLast()
    检索但不删除此双端队列的最后一个元素，如果此双端队列为空，则返回 null。
    E
    poll()
    检索并删除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素），或者如果此双端队列为空，则返回 null。
    E
    pollFirst()
    检索并删除此双端队列的第一个元素，如果此双端队列为空，则返回 null。
    E
    pollLast()
    检索并删除此双端队列的最后一个元素，如果此双端队列为空，则返回 null。
    E
    pop()
    从此双端队列表示的堆栈中弹出一个元素。
    void
    push(E e)
    如果可以在不违反容量限制的情况下立即将元素推入此双端队列表示的堆栈（换句话说，在此双端队列的头部），如果当前没有可用空间，则抛出 IllegalStateException。
    E
    remove()
    检索并删除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
    boolean
    remove(Object o)
    从此双端队列中移除第一次出现的指定元素。
    boolean
    removeAll(Collection<?> c)
    删除此集合的所有也包含在指定集合中的元素（可选操作）。
    E
    removeFirst()
    检索并删除此双端队列的第一个元素。
    boolean
    removeFirstOccurrence(Object o)
    从此双端队列中移除第一次出现的指定元素。
    boolean
    removeIf(Predicate<? super E> filter)
    移除此集合中满足给定谓词的所有元素。
    E
    removeLast()
    检索并删除此双端队列的最后一个元素。
    boolean
    removeLastOccurrence(Object o)
    从此双端队列中移除指定元素的最后一次出现。
    boolean
    retainAll(Collection<?> c)
    仅保留此集合中包含在指定集合中的元素（可选操作）。
    int
    size()
    返回此双端队列中的元素数。
    Spliterator<E>
    spliterator()
    返回此双端队列中元素的 Spliterator 。
    Object[]
    toArray()
    返回一个包含此双端队列中所有元素的数组，顺序正确（从第一个元素到最后一个元素）。
    <T> T[]
    toArray(T[] a)
    以正确的顺序（从第一个元素到最后一个元素）返回一个包含此双端队列中所有元素的数组；返回数组的运行时类型是指定数组的类型。

    在类 java.util.AbstractCollection 中声明的方法

    containsAll, toString

    在类 java.lang.Object 中声明的方法

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

    在接口 java.util.Collection 中声明的方法

    containsAll, equals, hashCode, parallelStream, stream, toArray

  • 构造方法详细信息

    • ConcurrentLinkedDeque

      public ConcurrentLinkedDeque()
      构造一个空的双端队列。

    • ConcurrentLinkedDeque

      public ConcurrentLinkedDeque(Collection <? extends E > c)
      构造一个最初包含给定集合元素的双端队列，按集合迭代器的遍历顺序添加。
      参数：
      c - 最初包含的元素集合
      抛出：
      NullPointerException - 如果指定的集合或其任何元素为空

  • 方法详情

    • addFirst

      public void addFirst(E  e)
      在此双端队列的前面插入指定的元素。由于双端队列是无界的，此方法永远不会抛出 IllegalStateException 。
      指定者：
      addFirst 在接口 Deque<E> 中
      参数：
      e - 要添加的元素
      抛出：
      NullPointerException - 如果指定元素为空

    • addLast

      public void addLast(E  e)
      在此双端队列的末尾插入指定的元素。由于双端队列是无界的，此方法永远不会抛出 IllegalStateException 。

      此方法等效于 add(E) 。

      指定者：
      addLast 在接口 Deque<E> 中
      参数：
      e - 要添加的元素
      抛出：
      NullPointerException - 如果指定元素为空

    • offerFirst

      public boolean offerFirst(E  e)
      在此双端队列的前面插入指定的元素。由于双端队列是无界的，此方法永远不会返回 false 。
      指定者：
      offerFirst 在接口 Deque<E> 中
      参数：
      e - 要添加的元素
      返回：
      true（由 Deque.offerFirst(E) 指定）
      抛出：
      NullPointerException - 如果指定元素为空

    • offerLast

      public boolean offerLast(E  e)
      在此双端队列的末尾插入指定的元素。由于双端队列是无界的，此方法永远不会返回 false 。

      此方法等效于 add(E) 。

      指定者：
      offerLast 在接口 Deque<E> 中
      参数：
      e - 要添加的元素
      返回：
      true（由 Deque.offerLast(E) 指定）
      抛出：
      NullPointerException - 如果指定元素为空

    • peekFirst

      public E  peekFirst()
      从接口 Deque 复制的描述
      检索但不删除此双端队列的第一个元素，如果此双端队列为空，则返回 null。
      指定者：
      peekFirst 在接口 Deque<E> 中
      返回：
      这个双端队列的头部，或者 null 如果这个双端队列是空的

    • peekLast

      public E  peekLast()
      从接口 Deque 复制的描述
      检索但不删除此双端队列的最后一个元素，如果此双端队列为空，则返回 null。
      指定者：
      peekLast 在接口 Deque<E> 中
      返回：
      这个双端队列的尾部，或者 null 如果这个双端队列是空的

    • getFirst

      public E  getFirst()
      从接口 Deque 复制的描述
      检索但不删除此双端队列的第一个元素。此方法与 peekFirst 的不同之处仅在于，如果此双端队列为空，它会抛出异常。
      指定者：
      getFirst 在接口 Deque<E> 中
      返回：
      这个双端队列的头
      抛出：
      NoSuchElementException - 如果这个双端队列是空的

    • getLast

      public E  getLast()
      从接口 Deque 复制的描述
      检索但不删除此双端队列的最后一个元素。此方法与 peekLast 的不同之处仅在于，如果此双端队列为空，它会抛出异常。
      指定者：
      getLast 在接口 Deque<E> 中
      返回：
      这个双端队列的尾巴
      抛出：
      NoSuchElementException - 如果这个双端队列是空的

    • pollFirst

      public E  pollFirst()
      从接口 Deque 复制的描述
      检索并删除此双端队列的第一个元素，如果此双端队列为空，则返回 null。
      指定者：
      pollFirst 在接口 Deque<E> 中
      返回：
      这个双端队列的头部，或者 null 如果这个双端队列是空的

    • pollLast

      public E  pollLast()
      从接口 Deque 复制的描述
      检索并删除此双端队列的最后一个元素，如果此双端队列为空，则返回 null。
      指定者：
      pollLast 在接口 Deque<E> 中
      返回：
      这个双端队列的尾部，或者 null 如果这个双端队列是空的

    • removeFirst

      public E  removeFirst()
      从接口 Deque 复制的描述
      检索并删除此双端队列的第一个元素。此方法与 pollFirst 的不同之处仅在于，如果此双端队列为空，它会抛出异常。
      指定者：
      removeFirst 在接口 Deque<E> 中
      返回：
      这个双端队列的头
      抛出：
      NoSuchElementException - 如果这个双端队列是空的

    • removeLast

      public E  removeLast()
      从接口 Deque 复制的描述
      检索并删除此双端队列的最后一个元素。此方法与 pollLast 的不同之处仅在于，如果此双端队列为空，它会抛出异常。
      指定者：
      removeLast 在接口 Deque<E> 中
      返回：
      这个双端队列的尾巴
      抛出：
      NoSuchElementException - 如果这个双端队列是空的

    • offer

      public boolean offer(E  e)
      在此双端队列的尾部插入指定的元素。由于双端队列是无界的，此方法永远不会返回 false 。
      指定者：
      offer 在接口 Deque<E> 中
      指定者：
      offer 在接口 Queue<E> 中
      参数：
      e - 要添加的元素
      返回：
      true（由 Queue.offer(E) 指定）
      抛出：
      NullPointerException - 如果指定元素为空

    • add

      public boolean add(E  e)
      在此双端队列的尾部插入指定的元素。由于双端队列是无界的，此方法永远不会抛出 IllegalStateException 或返回 false 。
      指定者：
      add 在接口 Collection<E> 中
      指定者：
      add 在接口 Deque<E> 中
      指定者：
      add 在接口 Queue<E> 中
      重写：
      add 在类 AbstractCollection<E> 中
      参数：
      e - 要确保其存在于此集合中的元素
      返回：
      true（由 Collection.add(E) 指定）
      抛出：
      NullPointerException - 如果指定元素为空

    • poll

      public E  poll()
      从接口 Deque 复制的描述
      检索并删除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素），或者如果此双端队列为空，则返回 null。

      此方法等效于 Deque.pollFirst() 。

      指定者：
      poll 在接口 Deque<E> 中
      指定者：
      poll 在接口 Queue<E> 中
      返回：
      此双端队列的第一个元素，如果此双端队列为空，则为 null

    • peek

      public E  peek()
      从接口 Deque 复制的描述
      检索但不删除由此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），或者如果此双端队列为空则返回 null。

      此方法等效于 Deque.peekFirst() 。

      指定者：
      peek 在接口 Deque<E> 中
      指定者：
      peek 在接口 Queue<E> 中
      返回：
      此双端队列表示的队列的头部，如果此双端队列为空，则为 null

    • remove

      public E  remove()
      从接口 Deque 复制的描述
      检索并删除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。此方法与 poll() 的不同之处仅在于，如果此双端队列为空，它会抛出异常。

      此方法等效于 Deque.removeFirst() 。

      指定者：
      remove 在接口 Deque<E> 中
      指定者：
      remove 在接口 Queue<E> 中
      返回：
      此双端队列所代表的队列的头部
      抛出：
      NoSuchElementException - 如果这个双端队列是空的

    • pop

      public E  pop()
      从接口 Deque 复制的描述
      从此双端队列表示的堆栈中弹出一个元素。换句话说，删除并返回此双端队列的第一个元素。

      此方法等效于 Deque.removeFirst() 。

      指定者：
      pop 在接口 Deque<E> 中
      返回：
      此双端队列前面的元素（这是此双端队列表示的堆栈的顶部）
      抛出：
      NoSuchElementException - 如果这个双端队列是空的

    • element

      public E  element()
      从接口 Deque 复制的描述
      检索但不删除由此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素）。此方法与 peek 的不同之处仅在于，如果此双端队列为空，它会抛出异常。

      此方法等效于 Deque.getFirst() 。

      指定者：
      element 在接口 Deque<E> 中
      指定者：
      element 在接口 Queue<E> 中
      返回：
      此双端队列所代表的队列的头部
      抛出：
      NoSuchElementException - 如果这个双端队列是空的

    • push

      public void push(E  e)
      从接口 Deque 复制的描述
      如果可以在不违反容量限制的情况下立即将元素推入此双端队列表示的堆栈（换句话说，在此双端队列的头部），如果当前没有可用空间，则抛出 IllegalStateException。

      此方法等效于 Deque.addFirst(E) 。

      指定者：
      push 在接口 Deque<E> 中
      参数：
      e - 要推送的元素
      抛出：
      NullPointerException - 如果指定元素为空且此双端队列不允许空元素

    • removeFirstOccurrence

      public boolean removeFirstOccurrence(Object  o)
      从此双端队列中移除第一次出现的指定元素。如果双端队列不包含该元素，则它不变。更正式地说，删除第一个元素 e 这样 o.equals(e) （如果存在这样的元素）。如果此双端队列包含指定元素，则返回 true（或者等效地，如果此双端队列因调用而更改）。
      指定者：
      removeFirstOccurrence 在接口 Deque<E> 中
      参数：
      o - 要从此双端队列中删除的元素（如果存在）
      返回：
      true 如果双端队列包含指定的元素
      抛出：
      NullPointerException - 如果指定元素为空

    • removeLastOccurrence

      public boolean removeLastOccurrence(Object  o)
      从此双端队列中移除指定元素的最后一次出现。如果双端队列不包含该元素，则它不变。更正式地说，删除最后一个元素 e 这样 o.equals(e) （如果存在这样的元素）。如果此双端队列包含指定元素，则返回 true（或者等效地，如果此双端队列因调用而更改）。
      指定者：
      removeLastOccurrence 在接口 Deque<E> 中
      参数：
      o - 要从此双端队列中删除的元素（如果存在）
      返回：
      true 如果双端队列包含指定的元素
      抛出：
      NullPointerException - 如果指定元素为空

    • contains

      public boolean contains(Object  o)
      如果此双端队列包含指定元素，则返回 true。更正式地说，返回 true 当且仅当此双端队列包含至少一个元素 e 使得 o.equals(e) 。
      指定者：
      contains 在接口 Collection<E> 中
      指定者：
      contains 在接口 Deque<E> 中
      重写：
      contains 在类 AbstractCollection<E> 中
      参数：
      o - 要测试其在此双端队列中是否存在的元素
      返回：
      true 如果这个双端队列包含指定的元素

    • isEmpty

      public boolean isEmpty()
      如果此集合不包含任何元素，则返回 true。
      指定者：
      isEmpty 在接口 Collection<E> 中
      重写：
      isEmpty 在类 AbstractCollection<E> 中
      返回：
      true 如果此集合不包含任何元素

    • size

      public int size()
      返回此双端队列中的元素数。如果此双端队列包含超过 Integer.MAX_VALUE 个元素，则返回 Integer.MAX_VALUE 。

      请注意，与大多数集合不同，此方法是 NOT 恒定时间操作。由于这些双端队列的异步性质，确定当前元素的数量需要遍历它们来计算它们。另外，在该方法执行过程中，size可能会发生变化，返回的结果会不准确。因此，这种方法在并发应用程序中通常不是很有用。

      指定者：
      size 在接口 Collection<E> 中
      指定者：
      size 在接口 Deque<E> 中
      返回：
      此双端队列中的元素数

    • remove

      public boolean remove(Object  o)
      从此双端队列中移除第一次出现的指定元素。如果双端队列不包含该元素，则它不变。更正式地说，删除第一个元素 e 这样 o.equals(e) （如果存在这样的元素）。如果此双端队列包含指定元素，则返回 true（或者等效地，如果此双端队列因调用而更改）。

      此方法等效于 removeFirstOccurrence(Object) 。

      指定者：
      remove 在接口 Collection<E> 中
      指定者：
      remove 在接口 Deque<E> 中
      重写：
      remove 在类 AbstractCollection<E> 中
      参数：
      o - 要从此双端队列中删除的元素（如果存在）
      返回：
      true 如果双端队列包含指定的元素
      抛出：
      NullPointerException - 如果指定元素为空

    • addAll

      public boolean addAll(Collection <? extends E > c)
      将指定集合中的所有元素附加到此双端队列的末尾，按照它们由指定集合的迭代器返回的顺序。尝试 addAll 对自身的双端队列导致 IllegalArgumentException 。
      指定者：
      addAll 在接口 Collection<E> 中
      指定者：
      addAll 在接口 Deque<E> 中
      重写：
      addAll 在类 AbstractCollection<E> 中
      参数：
      c - 要插入到此双端队列中的元素
      返回：
      true 如果此双端队列因调用而改变
      抛出：
      NullPointerException - 如果指定的集合或其任何元素为空
      IllegalArgumentException - 如果集合是这个双端队列
      参见：

    • clear

      public void clear()
      从此双端队列中删除所有元素。
      指定者：
      clear 在接口 Collection<E> 中
      重写：
      clear 在类 AbstractCollection<E> 中

    • toArray

      public Object [] toArray()
      返回一个包含此双端队列中所有元素的数组，顺序正确（从第一个元素到最后一个元素）。

      返回的数组将是“安全的”，因为此双端队列没有维护对它的引用。 （换句话说，这个方法必须分配一个新数组）。调用者因此可以自由修改返回的数组。

      此方法充当基于数组和基于集合的 API 之间的桥梁。

      指定者：
      toArray 在接口 Collection<E> 中
      重写：
      toArray 在类 AbstractCollection<E> 中
      返回：
      包含此双端队列中所有元素的数组

    • toArray

      public <T> T[] toArray(T[] a)
      以正确的顺序（从第一个元素到最后一个元素）返回一个包含此双端队列中所有元素的数组；返回数组的运行时类型是指定数组的类型。如果双端队列适合指定的数组，则在其中返回。否则，将使用指定数组的运行时类型和此双端队列的大小分配一个新数组。

      如果此双端队列适合指定的数组并有剩余空间（即，该数组的元素多于此双端队列），则将数组中紧随双端队列末尾的元素设置为 null 。

      与 toArray() 方法一样，此方法充当基于数组和基于集合的 API 之间的桥梁。此外，此方法允许精确控制输出数组的运行时类型，并且在某些情况下可用于节省分配成本。

      假设 x 是已知仅包含字符串的双端队列。以下代码可用于将双端队列转储到新分配的 String 数组中：

       String[] y = x.toArray(new String[0]);
      请注意，toArray(new Object[0]) 在功能上与 toArray() 相同。
      指定者：
      toArray 在接口 Collection<E> 中
      重写：
      toArray 在类 AbstractCollection<E> 中
      类型参数：
      T - 包含集合的数组的组件类型
      参数：
      a - 存储双端队列元素的数组，如果它足够大的话；否则，为此分配一个相同运行时类型的新数组
      返回：
      包含此双端队列中所有元素的数组
      抛出：
      ArrayStoreException - 如果指定数组的运行时类型不是此双端队列中每个元素的运行时类型的超类型
      NullPointerException - 如果指定数组为空

    • iterator

      public Iterator <E > iterator()
      以正确的顺序返回此双端队列中元素的迭代器。元素将按从第一个（头）到最后一个（尾）的顺序返回。

      返回的迭代器是 弱一致 。

      指定者：
      iterator 在接口 Collection<E> 中
      指定者：
      iterator 在接口 Deque<E> 中
      指定者：
      iterator 在接口 Iterable<E> 中
      指定者：
      iterator 在类 AbstractCollection<E> 中
      返回：
      以适当顺序在此双端队列中的元素上的迭代器

    • descendingIterator

      public Iterator <E > descendingIterator()
      以相反的顺序返回此双端队列中元素的迭代器。元素将按从最后（尾）到第一个（头）的顺序返回。

      返回的迭代器是 弱一致 。

      指定者：
      descendingIterator 在接口 Deque<E> 中
      返回：
      以相反顺序遍历此双端队列中元素的迭代器

    • spliterator

      public Spliterator <E > spliterator()
      返回此双端队列中元素的 Spliterator 。

      返回的拆分器是 弱一致 。

      Spliterator 报告 Spliterator.CONCURRENT 、Spliterator.ORDERED 和 Spliterator.NONNULL 。

      指定者：
      spliterator 在接口 Collection<E> 中
      指定者：
      spliterator 在接口 Iterable<E> 中
      实现注意事项：
      Spliterator 实现 trySplit 以允许有限的并行性。
      返回：
      a Spliterator 在此双端队列中的元素上
      自从：
      1.8

    • removeIf

      public boolean removeIf(Predicate <? super E > filter)
      从接口 Collection 复制的描述
      移除此集合中满足给定谓词的所有元素。迭代期间或由谓词抛出的错误或运行时异常将传递给调用者。
      指定者：
      removeIf 在接口 Collection<E> 中
      参数：
      filter - 为要删除的元素返回 true 的谓词
      返回：
      true 如果删除了任何元素
      抛出：
      NullPointerException - 如果指定的过滤器为空

    • removeAll

      public boolean removeAll(Collection <?> c)
      从类复制的描述：AbstractCollection
      删除此集合的所有也包含在指定集合中的元素（可选操作）。此调用返回后，此集合将不包含与指定集合共有的元素。
      指定者：
      removeAll 在接口 Collection<E> 中
      重写：
      removeAll 在类 AbstractCollection<E> 中
      参数：
      c - 包含要从此集合中删除的元素的集合
      返回：
      true 如果此集合因调用而更改
      抛出：
      NullPointerException - 如果此集合包含一个或多个空元素并且指定的集合不支持空元素 (optional)，或者如果指定的集合为空
      参见：

    • retainAll

      public boolean retainAll(Collection <?> c)
      从类复制的描述：AbstractCollection
      仅保留此集合中包含在指定集合中的元素（可选操作）。换句话说，从该集合中移除所有未包含在指定集合中的元素。
      指定者：
      retainAll 在接口 Collection<E> 中
      重写：
      retainAll 在类 AbstractCollection<E> 中
      参数：
      c - 包含要保留在此集合中的元素的集合
      返回：
      true 如果此集合因调用而更改
      抛出：
      NullPointerException - 如果此集合包含一个或多个空元素并且指定的集合不允许空元素 (optional)，或者如果指定的集合为空
      参见：

    • forEach

      public void forEach(Consumer <? super E > action)
      从接口 Iterable 复制的描述
      对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或操作引发异常。如果指定了迭代顺序，则将按迭代顺序执行操作。操作抛出的异常被转发给调用者。

      如果操作执行修改元素的底层源的副作用，则此方法的行为是未指定的，除非重写类已指定并发修改策略。

      指定者：
      forEach 在接口 Iterable<E> 中
      参数：
      action - 对每个元素执行的操作
      抛出：
      NullPointerException - 如果指定的操作为空