Module java.base
Package java.util.concurrent

Class ConcurrentLinkedDeque<E>

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

迭代器和分割器是弱一致性的。

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

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

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

内存一致性效果: 与其他并发集合一样，在将对象放入ConcurrentLinkedDeque之前的线程中的操作先行发生于在另一个线程中访问或从ConcurrentLinkedDeque中删除该元素的操作。

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

自版本:
1.7
参见:

  • Constructor Summary

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

  • Method Summary

    Modifier and Type
    Method
    Description
    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)
    返回包含此双端队列中所有元素的数组，按正确顺序（从第一个到最后一个元素）；返回数组的运行时类型是指定数组的类型。

    Methods declared in class java.util.AbstractCollection

    containsAll, toString

    Methods declared in class java.lang.Object

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

    Methods declared in interface java.util.Collection

    containsAll, equals, hashCode, parallelStream, stream, toArray

    Methods declared in interface java.util.Deque

    reversed

  • Constructor Details

    • ConcurrentLinkedDeque

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

    • ConcurrentLinkedDeque

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

  • Method Details

    • addFirst

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

    • addLast

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

      此方法等效于add(E)。

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

    • offerFirst

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

    • offerLast

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

      此方法等效于add(E)。

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

    • 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>中
      指定者:
      getFirst 在接口 SequencedCollection<E>中
      返回值:
      此双端队列的头部
      抛出:
      NoSuchElementException - 如果此双端队列为空

    • getLast

      public E getLast()
      从接口复制的描述: Deque
      检索但不移除此双端队列的最后一个元素。此方法与peekLast的区别仅在于，如果此双端队列为空，则会抛出异常。
      指定者:
      getLast 在接口 Deque<E>中
      指定者:
      getLast 在接口 SequencedCollection<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>中
      指定者:
      removeFirst 在接口 SequencedCollection<E>中
      返回值:
      此双端队列的头部
      抛出:
      NoSuchElementException - 如果此双端队列为空

    • removeLast

      public E removeLast()
      从接口复制的描述: Deque
      检索并移除此双端队列的最后一个元素。此方法与pollLast的区别仅在于，如果此双端队列为空，则会抛出异常。
      指定者:
      removeLast 在接口 Deque<E>中
      指定者:
      removeLast 在接口 SequencedCollection<E>中
      返回值:
      此双端队列的尾部
      抛出:
      NoSuchElementException - 如果此双端队列为空

    • offer

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

    • 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 - 如果指定的元素为null

    • 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 - 如果指定的元素为null且此双端队列不允许空元素

    • removeFirstOccurrence

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

    • removeLastOccurrence

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

    • contains

      public boolean contains(Object o)
      返回true如果此双端队列包含指定的元素。更正式地说，当且仅当此双端队列包含至少一个元素e使得o.equals(e)返回true。
      指定者：
      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。

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

      指定者：
      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 - 如果指定的元素为null

    • addAll

      public boolean addAll(Collection<? extends E> c)
      将指定集合中的所有元素追加到此双端队列的末尾，按照指定集合的迭代器返回它们的顺序。尝试将双端队列的所有元素添加到自身会导致IllegalArgumentException。
      指定者：
      addAll 在接口 Collection<E>
      指定者：
      addAll 在接口 Deque<E>
      覆盖：
      addAll 在类 AbstractCollection<E>
      参数：
      c - 要插入到此双端队列中的元素
      返回：
      如果此双端队列由于调用而更改，则返回true
      抛出：
      NullPointerException - 如果指定的集合或其任何元素为null
      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 - 如果指定数组为null

    • 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以允许有限的并行性。
      返回：
      一个在此双端队列中元素上执行的Spliterator
      自：
      1.8

    • removeIf

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

    • removeAll

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

    • retainAll

      public boolean retainAll(Collection<?> c)
      从类复制的描述： AbstractCollection
      仅保留此集合中包含在指定集合中的元素（可选操作）。换句话说，从此集合中删除不包含在指定集合中的所有元素。
      指定由：
      retainAll 在接口 Collection<E>中
      覆盖：
      retainAll 在类 AbstractCollection<E>中
      参数：
      c - 包含要在此集合中保留的元素的集合
      返回：
      true如果此集合由于调用而更改
      抛出：
      NullPointerException - 如果此集合包含一个或多个null元素且指定的集合不支持null元素（可选）或指定的集合为null
      参见：

    • forEach

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

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

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