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

文章目录

  • 简介
  • 代码分析
    • Iterator接口
    • Iterable接口
    • Collection接口
    • AbstractCollection抽象类
    • List接口
    • AbstractList抽象类
      • Itr(Iterator的实现)
      • ListItr(ListIterator的实现)
      • SubList
      • RandomAccessSubList
    • Queue接口
    • Deque(/dɛk/)接口
  • 参考链接

本人的源码阅读主要聚焦于类的使用场景,一般只在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());
}

值得分析的方法只有两个:subListequals

  • 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();

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

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

有了前面的铺垫,很多方法基本不用再分析。只有updateSizeAndModCountlistIterator需要讲下:

  • 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的基础上添加了一堆方法,不过都比较好理解。直接截图源码文档看一下:

JCF相关基础类接口/抽象类源码阅读_第1张图片

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

JCF相关基础类接口/抽象类源码阅读_第2张图片

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

JCF相关基础类接口/抽象类源码阅读_第3张图片

还提供了两个移除内部元素(即队头队尾)的方法:

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

参考链接

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

你可能感兴趣的:(java)