第八章 java容器 （集合）

java 容器---集合

一、各种集合的整体关系图

1. Collection框架类图

collection框架图.png

2. 总体关系图

接口继承关系和实现

集合类存放于 Java.util 包中，主要有 3 种：set(集）、list(列表包含 Queue）和 map(映射)。

1. Collection：Collection 是集合 List、Set、Queue 的最基本的接口。

   Collection和Collections的区别

   • Collection是Java提供的集合接口，存储一组不唯一，无序的对象。它有两个子接口

   List和Set。

   • Collections类，专门用来操作集合类 ，它提供一系列静态方法实现对

   各种集合的搜索、排序、线程安全化等操作。

2. Iterator：迭代器，可以通过迭代器遍历集合中的数据

   ListIterator和Iterator的区别：

   ①使用范围不同：Iterator可以应用于更多的集合，Set、List和这些集合的子类型。

   而ListIterator只能用于List及其子类型。

   ②遍历顺序不同：Iterator只能顺序向后遍历; ListIterator还可以逆序向前遍历

   • Iterator可以在遍历的过程中remove();ListIterator可以在遍历的过程中remove()、add()、set()

   ③ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。

3. Map：是映射表的基础接口

二、List

2.1. ArrayList（数组） <u style="box-sizing: border-box;">线程不安全</u>

ArrayList 是最常用的 List 实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数

组的缺点是每个元素之间不能有间隔，<u style="box-sizing: border-box;">当数组大小不满足时需要增加存储能力，就要将已经有数</u>

<u style="box-sizing: border-box;">组的数据复制到新的存储空间中。当从 ArrayList 的中间位置插入或者删除元素时，需要对数组进</u>

<u style="box-sizing: border-box;">行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除</u>。

实现了长度可变的数组

2.1.2 listadd()和listaddall()的区别?

1.List.add()：向List中添加对象，它就把自己当做一个对

象，往这个List中添加容器，它就把自己当做一个容器。

2.List.addAll():规定List就是一个容器，往List中添加 list实例，都会被看成对象（当需要把多个List实例放到一

起的时候，必须使用List.addAll()方法）

2.2. Vector（数组实现、线程同步） 线程安全

Vector 与 ArrayList 一样，也是通过数组实现的，不同的是<u style="box-sizing: border-box;">它支持线程的同步，即某一时刻只有一</u>

<u style="box-sizing: border-box;">个线程能够写 Vector</u>，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，

访问它比访问 ArrayList 慢。

2.3. LinkList（链表） 线程不安全

<u style="box-sizing: border-box;">LinkedList 是用链表结构存储数据的，很适合数据的动态插入和删除</u>，随机访问和遍历速度比较

慢。另外，他还提供了 List 接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆

栈、队列和双向队列使用。

2.4 ArrayList和LinkedList 的联系和区别

• 联系：

• 都实现了List接口

• 有序 不唯一（可重复）

• ArrayList

• 在内存中分配连续的空间，实现了长度可变的数组

• 优点：遍历元素和随机访问元素的效率比较高

• 缺点：添加和删除需大量移动元素效率低，按照内容查询效率低，

• LinkedList

• 采用链表存储方式。

• 缺点：遍历和随机访问元素效率低下

• 优点：插入、删除元素效率比较高（但是前提也是必须先低效率查询才可。如果插入删除发生在头尾

可以减少查询次数）

三、set

Set 注重独一无二的性质,该体系集合用于存储无序(存入和取出的顺序不一定相同)元素，值不能重

复。对象的相等性本质是对象 hashCode 值（java 是依据对象的内存地址计算出的此序号）判断

<u style="box-sizing: border-box;">的，如果想要让两个不同的对象视为相等的，就必须覆盖 Object 的 hashCode 方法和 equals 方</u>

<u style="box-sizing: border-box;">法。</u>

3.1 HashSet（Hash表）

哈希表边存放的是哈希值。存储元素的顺序是按照哈希值来存的所以取数据也是按照哈希值取得。元素的哈希值是通过元素的 hashcode 方法来获取的, HashSet 首先判断两个元素的哈希值，如果哈希值一样，接着会比较

equals 方法 如果 equls 结果为 true ，HashSet 就视为同一个元素。如果 equals 为 false 就不是

同一个元素。 （需要hashcode（）和equals（）均判断相等才可以）

HashSet、HashMap或Hashtable中（hash家族*）对象唯一性判断： 重写其hashcode（）和equals（）

哈希值相同 equals 为 false 的元素是怎么存储呢,就是在同样的哈希值下顺延（可以认为哈希值相

同的元素放在一个哈希桶中）。也就是哈希一样的存一列。如图 1 表示 hashCode 值不相同的情

况；图 2 表示 hashCode 值相同，但 equals 不相同的情况。

3.2 TreeSet （二叉树）

1. TreeSet()是使用二叉树的原理对新 add()的对象按照指定的顺序排序（升序、降序），每增

加一个对象都会进行排序，将对象插入的二叉树指定的位置。

2. Integer 和 String 对象都可以进行默认的 TreeSet 排序，而自定义类的对象是不可以的，自

己定义的类必须实现 Comparable 接口，并且覆写相应的 compareTo()函数，才可以正常使

用。

3. 在覆写 compare()函数时，要返回相应的值才能使 TreeSet 按照一定的规则来排序

4. 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整

数、零或正整数。

3.3 LinkHashSet（HashSet+LinkedHashMap）

对于 LinkedHashSet 而言，它继承与 HashSet、又基于 LinkedHashMap 来实现的。

LinkedHashSet 底层使用 LinkedHashMap 来保存所有元素，它继承与 HashSet，其所有的方法

操作上又与 HashSet 相同，因此 LinkedHashSet 的实现上非常简单，只提供了四个构造方法，并

通过传递一个标识参数，调用父类的构造器，底层构造一个 LinkedHashMap 来实现，在相关操

作上与父类 HashSet 的操作相同，直接调用父类 HashSet 的方法即可。

四、Map

4.1 HashMap（数组+链表+红黑树）

HashMap 根据键的 hashCode 值存储数据，大多数情况下可以直接定位到它的值，因而具有很快

的访问速度，但遍历顺序却是不确定的。 HashMap 最多只允许一条记录的键为 null，允许多条记

录的值为 null。HashMap 非线程安全，即任一时刻可以有多个线程同时写 HashMap，可能会导

致数据的不一致。如果需要满足线程安全，可以用 Collections 的 synchronizedMap 方法使

HashMap 具有线程安全的能力，或者使用 ConcurrentHashMap。我们用下面这张图来介绍

HashMap 的结构。

HashMap和Hashtable的联系和区别

• 实现原理相同，功能相同，底层都是哈希表结构，查询速度快，在很多情况下可以互用

• 两者的主要区别如下

• Hashtable是早期JDK提供的接口，HashMap是新版JDK提供的接口

• Hashtable继承Dictionary类，HashMap实现Map接口

• Hashtable线程安全，HashMap线程非安全

• Hashtable不允许null值，HashMap允许null值

引用：

JAVA8 实现

Java8 对 HashMap 进行了一些修改，最大的不同就是利用了红黑树，所以其由 数组+链表+红黑

树 组成。

根据 Java7 HashMap 的介绍，我们知道，查找的时候，根据 hash 值我们能够快速定位到数组的

具体下标，但是之后的话，需要顺着链表一个个比较下去才能找到我们需要的，时间复杂度取决

于链表的长度，为 O(n)。为了降低这部分的开销，在 Java8 中，当链表中的元素超过了 8 个以后，

会将链表转换为红黑树，在这些位置进行查找的时候可以降低时间复杂度为 O(logN)。

java8 hashmap结构.png

ConcurrentHashMap

Segment 段

ConcurrentHashMap 和 HashMap 思路是差不多的，但是因为它支持并发操作，所以要复杂一

些。整个 ConcurrentHashMap 由一个个 Segment 组成，Segment 代表”部分“或”一段“的

意思，所以很多地方都会将其描述为分段锁。注意，行文中，我很多地方用了“槽”来代表一个

segment。

线程安全（Segment 继承 ReentrantLock 加锁）

简单理解就是，ConcurrentHashMap 是一个 Segment 数组，Segment 通过继承

ReentrantLock 来进行加锁，所以每次需要加锁的操作锁住的是一个 segment，这样只要保证每

个 Segment 是线程安全的，也就实现了全局的线程安全。

4.2 HashTable（线程安全）

Hashtable 是遗留类，很多映射的常用功能与 HashMap 类似，不同的是它承自 Dictionary 类，

并且是线程安全的，任一时间只有一个线程能写 Hashtable，并发性不如 ConcurrentHashMap，

因为 ConcurrentHashMap 引入了分段锁。Hashtable 不建议在新代码中使用，不需要线程安全

的场合可以用 HashMap 替换，需要线程安全的场合可以用 ConcurrentHashMap 替换。

**4.3 TreeMap****（可排序）

TreeMap 实现 SortedMap 接口，能够把它保存的记录根据键排序，默认是按键值的升序排序，

也可以指定排序的比较器，当用 Iterator 遍历 TreeMap 时，得到的记录是排过序的。

如果使用排序的映射，建议使用 TreeMap。

在使用 TreeMap 时，key 必须实现 Comparable 接口或者在构造 TreeMap 传入自定义的

Comparator，否则会在运行时抛出 java.lang.ClassCastException 类型的异常。

参考：https://www.ibm.com/developerworks/cn/java/j-lo-tree/index.html

*4.4 LinkHashMap****（记录插入顺序）

LinkedHashMap 是 HashMap 的一个子类，保存了记录的插入顺序，在用 Iterator 遍历

LinkedHashMap 时，先得到的记录肯定是先插入的，也可以在构造时带参数，按照访问次序排序。

参考 1：http://www.importnew.com/28263.html

参考 2：http://www.importnew.com/20386.html#comment-648123

五、Collections工具类

类 java.util.Collections 提供了对Set、List、Map进行排序、填充、查找元素的辅助方法。

1. void sort(List) //对List容器内的元素排序，排序的规则是按照升序进行排序。

2. void shuffle(List) //对List容器内的元素进行随机排列。

3. void reverse(List) //对List容器内的元素进行逆续排列 。

4. void fill(List, Object) //用一个特定的对象重写整个List容器。

5. int binarySearch(List, Object)//对于顺序的List容器，采用折半查找的方法查找特定对象。

【示例9-23】Collections工具类的常用方法

 public class Test {
  public static void main(String[] args) {
  List<String> aList = new ArrayList<String>();
  for (int i = 0; i < 5; i++){
  aList.add("a" + i);
  }
  System.out.println(aList);
  Collections.shuffle(aList); // 随机排列
  System.out.println(aList);
  Collections.reverse(aList); // 逆续
  System.out.println(aList);
  Collections.sort(aList); // 排序
  System.out.println(aList);
  System.out.println(Collections.binarySearch(aList, "a2")); 
  Collections.fill(aList, "hello");
  System.out.println(aList);
  }
 }

执行结果如图9-31所示：

图9-31示例9-23运行效果图.png

图9-31示例9-23运行效果图

六、遍历集合的方法总结

6.1 遍历LIst

 //1  普通for循环
 for(int i=0;i<list.size();i++){//list为集合的对象名
  String temp = (String)list.get(i);
  System.out.println(temp);
 }
 //2  增强for循环(使用泛型!)
 for (String temp : list) {
 System.out.println(temp);
 }
 ​
 //3  使用Iterator迭代器(1)
 for(Iterator iter= list.iterator();iter.hasNext();){
  String temp = (String)iter.next();
  System.out.println(temp);
 }
 ​
 //4  使用Iterator迭代器(2)
 Iterator  iter =list.iterator();
 while(iter.hasNext()){
  Object  obj =  iter.next();
  iter.remove();//如果要遍历时，删除集合中的元素，建议使用这种方式！
  System.out.println(obj);
 }
 ​

6.2 遍历set

 //1 遍历Set方法一 增强版for循环
 for(String temp:set){
 System.out.println(temp);
 }
 ​
 //2 遍历Set方法二：使用Iterator迭代器
 for(Iterator iter = set.iterator();iter.hasNext();){
  String temp = (String)iter.next();
  System.out.println(temp);
 }

6.3 遍历Map

 //1  根据key获取value
 Map<Integer, Man> maps = new HashMap<Integer, Man>();
 Set<Integer>  keySet =  maps.keySet();
 for(Integer id : keySet){
 System.out.println(maps.get(id).name);
 }
 ​
 //2  使用entrySet
 Set<Entry<Integer, Man>>  ss = maps.entrySet();
 for (Iterator iterator = ss.iterator(); iterator.hasNext();) {
  Entry e = (Entry) iterator.next(); 
  System.out.println(e.getKey()+"--"+e.getValue());
 ​</pre>

七、关于二叉树和红黑二叉树

7.1 二叉树的定义
1 二叉树是树形结构的一个重要类型。 许多实际问题抽象出来的数据结构往往是二叉树的形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。
2 二叉树(BinaryTree)由一个节点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。下图中展现了五种不同基本形态的二叉树。

图9-18 二叉树五种基本形态示意图.png

图9-18 二叉树五种基本形态示意图
(a) 为空树。
(b) 为仅有一个结点的二叉树。
(c) 是仅有左子树而右子树为空的二叉树。
(d) 是仅有右子树而左子树为空的二叉树。
(e) 是左、右子树均非空的二叉树。

注意事项
二叉树的左子树和右子树是严格区分并且不能随意颠倒的，图 (c) 与图 (d) 就是两棵不同的二叉树。

排序二叉树特性如下：
(1) 左子树上所有节点的值均小于它的根节点的值。
(2) 右子树上所有节点的值均大于它的根节点的值。
比如：我们要将数据【14,12,23,4,16,13, 8,,3】存储到排序二叉树中，如下图所示：

图9-19 排序二叉树示意图(1).png

图9-19 排序二叉树示意图(1)
排序二叉树本身实现了排序功能，可以快速检索。但如果插入的节点集本身就是有序的，要么是由小到大排列，要么是由大到小排列，那么最后得到的排序二叉树将变成普通的链表，其检索效率就会很差。 比如上面的数据【14,12,23,4,16,13, 8,,3】，我们先进行排序变成：【3,4,8,12,13,14,16,23】，然后存储到排序二叉树中，显然就变成了链表，如下图所示：

图9-20 排序二叉树示意图(2).png

图9-20 排序二叉树示意图(2)

▪ 平衡二叉树(AVL)
为了避免出现上述一边倒的存储，科学家提出了“平衡二叉树”。

  在平衡二叉树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。 增加和删除节点可能需要通过一次或多次树旋转来重新平衡这个树。

  节点的平衡因子是它的左子树的高度减去它的右子树的高度(有时相反)。带有平衡因子1、0或 -1的节点被认为是平衡的。带有平衡因子 -2或2的节点被认为是不平衡的，并需要重新平衡这个树。

  比如，我们存储排好序的数据【3,4,8,12,13,14,16,23】，增加节点如果出现不平衡，则通过节点的左旋或右旋，重新平衡树结构，最终平衡二叉树如下图所示：

图9-21 平衡二叉树示意图.png

图9-21 平衡二叉树示意图
平衡二叉树追求绝对平衡，实现起来比较麻烦，每次插入新节点需要做的旋转操作次数不能预知。

▪ 红黑二叉树
红黑二叉树(简称：红黑树)，它首先是一棵二叉树，同时也是一棵自平衡的排序二叉树。
红黑树在原有的排序二叉树增加了如下几个要求：
1. 每个节点要么是红色，要么是黑色。
2. 根节点永远是黑色的。
3. 所有的叶节点都是空节点(即 null)，并且是黑色的。
4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的路径上不会有两个连续的红色节点)
5. 从任一节点到其子树中每个叶子节点的路径都包含相同数量的黑色节点。
这些约束强化了红黑树的关键性质：从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。这样就让树大致上是平衡的。
红黑树是一个更高效的检索二叉树，JDK 提供的集合类 TreeMap、TreeSet 本身就是一个红黑树的实现。

图9-22一个典型的红黑树（考虑书本印刷问题，浅色表示红色，深色表示黑色）.png

图9-22一个典型的红黑树(考虑书本印刷问题，浅色表示红色，深色表示黑色)
红黑树的基本操作：插入、删除、左旋、右旋、着色。 每插入或者删除一个节点，可能会导致树不在符合红黑树的特征，需要进行修复，进行 “左旋、右旋、着色”操作，使树继续保持红黑树的特性。