JAVA集合类汇总记录-针对自己的知识点记录

亦凉 2022-05-31 13:21 169阅读 0赞

## **一、集合与数组** ##

**数组**（可以存储基本数据类型）是用来存现对象的一种容器，但是数组的长度固定，不适合在对象数量未知的情况下使用。

**集合**（只能存储对象，对象类型可以不一样）的长度可变，可在多数情况下使用。

## **二、层次关系** ##

如图所示：

图中，实线边框的是实现类，折线边框的是抽象类，而点线边框的是接口

![SouthEast][]

Collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。但是却让其被继承产生了两个接口，就是Set和List。Set中不能包含重复的元素。List是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式。  
  
Map是Java.util包中的另一个接口，它和Collection接口没有关系，是相互独立的，但是都属于集合类的一部分。Map包含了key-value对。Map不能包含重复的key，但是可以包含相同的value。  
  
Iterator，所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含以下三种方法：  
1.hasNext()是否还有下一个元素。  
2.next()返回下一个元素。  
3.remove()删除当前元素。

## 三、几种重要的接口和类简介 ##

1、List（有序、可重复）  
List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据的移动，所有插入删除数据速度慢。  
  
2、Set（无序、不能重复）  
Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。  
  
3、Map（键值对、键唯一、值不唯一）  
Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。  
  
**对比如下：**

<table style="margin:0px; padding:0px; border-collapse:collapse; border-spacing:0px; border:1px solid silver; word-break:break-word; color:rgb(57,57,57); font-family:Verdana,Arial,Helvetica,sans-serif; font-size:14px; background-color:rgb(250,247,239)"> 
 <tbody style="margin:0px; padding:0px"> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 　 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 　 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 是否有序 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 是否允许元素重复 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td colspan="2" style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> Collection </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> &nbsp; </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> &nbsp; </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td colspan="2" style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> List </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 是 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 是 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> Set </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> AbstractSet </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 否 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 否 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 　 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> HashSet </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 　 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> TreeSet </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 是（用二叉排序树） </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> Map </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> AbstractMap </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 否 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 使用key-value来映射和存储数据，key必须唯一，value可以重复 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 　 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> HashMap </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 　 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> TreeMap </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 是（用二叉排序树） </td> 
 </tr> 
 </tbody> 
</table>

## 四、遍历 ##

在类集中提供了以下四种的常见输出方式： 
 
 
1）Iterator：迭代输出，是使用最多的输出方式。 
 
 
2）ListIterator：是Iterator的子接口，专门用于输出List中的内容。 
 
 
3）foreach输出：JDK1.5之后提供的新功能，可以输出数组或集合。 
 
 
4）for循环 
 
 
代码示例如下： 
 
 
 for的形式：for（int i=0;i<arr.size();i++）\{...\} 
 
 
 foreach的形式： for（int　i：arr）\{...\} 
 
 
 iterator的形式： 
Iterator it = arr.iterator(); 
while(it.hasNext())\{ object o =it.next(); ...\}

## 五、ArrayList和LinkedList ##

ArrayList和LinkedList在用法上没有区别，但是在功能上还是有区别的。LinkedList经常用在增删操作较多而查询操作很少的情况下，ArrayList则相反。

## 六、Map集合 ##

实现类：HashMap、Hashtable、LinkedHashMap和TreeMap  
  
  
HashMap   
  
  
HashMap是最常用的Map，它根据键的HashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度，遍历时，取得数据的顺序是完全随机的。因为键对象不可以重复，所以HashMap最多只允许一条记录的键为Null，允许多条记录的值为Null，是非同步的  
  
  
Hashtable  
  
  
Hashtable与HashMap类似，是HashMap的线程安全版，它支持线程的同步，即任一时刻只有一个线程能写Hashtable，因此也导致了Hashtale在写入时会比较慢，它继承自Dictionary类，不同的是它不允许记录的键或者值为null，同时效率较低。  
  
  
ConcurrentHashMap  
  
  
线程安全，并且锁分离。ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行。  
  
  
LinkedHashMap  
  
  
LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的，在遍历的时候会比HashMap慢，有HashMap的全部特性。  
  
  
TreeMap  
  
  
TreeMap实现SortMap接口，能够把它保存的记录根据键排序，默认是按键值的升序排序（自然顺序），也可以指定排序的比较器，当用Iterator遍历TreeMap时，得到的记录是排过序的。不允许key值为空，非同步的；  
  
  
map的遍历  
  
  
第一种：KeySet()  
将Map中所有的键存入到set集合中。因为set具备迭代器。所有可以迭代方式取出所有的键，再根据get方法。获取每一个键对应的值。 keySet():迭代后只能通过get()取key 。  
取到的结果会乱序，是因为取得数据行主键的时候，使用了HashMap.keySet()方法，而这个方法返回的Set结果，里面的数据是乱序排放的。  
典型用法如下：

Map map = new HashMap();
    map.put("key1","lisi1");
    map.put("key2","lisi2");
    map.put("key3","lisi3");
    map.put("key4","lisi4");  
    //先获取map集合的所有键的set集合，keyset（）
    Iterator it = map.keySet().iterator();
     //获取迭代器
    while(it.hasNext()){
    Object key = it.next();
    System.out.println(map.get(key));
    }

第二种：entrySet（） 
Set<Map.Entry<K,V>> entrySet() //返回此映射中包含的映射关系的 Set 视图。（一个关系就是一个键-值对），就是把(key-value)作为一个整体一对一对地存放到Set集合当中的。Map.Entry表示映射关系。entrySet()：迭代后可以e.getKey()，e.getValue()两种方法来取key和value。返回的是Entry接口。 
典型用法如下：

Map map = new HashMap();
    map.put("key1","lisi1");
    map.put("key2","lisi2");
    map.put("key3","lisi3");
    map.put("key4","lisi4");
    //将map集合中的映射关系取出，存入到set集合
    Iterator it = map.entrySet().iterator();
    while(it.hasNext()){
    Entry e =(Entry) it.next();
    System.out.println("键"+e.getKey () + "的值为" + e.getValue());
    }

推荐使用第二种方式，即entrySet()方法，效率较高。  
对于keySet其实是遍历了2次，一次是转为iterator，一次就是从HashMap中取出key所对于的value。而entryset只是遍历了第一次，它把key和value都放到了entry中，所以快了。两种遍历的遍历时间相差还是很明显的。

## 七、主要实现类区别小结 ##

Vector和ArrayList  
1，vector是线程同步的，所以它也是线程安全的，而arraylist是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用arraylist效率比较高。  
2，如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%，而arraylist增长率为目前数组长度的50%。如果在集合中使用数据量比较大的数据，用vector有一定的优势。  
3，如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，如果频繁的访问数据，这个时候使用vector和arraylist都可以。而如果移动一个指定位置会导致后面的元素都发生移动，这个时候就应该考虑到使用linklist,因为它移动一个指定位置的数据时其它元素不移动。  
ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要涉及到数组元素移动等内存操作，所以索引数据快，插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快。  
  
  
arraylist和linkedlist  
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。  
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。  
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。  
  
  
HashMap与TreeMap  
1、 HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。  
2、在Map 中插入、删除和定位元素，HashMap是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。  
两个map中的元素一样，但顺序不一样，导致hashCode()不一样。  
同样做测试：  
在HashMap中，同样的值的map,顺序不同，equals时，false;  
而在treeMap中，同样的值的map,顺序不同,equals时，true，说明，treeMap在equals()时是整理了顺序了的。  
  
  
HashTable与HashMap  
1、同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。  
2、HashMap允许存在一个为null的key，多个为null的value 。  
3、hashtable的key和value都不允许为null。

Collection 和 Collections的区别。 
    Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。 
    
    Collection是个java.util下的接口，它是各种集合结构的父接口。 
    
    List, Set, Map是否继承自Collection接口? List，Set是  Map不是 
    
    ArrayList和Vector的区别。 
    
    一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的 
    二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半 
    
    HashMap和Hashtable的区别 
    
    一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现 
    
    二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的 
    
    三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

Collection

├List

│├LinkedList

│├ [ArrayList][]

│└Vector

│　└Stack

└Set

Map

├ [Hashtable][]

├ [HashMap][]

└WeakHashMap

所有实现Collection接口的类都必须提供两个标准的 [构造函数][Link 1]：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。

如何 [遍历][Link 2]Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个 [iterator][]()的方法，该方法返回一个 [迭代][Link 3]子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：

Iterator it = collection.iterator(); // 获得一个迭代子

[while][](it.hasNext()) \{

Object obj = it.next(); // 得到下一个元素

由Collection接口派生的两个接口是List和Set。

## List接口 ##

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于 [数组][Link 4]下标）来访问List中的元素，这类似于 [Java][]的数组。

和下面要提到的Set不同，List允许有相同的元素。

除了具有Collection接口必备的 [iterator][]()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的 [Iterator][]接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后 [遍历][Link 2]。

实现List接口的常用类有LinkedList， [ArrayList][]，Vector和Stack。

LinkedList类

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作 [堆栈][Link 5]（stack），队列（ [queue][]）或双向队列（ [deque][]）。

注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：

List list = Collections.synchronizedList(new LinkedList(...));

[ArrayList][]类

ArrayList实现了可变大小的 [数组][Link 4]。它允许所有元素，包括null。ArrayList没有同步。

[size][]，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加 [ArrayList][]的容量以提高插入效率。

和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Vector类

Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的 [Iterator][]，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

Stack 类

Stack继承自Vector，实现一个后进先出的 [堆栈][Link 6]。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

## Set接口 ##

Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。

很明显，Set的 [构造函数][Link 1]有一个约束条件，传入的Collection参数不能包含重复的元素。

请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

## Map接口 ##

请注意，Map没有继承Collection接口，Map提供key到 [value][]的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组 [key-value][]映射。

[Hashtable][]类

Hashtable继承Map接口，实现一个key-value映射的 [哈希表][Link 7]。任何非空（non-null）的对象都可作为key或者value。

添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。

Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。

使用 [Hashtable][]的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：

Hashtable numbers = new Hashtable();

numbers.put(“one”, new Integer(1));

numbers.put(“two”, new Integer(2));

numbers.put(“three”, new Integer(3));

要取出一个数，比如2，用相应的key：

Integer n = (Integer)numbers.get(“two”);

System.out.println(“two = ” + n);

由于作为key的对象将通过计算其散列函数来确定与之对应的 [value][]的位置，因此任何作为key的对象都必须实现 [hashCode][]和 [equals][]方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的 [hashCode][]相同，这种现象称为冲突，冲突会导致操作 [哈希表][Link 7]的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。

如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写 [equals][]方法和hashCode方法，而不要只写其中一个。

[Hashtable][]是同步的。

[HashMap][]类

HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其 [迭代][Link 8]子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

HashSet类

参见set。

WeakHashMap类

WeakHashMap是一种改进的 [HashMap][]，它对key实行“ [弱引用][Link 9]”，如果一个key不再被外部所引用，那么该key可以被GC回收。

## 总结 ##

如果涉及到 [堆栈][Link 5]，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用 [ArrayList][]。

如果程序在 [单线程][Link 10]环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。

要特别注意对 [哈希表][Link 7]的操作，作为key的对象要正确复写 [equals][]和 [hashCode][]方法。

尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对 [抽象编程][Link 11]。

同步性

Vector是同步的。这个类中的一些方法保证了Vector中的对象是 [线程安全][Link 12]的。而 [ArrayList][]则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。

数据增长

从内部实现机制来讲ArrayList和Vector都是使用 [数组][Link 4]( [Array][])来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了 [内部数组][Link 13]目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度， [ArrayList][]是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。

使用模式

在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？

这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或 [ArrayList][]都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替创建 [iterator][]对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。

最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的 [数组][Link 4]（ [Array][]）来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。

[SouthEast]: /images/20220531/2a5b9313b7ac433a894b5f17941e3047.png
[ArrayList]: https://baike.baidu.com/item/ArrayList/5529371
[Hashtable]: https://baike.baidu.com/item/Hashtable/3149676
[HashMap]: https://baike.baidu.com/item/HashMap/1167707
[Link 1]: https://baike.baidu.com/item/%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0
[Link 2]: https://baike.baidu.com/item/%E9%81%8D%E5%8E%86/9796023
[iterator]: https://baike.baidu.com/item/iterator/226189
[Link 3]: https://baike.baidu.com/item/%E8%BF%AD%E4%BB%A3
[while]: https://baike.baidu.com/item/while/755564
[Link 4]: https://baike.baidu.com/item/%E6%95%B0%E7%BB%84
[Java]: https://baike.baidu.com/item/Java/85979
[Iterator]: https://baike.baidu.com/item/Iterator/226189
[Link 5]: https://baike.baidu.com/item/%E5%A0%86%E6%A0%88/1682032
[queue]: https://baike.baidu.com/item/queue/4511093
[deque]: https://baike.baidu.com/item/deque/849385
[size]: https://baike.baidu.com/item/size/2286120
[Link 6]: https://baike.baidu.com/item/%E5%A0%86%E6%A0%88
[value]: https://baike.baidu.com/item/value/2285610
[key-value]: https://baike.baidu.com/item/key-value/8578878
[Link 7]: https://baike.baidu.com/item/%E5%93%88%E5%B8%8C%E8%A1%A8
[hashCode]: https://baike.baidu.com/item/hashCode/7482507
[equals]: https://baike.baidu.com/item/equals/4481402
[Link 8]: https://baike.baidu.com/item/%E8%BF%AD%E4%BB%A3/8415523
[Link 9]: https://baike.baidu.com/item/%E5%BC%B1%E5%BC%95%E7%94%A8/1019312
[Link 10]: https://baike.baidu.com/item/%E5%8D%95%E7%BA%BF%E7%A8%8B
[Link 11]: https://baike.baidu.com/item/%E6%8A%BD%E8%B1%A1%E7%BC%96%E7%A8%8B
[Link 12]: https://baike.baidu.com/item/%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8
[Array]: https://baike.baidu.com/item/Array/2182501
[Link 13]: https://baike.baidu.com/item/%E5%86%85%E9%83%A8%E6%95%B0%E7%BB%84/10529199