JCF相关基础类接口/抽象类源码阅读

本人的源码阅读主要聚焦于类的使用场景，一般只在java层面进行分析，没有深入到一些native方法的实现。并且由于知识储备不完整，很可能出现疏漏甚至是谬误，欢迎指出共同学习

本文基于corretto-17.0.9源码，参考本文时请打开相应的源码对照，否则你会不知道我在说什么

简介

JCF（Java Collections Framework）为Java开发者提供了通用的容器，而每个可以直接拿来用的容器又实现了很多接口，并且有些接口方法还有default实现，为了更好地掌握JCF的整体结构，甚至以后需要到自己开发容器的时候，对应该实现哪些接口可以做到了然于胸。

对于接口我按照源码注释进行二次解释，而抽象类，会稍微深入到源码去理解里面方法的执行。

代码分析

Iterator接口

Iterator是一个集合上的迭代器，用来替代 Enumeration（旧API，可以忽略） 进行遍历、迭代。迭代不一定是顺序的，对于List来说可能是顺序的，但是对于Set来说就不一定了。

public interface Iterator<E> {
  // 查询是否有下一个元素
  boolean hasNext();
  // 获取当前，并将指针指向下一个元素
  E next();
	// 移除上一次调用next得到的元素
  default void remove() {
    throw new UnsupportedOperationException("remove");
  }
	// 遍历从当前指针开始的剩余元素
  default void forEachRemaining(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    while (hasNext())
      action.accept(next());
  }
}

注释里说的“指针”其实是假想出来的。举个例子，比如ArrayList，其新生成的迭代器相当于一个指针，初始指向下标为0的位置，此时hasNext询问“指针”指向的位置有没有元素，next的行为则是返回当前指针指向的元素，然后把“指针”指向下一个元素的位置。

因此使用迭代器遍历是这样的：

ArrayList<String> arr = new ArrayList<>();
Iterator<String> c = arr.iterator();
while (c.hashNext()) {
  String s = c.next();
  // ...
}

另外，迭代器还支持在遍历的过程中删除当前指针指向的元素，比如你像下面这么干，就会删除ArrayList的第一个元素：

ArrayList<String> arr = new ArrayList<>();
Iterator<String> c = arr.iterator();
arr.next();
arr.remove();

当然，remove得子类去根据集合是否支持，不支持的话直接抛异常。

Iterable接口

public interface Iterable<T> {
  // 返回集合的迭代器
  Iterator<T> iterator();
	// 提供函数调用式的遍历方式
  default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
      action.accept(t);
    }
  }
	// 返回集合的spliterator
  default Spliterator<T> spliterator() {
    return Spliterators.spliteratorUnknownSize(iterator(), 0);
  }
}

实现这个接口主要是可以让对象支持for-each语法，比如ArrayList就实现了这个接口，因此相比使用迭代器，你可以写出更简洁的遍历方式：

ArrayList<String> arr = new ArrayList<>();
for (String s : arr) {
  // ...
}

这种简洁的遍历方式是java的语法糖，实际上它还是依靠iterator来实现的，也就是会被编译成之前使用迭代器的那个样子（可能会与实际的编译情况有差别，不细究）：

ArrayList<String> arr = new ArrayList<>();
Iterator<String> c = arr.iterator();
while (c.hashNext()) {
  String s = c.next();
  // ...
}

最后的spliterator函数，返回一个Spliterator对象，这个是在java8引入的，与stream、并行计算有关，暂时不讲，以后会单独介绍。

Collection接口

Collection接口实现了Iterable接口，通过注释的方式来说明每个方法的作用。流相关函数忽略。

public interface Collection<E> extends Iterable<E> {
  // 集合元素个数，如果元素个数超过Integer.MAX_VALUE，则返回Integer.MAX_VALUE
  int size();
  // 集合是否为空
  boolean isEmpty();
  // 是否包含o，具体是通过equals方法来对比
  boolean contains(Object o);
  Iterator<E> iterator();
  // 返回一个包含所有元素的新数组，也就是说数组是new出来的（元素不是new出来的），不是集合的底层数组
  Object[] toArray();
  // 返回一个包含所有元素的新数组，类型为T。如果数组长度小于集合大小那么会new一个数组，否则返回a
  <T> T[] toArray(T[] a);
  // 新增一个元素
  boolean add(E e);
  // 移除一个元素
  boolean remove(Object o);
  // 是否包含c中的所有元素
  boolean containsAll(Collection<?> c);
  // 添加c中的所有元素
  boolean addAll(Collection<? extends E> c);
  // 移除c中的所有元素（如果元素不在集合中的话不产生影响）
  boolean removeAll(Collection<?> c);
  // 移除所有满足filter的元素，返回是否有元素被移除
  default boolean removeIf(Predicate<? super E> filter);
  // 移除所有不在c中的元素，与removeAll的功能恰好相反
  boolean retainAll(Collection<?> c);
  // 移除集合中所有元素
  void clear();
  
  // 流相关
  default Spliterator<E> spliterator();
  default Stream<E> stream();
  default Stream<E> parallelStream();
}

AbstractCollection抽象类

AbstractCollection实现了Collection接口，目的是实现一些通用的方法，这样一来想要实现Collection的类可以考虑继承AbstractCollection，省去功夫重新实现其中的一些方法，比如isEmpty显而易见可以实现成size()==0，如果子类有更加高效的实现再考虑重写AbstractCollection提供的默认实现。

下面来看一下AbstractCollection实现了的方法：

• isEmptry

  public boolean isEmpty() {
  	return size() == 0;
  }
  

• contains

  // 循环遍历比较o和集合中的元素，如果equals则返回true
  public boolean contains(Object o) {
    Iterator<E> it = iterator();
    if (o==null) {
      while (it.hasNext())
        if (it.next()==null)
          return true;
    } else {
      while (it.hasNext())
        if (o.equals(it.next()))
          return true;
    }
    return false;
  }
  

• toArray

  // 循环遍历集合，将元素放到数组r。集合大小可能会在遍历时由于并发增删发生变化，从而影响最终数组的大小
  public Object[] toArray() {
    Object[] r = new Object[size()];
    Iterator<E> it = iterator();
    for (int i = 0; i < r.length; i++) {
      // 如果没有下一个元素了，那么直接truncate
      if (!it.hasNext())
        return Arrays.copyOf(r, i);
      r[i] = it.next();
    }
    // 如果集合大小大于原来的大小，那么调用finishToArray继续加入元素到数组中
    return it.hasNext() ? finishToArray(r, it) : r;
  }
  
  // 使用iterator将剩下的元素加入数组中
  private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
    int len = r.length;
    int i = len;
    while (it.hasNext()) {
      // 数组需要扩容
      if (i == len) {
        // 一般情况下扩展数组大小为原先大小的两倍+1（具体查看ArraysSupport.newLength）
        len = ArraysSupport.newLength(len,
          1,             /* minimum growth */
          (len >> 1) + 1 /* preferred growth */);
        r = Arrays.copyOf(r, len);
      }
      r[i++] = (T)it.next();
    }
  	// 返回数组并且删除扩容后多余的长度
    return (i == len) ? r : Arrays.copyOf(r, i);
  }
  

• add

  public boolean add(E e) {
    // 实现为抛出异常的原因：
    // 1. 默认集合为immutable的，如果要支持add，重写这个方法即可
    // 2. AbstractCollection没有默认的存储元素的底层数据结构，而且迭代器不支持add操作，因此add方法留给子类实现
    throw new UnsupportedOperationException();
  }
  

• remove

  // 类似contains方法，只是多了一句it.remove
  public boolean remove(Object o) {
    Iterator<E> it = iterator();
    if (o==null) {
      while (it.hasNext()) {
        if (it.next()==null) {
          it.remove();
          return true;
        }
      }
    } else {
      while (it.hasNext()) {
        if (o.equals(it.next())) {
          it.remove();
          return true;
        }
      }
    }
    return false;
  }
  

还有几个xxxAll的批操作方法就不展示了，大同小异。

AbstratctCollection基于迭代器实现了一些常用的删除、包含等操作，总体来说比较简单。

List接口

List接口实现Collection接口，代表的是 有序的集合（sequence），每个元素都对应一个下标，允许存储重复的元素（这是官方推荐的做法），支持随机访问、插入、新增。在Collection的Iterator的基础上，List提供了列表迭代器ListIterator，除了Iterator接口提供的操作外，还允许基于位置的元素插入、替换以及双向遍历。

先看一下新增的迭代器ListIterator

public interface ListIterator<E> extends Iterator<E> {
	// 就是Iterator中的hashNext、next、remove
  boolean hasNext();
  E next();
  void remove();
  
  // 询问当前指针的上一个位置是否有元素
  boolean hasPrevious();
  // 将指针-1，并返回指针指向的位置
  E previous();
	// 当前指针的指向的下标
  int nextIndex();
  // 当前指针指向的下标-1
  int previousIndex();
  
  void set(E e);
  void add(E e);
}

下面是新增的方法，太简单的就不注释了，猜也能猜出来功能是什么。

// 通过迭代器的set方法，将每个位置上的元素替换为用户指定的元素
default void replaceAll(UnaryOperator<E> operator) {
  Objects.requireNonNull(operator);
  final ListIterator<E> li = this.listIterator();
  while (li.hasNext()) {
    li.set(operator.apply(li.next()));
  }
}
// 通过toArray转换成数组并用工具类Arrays.sort排序，然后再把排序后的数组重新设到集合上
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);
// 其实就是firstIndexOf
int indexOf(Object o);
int lastIndexOf(Object o);
ListIterator<E> listIterator();
// 从index开始的列表迭代器，即“指针”初始位置为index而不是-1
ListIterator<E> listIterator(int index);
// 返回列表的一个“view”。对view做结构化的修改以及非结构的修改都会影响原始的列表
// 如果在生成了view之后对原列表做结构化的修改，并且不是通过view作的这个修改，那么这个行为是未定义的（由子类定义），比如在ArrayList会抛ConcurrentModificationException
// 结构化修改：比如subList(0, 10).clear()会使得原始列表的前10个元素被删除
// 非结构化修改：比如subList(3, 5).set(0, obj)会使得原列表下标为3的元素被设置为obj
List<E> subList(int fromIndex, int toIndex);

List还添加了一堆静态方法of的重载，来方便地生成immutable List，比如

static <E> List<E> of(E... elements);

AbstractList抽象类

AbstractList继承于AbstractColletion。类似AbstractColletion，AbstractList实现了List的一些方法。AbstractList还提供了默认的Iterator、ListIterator实现。

Itr（Iterator的实现）

只需要牢记，Iterator用于向后（单向）遍历，指针指向下一个获取的元素，因此是先获取指针指向的元素，然后指针+1。

private class Itr implements Iterator<E> {
  // iterator的“指针”，实际上是当前遍历到的下标
  int cursor = 0;
  // 上次指针修改前的值
  int lastRet = -1;
  // 记录创建iterator时列表的结构化修改次数
  int expectedModCount = modCount;

  public boolean hasNext() {
    return cursor != size();
  }

  public E next() {
    checkForComodification();
    try {
      // 获取当前指针指向的元素
      int i = cursor;
      E next = get(i);
      lastRet = i;
      // 指针+1
      cursor = i + 1;
      return next;
    } catch (IndexOutOfBoundsException e) {
      checkForComodification();
      throw new NoSuchElementException(e);
    }
  }
	// 删除上次next对应的元素
  public void remove() {
    if (lastRet < 0)
      throw new IllegalStateException();
    checkForComodification();

    try {
      // 移除指针修改前指向的元素
      AbstractList.this.remove(lastRet);
      // 指针-1
      if (lastRet < cursor)
        cursor--;
      // 重设lastRet，指示该位置的元素已经被移除，不能二次移除
      lastRet = -1;
      expectedModCount = modCount;
    } catch (IndexOutOfBoundsException e) {
      throw new ConcurrentModificationException();
    }
  }

  // 检查列表是否被结构化修改了，而且不是被this iterator修改的，那么抛出异常避免进一步出错
  final void checkForComodification() {
    if (modCount != expectedModCount)
      throw new ConcurrentModificationException();
  }
}

比较简单，基本上是把Iterator接口定义好的功能用代码翻译一下而已，看注释就行。

需要注意的点：

• checkForComodification，虽然抛出的异常名是“并发修改异常”，看，但分析代码可以知道，在iterator被创建后，只能用这个iterator来修改集合的结构（比如remove），否则，无论是当前线程还是其他线程修改了集合的结构后，这个iterator不能再被使用，否则会抛异常。

• 不能连续remove元素，remove相当于在逻辑上留下了一个“空洞”（lastRet=-1），即非法元素，那肯定不能remove一个“空洞”。如果要实现从当前元素开始删除后面所有的元素可以写成：

  while (ite.hasNext()) {
    it.next();
    it.remove();
  }
  

ListItr（ListIterator的实现）

ListItr实现了ListIterator，继承于Itr。只需要牢记ListIterator用于双向遍历，向后遍历的行为与Iterator一样，向前遍历时，指针先-1，然后获取指针指向的元素。

private class ListItr extends Itr implements ListIterator<E> {
	// 指针从index开始
  ListItr(int index) {
    cursor = index;
  }
	// 如果指针=0，那么前一个元素就是-1，前面就没有元素了，返回false
  public boolean hasPrevious() {
    return cursor != 0;
  }
	// 获取上一个元素
  public E previous() {
    checkForComodification();
    try {
      // 指针-1
      int i = cursor - 1;
      // 获取上一个元素
      E previous = get(i);
      lastRet = cursor = i;
      return previous;
    } catch (IndexOutOfBoundsException e) {
      checkForComodification();
      throw new NoSuchElementException(e);
    }
  }
	// 获取下一个元素下标
  public int nextIndex() {
    return cursor;
  }
	// 获取上一个元素下标
  public int previousIndex() {
    return cursor-1;
  }
	// 设置当前指针指向的元素
  public void set(E e) {
    // 如果是非法位置，则抛异常
    if (lastRet < 0)
      throw new IllegalStateException();
    checkForComodification();

    try {
      AbstractList.this.set(lastRet, e);
      expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
      throw new ConcurrentModificationException();
    }
  }
	// 将元素插入当前指针指向的位置，当前指针指向的元素及其后面的元素全体“后移”
  public void add(E e) {
    checkForComodification();

    try {
      int i = cursor;
      AbstractList.this.add(i, e);
      // 注意这两行
      lastRet = -1;
      cursor = i + 1;
      expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
      throw new ConcurrentModificationException();
    }
  }
}

需要注意的点：

• 之前说过，使用remove删除完元素之后，当前指针可以视为指向“空洞”，不可以进行操作，包括set。因此lastRet=-1的时候进行set的话会抛异常
• add之后，指针还是指向原来的元素，因此cursor=i+1，并且lastRet=-1设置“空洞”，不能进行set和remove。

回归AbstractList，看一下它实现了List接口的方法：

// 在尾部添加一个元素
public boolean add(E e) {
  add(size(), e);
  return true;
}

// 往后找o第一次出现的下标
public int indexOf(Object o) {
  ListIterator<E> it = listIterator();
  if (o==null) {
    while (it.hasNext())
      if (it.next()==null)
        return it.previousIndex();
  } else {
    while (it.hasNext())
      if (o.equals(it.next()))
        return it.previousIndex();
  }
  return -1;
}

// 往前找o第一次出现的下标
public int lastIndexOf(Object o) {
  ListIterator<E> it = listIterator(size());
  if (o==null) {
    while (it.hasPrevious())
        if (it.previous()==null)
          return it.nextIndex();
  } else {
    while (it.hasPrevious())
      if (o.equals(it.previous()))
        return it.nextIndex();
  }
  return -1;
}

// 删除所有元素
public void clear() {
  removeRange(0, size());
}

// 移除[fromIndex, toIndex)内的元素
protected void removeRange(int fromIndex, int toIndex) {
  ListIterator<E> it = listIterator(fromIndex);
  for (int i=0, n=toIndex-fromIndex; i<n; i++) {
    it.next();
    it.remove();
  }
}

// 获取迭代器
public Iterator<E> iterator() {
  return new Itr();
}

// 获取列表迭代器
public ListIterator<E> listIterator() {
  return listIterator(0);
}

// 获取列表的子视图
public List<E> subList(int fromIndex, int toIndex) {
  subListRangeCheck(fromIndex, toIndex, size());
  return (this instanceof RandomAccess ?
      new RandomAccessSubList<>(this, fromIndex, toIndex) :
      new SubList<>(this, fromIndex, toIndex));
}

// 重写equals规则
public boolean equals(Object o) {
  if (o == this)
    return true;
  if (!(o instanceof List))
    return false;

  ListIterator<E> e1 = listIterator();
  ListIterator<?> e2 = ((List<?>) o).listIterator();
  while (e1.hasNext() && e2.hasNext()) {
    E o1 = e1.next();
    Object o2 = e2.next();
    if (!(o1==null ? o2==null : o1.equals(o2)))
      return false;
  }
  return !(e1.hasNext() || e2.hasNext());
}

值得分析的方法只有两个：subList和equals

• equals：对Object.equals的重载。当两个列表的每个元素都相等的时候，列表视为相等
• subList：这个方法根据列表是否支持随机访问，分别返回SubList或RandomAccessSubList。这两个类都继承自AbstractList，以 代理模式，代理this对象，封装了对列表某个范围的数据访问，官方文档称之为原列表的一个“视图”，对该视图的任何结构与非结构上的修改都相当于对原列表进行修改，目的是方便我们像使用普通List那样来操作列表的子列表。

SubList

SubList是AbstractList的静态内部类，继承于AbstractList。看一下成员变量：

private static class SubList<E> extends AbstractList<E> {
  // 被代理对象
  private final AbstractList<E> root;
  // 由于SubList也是一个List，因此subList可以链式调用，parent记录调用subList的SubList对象
  private final SubList<E> parent;
  // 记录该子列表在原列表的偏移量，比如list.subList(3, 5)，那么生成的SubList.offset=3
  private final int offset;
  // 子列表大小
  protected int size;
}

下面分析SubList的方法，由于SubList是代理类，因此SubList的方法肯定是借助被代理对象来实现的：

public R xyz(params) {
  // ...
  return root.xyz(params)
  // ...
}

几乎每个公有方法都调用了checkForComodification，之前稍微提到过，但都不够详细或者有所缺漏，在这儿结合SubList全面剖析一下它背后的理念。

checkForComodification检查列表是否被非子孙子列表做过结构性修改（即检查modCount与parent.modCount是否相等）如果被修改过的话，再去访问该子列表是不允许的。这里“子孙”一词借用了树的概念：原列表视为根节点，其subList为第二层节点，subList.subList为第三层节点…，当对某个节点做结构性修改，只会对祖先进行同步，此时访问本节点和祖先节点都是没问题的，但除了该节点的祖先外的其他节点与本节点此时是不一致的，访问它们就会抛异常。talk is cheap, show me the code：

List<String> list = ...;
List<String> sub1 = list.subList(3, 5);
List<String> sub1_1 = sub2.subList(0, 3);
List<String> sub2 = list.subList(6, 10);

/*
此时的树：
list(root)
├── sub1
│   └── sub1_1
└── sub2
*/

list.remove(0); // 最后一行报错
sub2.remove(0); // 最后一行报错
sub1_1.remove(0); // ok的
sub1.remove(0); // ok的

// 访问sub1节点
sub1.size();

由此，我们进一步思考为什么要这样设计：回到“视图”这个概念，子节点是对父节点的视图，使用视图的初衷就是为了方便操作原列表的某个范围，因此：

• 子节点发生结构性修改后，肯定能继续访问父节点，否则如果抛异常的话，要视图干什么呢。
• 父节点发生结构性修改后，子节点（视图）可能没办法再去正确映射父节点这段范围，如果还要更新子节点的话，成本太高了，因为子节点可能不止一个，直接把子节点给废了就好了。
• 兄弟/叔父等旁系节点发生结构性修改后，与父节点发生修改同理，都是对同一个祖先的映射，相当于祖先被修改了，因此本节点要废掉。

有了前面的铺垫，很多方法基本不用再分析。只有updateSizeAndModCount和listIterator需要讲下：

• updateSizeAndModCount：每次对子列表做完结构性修改后（remove、add等），维护modCount和size：

  private void updateSizeAndModCount(int sizeChange) {
    SubList<E> slist = this;
    do {
      slist.size += sizeChange;
      slist.modCount = root.modCount;
      slist = slist.parent;
    } while (slist != null);
  }
  

  上面说过，节点发生修改，只需要同步祖先即可，因此借助parent，往root的方向，更新一路上父节点的modCount。

• listIterator：由于子列表只映射原列表的某个范围，因此肯定不能直接返回原列表的迭代器，SubList自己实现了一个匿名内部类，并且也是代理模式，代理原列表（父节点）的迭代器，比较简单，明白原理随便看看就行：

  public ListIterator<E> listIterator(int index) {
    checkForComodification();
    rangeCheckForAdd(index);
  
    return new ListIterator<E>() {
      private final ListIterator<E> i = root.listIterator(offset + index);
  
      public boolean hasNext() {
        return nextIndex() < size;
      }
  
      public E next() {
        if (hasNext())
          return i.next();
        else
          throw new NoSuchElementException();
      }
  
      public boolean hasPrevious() {
        return previousIndex() >= 0;
      }
  
      public E previous() {
        if (hasPrevious())
          return i.previous();
        else
          throw new NoSuchElementException();
      }
  
      public int nextIndex() {
        return i.nextIndex() - offset;
      }
  
      public int previousIndex() {
        return i.previousIndex() - offset;
      }
  
      public void remove() {
        i.remove();
        updateSizeAndModCount(-1);
      }
  
      public void set(E e) {
        i.set(e);
      }
  
      public void add(E e) {
        i.add(e);
        updateSizeAndModCount(1);
      }
    };
  }
  

RandomAccessSubList

继承于SubList，没有实现新的方法，只是多实现了一个RandomAccess接口，这个接口作为标记接口没有任何方法。这个类的目的是用于调用subList的时候保留RandomAccess接口。

说个题外话，像RandomAccess的空接口有什么用呢？用作标记。举个例子，某个函数接收参数类型为List，功能是遍历并输出元素，但是你不想采用迭代器的方式，而是使用下标的方式去遍历（因为可能下标方式是直接访问数组，而迭代器还得创建迭代器对象，调用额外的方法等，直接下标可能效率更高），但如果List是不支持随机访问的LinkedList，那么用下标方式就会很慢了，因此可以判断有没有实现RandomAccess快速判断支不支持随机访问，以选择迭代方式：

public void iter(List<String> list) {
  if (list instanceof RandomAccess) {
    for (int i = 0; i < list.size(); i++) {
      String s = list[i];
      sout(s);
    }
  } else {
    for (String s : list) {
      sout(s);
    }
  }
}

类似的，还有Cloneable接口、Serializable接口等，但是也有一些别的作用，比如Cloneable，如果你要实现clone方法的话，必须继承这个接口，否则调用super.clone()获取浅拷贝对象的时候（即Object.clone这个native方法）会直接抛异常。

Queue接口

顾名思义，Queue代表队列。其父接口是Collection。

虽然名义上是队列，但不一定是FIFO，也可以是优先队列，也可以是LIFO。总而言之Queue只是提供“入队”和“出队”的语义，而出入队顺序并不作规定，即在给定入队顺序下，出队顺序由子类定义。

Queue定义了两套功能相同的方法，及其应对非法操作的行为：

• add/offer入队：抛出IllegalStateException / 返回false
• remove/poll出队：抛出NoSuchElementException / 返回null
• element/peek查询队首元素：抛出NoSuchElementException / 返回null

非法操作包括对满队列入队、对空队列出队/查询队首，前一组方法（add、remove、element）直接抛出异常，后一组命名更加fancy的方法（offer、poll、peek）则返回特殊值。

由于Queue不规定出队顺序，因此如果要比较两个Queue的话（即equals、hashcode方法），一般不能基于元素来比较他们，是否相等还与出队顺序相关，因此一般使用默认的Object.equals…

Deque（/dɛk/）接口

Deque表示双端队列，其父接口是Queue。注意Deque这个单词与deck的发音一样，与de-queue区分开来，后者用来说“出队”这个操作，比如：you can "de-queue an object from the deque。

在Queue的基础上添加了一堆方法，不过都比较好理解。直接截图源码文档看一下：

Queue的方法依然保持原来的语义，last代表队尾，first为队首：

Deque还提供了用作栈的方法，比如push、pop（当然，你也可以通过定义Queue的出队顺序为LIFO来搞个栈，只是没有push、pop这些以栈操作来命名的方法）。基于这一点，相比Stack类官方推荐用Deque接口，可能因为Stack继承于Vector，而Vector早已是哥们废了：

还提供了两个移除内部元素（即队头队尾）的方法：

boolean removeFirstOccurrence(Object o);
boolean removeLastOccurrence(Object o);

参考链接

「CSDN」Java 集合框架原理分析