Java集合（一）集合框架概述

文章目录

一、集合框架
- 1.1 常用的集合
- 1.2 线程安全的集合
- 1.3 “fail-fast”机制
- - 1.3.1 “fail-fast”机制是什么
  - 1.3.2 怎么解决“fail-fast”问题
- 1.4 Iterator迭代器
- - 1.4.1 迭代器Iterator是什么
  - 1.4.2 Iterator的作用
  - 1.4.3 Iterator的特点
- 1.5 Iterator和ListIterator比较
- - 1.5.1 两者介绍
  - 1.5.2 两者的方法
  - 1.5.3 两者的区别
- 1.6 集合相关的问题
- - 1.6.1 集合和数组的区别
  - 1.6.2 怎么确保一个集合不能被修改？
  - 1.6.3 Enumeration和Iterator接口的区别？
  - 1.6.4 与集合框架相关的有哪些最好的实践？
二、集合元素排序
- 2.1 Comparable和Comparator
- - 2.1.1 Comparable
  - 2.1.2 Comparator
  - 2.1.3 比较
- 2.2 TreeMap和TreeSet在排序时如何比较元素？Collections工具类中的sort方法如何比较元素？
- 2.3 如何对一组对象进行排序？
三、Collections常用方法
- 3.1 排序方法
- 3.2 查找替换方法
- 3.3 同步控制方法

本系列文章：
Java集合（一）集合框架概述
Java集合（二）List、ArrayList、LinkedList
Java集合（三）CopyOnWriteArrayList、Vector、Stack
Java集合（四）Map、HashMap、HashTable
Java集合（五）LinkedHashMap、TreeMap、ConcurrentHashMap
Java集合（六）Set、HashSet、LinkedHashSet、TreeSet
Java集合（七）BlockingQueue、ArrayBlockingQueue、LinkedBlockingQueue
Java集合（八）PriorityBlockingQueue、DelayQueue

一、集合框架

集合框架：用于存储数据的容器。集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。任何集合框架都包含三大块内容：

1、接口
表示集合的抽象数据类型。接口允许我们操作集合时不必关注具体实现，从而达到“多态”。在面向对象编程语言中，接口通常用来形成规范。
2、实现
集合接口的具体实现，是重用性很高的数据结构。
3、算法
在一个实现了某个集合框架中的接口的对象身上完成某种有用的计算的方法，例如查找、排序等。这些算法通常是多态的，因为相同的方法可以在同一个接口被多个类实现时有不同的表现。

常见集合的特征对比：

1.1 常用的集合

总的来说，Collection接口和Map接口是所有集合框架的父接口。Collection接口的子接口包括：Set接口、List接口和Queue接口。

1、Collection体系
2、Map体系
3、三大集合类的特征比较

集合类	特点	遍历
List	有序（元素存入集合的顺序和取出的顺序一致）；元素可以重复；可以插入多个Null元素；元素都有索引。	支持for循环，也就是通过下标来遍历；也可以用迭代器遍历。
Set	无序（存入和取出顺序有可能不一致）；元素不可以重复；只允许存入一个null元素；必须保证元素唯一性。	只能用迭代方式遍历，因为无序，无法用下标来取得想要的值。
Map	键值对集合，存储键、值和之间的映射。 Key无序，唯一； value不要求有序，允许重复。	底层实现也是List，所以也支持for循环，也就是通过下标来遍历；也可以用迭代器。

4、三大集合类的常见实现类

接口	常用实现类
Map	HashMap、LinkedHashMap、Hashtable、ConcurrentHashMap
Set	HashSet、LinkedHashSet
List	ArrayList、LinkedList、Stack
Queue	ArrayBlockingQueue、LinkedBlockingQueue

5、List实现类底层实现方式比较

集合类	底层实现
Arraylist	Object数组
Vector	Object数组
LinkedList	双向链表(JDK1.6之前为循环链表，JDK1.7取消了循环)

6、Set实现类底层实现方式比较

集合类	底层实现
HashSet	基于HashMap实现，用HashMap来保存元素
LinkedHashSet	LinkedHashSet继承HashSet，基于LinkedHashMap实现
TreeSet	红黑树(自平衡的排序二叉树)

7、Map实现类底层实现方式比较

集合类	底层实现
HashMap	JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在。JDK1.8以后链表在元素较多时，可以转化为红黑树
LinkedHashMap	LinkedHashMap继承HashMap，所以它的底层仍然是由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序（LRU）相关逻辑
Hashtable	和HashMap相似，由数组+链表组成，数组是Hashtable的主体，链表则是主要为了解决哈希冲突而存在
TreeMap	红黑树（平衡二叉排序树）

1.2 线程安全的集合

线程安全集合类可以分为三大类：

1、遗留的线程安全集合
如 Hashtable ， Vector。
2、使用 Collections 装饰的线程安全集合
如：Collections.synchronizedCollection、Collections.synchronizedList、Collections.synchronizedMap、Collections.synchronizedSet、Collections.synchronizedNavigableMap、Collections.synchronizedNavigableSet、Collections.synchronizedSortedMap、Collections.synchronizedSortedSet。
3、java.util.concurrent.*
里面包含三类关键词：Blocking、CopyOnWrite、Concurrent。

Blocking大部分实现基于锁，并提供用来阻塞的方法；

CopyOnWrite之类容器修改开销相对较重；

Concurrent类型的容器：内部很多操作使用CAS优化，一般可以提供较高吞吐量。

1.3 “fail-fast”机制

1.3.1 “fail-fast”机制是什么

在ArrayList、LinkedList、HashMap等等的内部实现增、删、改中，总能看到modCount 的身影，modCount字面意思就是修改次数。
所有使用 modCount 属性集合的都是线程不安全的。
在一个迭代器初始的时候会赋予它调用这个迭代器的对象的 modCount，在迭代器遍历的过程中，一旦发现这个对象的modCount和迭代器中存储的modCount不一样那就抛异常。
fail-fast是Java集合的一种错误检测机制，当多个线程对集合进行结构上的改变的操作时，有可能会产生fail-fast。例如：假设存在两个线程（线程1、线程2），线程1通过 Iterator 在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出ConcurrentModificationException异常，从而产生fail-fast事件。
原因：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个modCount变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。
当然，不仅是多个线程，单个线程也会出现fail-fast机制，包括ArrayList、HashMap无论在单线程和多线程状态下，都可能会出现ConcurrentModificationException 异常。

1.3.2 怎么解决“fail-fast”问题

1、将线程不安全的集合转换成线程安全的集合
比如使用Collections.synchronizedList将线程不安全的集合转换成线程安全的集合。
2、直接使用线程安全的集合
比如使用CopyOnWriteArrayList，它的所有可变操作（add、set等）都是通过对底层数组进行一次新的复制来实现的。该类产生的开销比较大，但是在两种情况下，它非常适合使用：

在不能或不想进行同步遍历，但又需要从并发线程中排除冲突时；

当遍历操作的数量大大超过可变操作的数量时。

3、不要使用集合自身的删除方法，而使用集合中迭代器的删除方法

1.4 Iterator迭代器

1.4.1 迭代器Iterator是什么

Iterator对象称为迭代器（设计模式的一种），迭代器可以对集合进行遍历，但每个集合内部的数据结构可能是不尽相同的，所以每个集合存和取都很可能是不一样的，虽然我们可以为地在每个类中定义hasNext()和next()方法，但这样做会让整个集合体系过于臃肿。于是就有了迭代器。
迭代器是将这样的方法抽取出接口，然后在每个类的内部，定义迭代方式，这样做就规定了整个集合体系的遍历方式都是hasNext()和next()方法，使二者不管怎么实现的，会用即可。迭代器的定义为：提供一种方法访问一个容器对象中各个元素，而有不需要暴露该对象的内部细节。
具体到代码层面而言，迭代器就是一个接口：

public interface Iterator<E> {//集合中是否还有元素boolean hasNext();//获取下一个元素E next();//删除元素default void remove() {throw new UnsupportedOperationException("remove");}
}

Iterator使用示例：

     //迭代器循环Iterator iterator = list.iterator();while(iterator.hasNext()){System.out.println(o);}

所有的集合类都默认实现了Iterable的接口，实现此接口意味着具备了增强for循环的能力，也就是for-each，因为增强for循环本质上使用的也是Iterator（迭代器）的功能。

1.4.2 Iterator的作用

Iterator主要是用来遍历集合⽤的，它的特点是更加安全，因为它可以确保，在当前遍历的集合元素被更改的时候，就会抛出ConcurrentModificationException异常。

1.4.3 Iterator的特点

1、使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。
2、使用next()获得序列中的下一个元素。
3、使用hasNext()检查序列中是否还有元素。
4、使用remove()将迭代器新返回的元素删除。
5、Iterator接口被Collection接口继承，因此List、Set、Queue的实现类都可以使用迭代器。
6、Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。
7、Iterator遍历集合元素的过程中不允许线程对集合元素进行修改，否则会抛出ConcurrentModificationEception的异常。
8、Iterator遍历集合元素的过程中可以通过Iterator.remove方法来移除集合中的元素，删除的是上一次Iterator.next()方法返回的对象。示例：

 Iterator<Integer> it = list.iterator();while(it.hasNext()){it.remove();}

1.5 Iterator和ListIterator比较

1.5.1 两者介绍

Iterator代表迭代器，是Collection框架中的一个接口，用于遍历集合元素。它允许逐个迭代集合中的每个元素，从集合中获取元素或从集合中删除元素，但无法使用Iterator修改集合中的任何元素。
Iterator缺点：

使用Iterator，只能即单向遍历。

使用Iterator，无法修改集合中的元素。

ListIterator是Collection框架中的一个接口；是用于扩展Iterator接口的。ListIterator，可以向前和向后遍历集合的元素，还可以添加、删除或修改集合中的任何元素。简而言之，可以说它消除了Iterator的缺点。

1.5.2 两者的方法

Iterator迭代器包含的主要方法：

方法	作用
hasNext()	如果迭代器指向位置后面还有元素，则返回true，否则返回false
next()	返回集合中Iterator指向位置后面的元素
remove()	删除集合中Iterator指向位置后面的元素

ListIterator迭代器包含的主要方法：

方法	作用
add(E e)	将指定的元素插入列表，插入位置为迭代器当前位置之前
hasNext()	以正向遍历列表时，如果列表迭代器后面还有元素，则返回 true，否则返回false
hasPrevious()	以逆向遍历列表，列表迭代器前面还有元素，则返回 true，否则返回false
next()	返回列表中ListIterator指向位置后面的元素
nextIndex()	返回列表中ListIterator所需位置后面元素的索引
previous()	返回列表中ListIterator指向位置前面的元素
previousIndex()	返回列表中ListIterator所需位置前面元素的索引
remove()	从列表中删除next()或previous()返回的最后一个元素
set(E e)	从列表中将next()或previous()返回的最后一个元素返回的最后一个元素更改为指定元素e

1.5.3 两者的区别

	Iterator	ListIterator
遍历	可以遍历所有集合，如Map，List，Set；但只能在向前方向上遍历集合中的元素。	只能遍历List实现的对象，但可以向前和向后遍历集合中的元素。
添加元素	无法向集合中添加元素	可以向集合添加元素
修改元素	无法修改集合中的元素	可以使用set方法修改集合中的元素
是否可以获取元素索引	无法获取集合中元素的索引	可以获取集合中元素的索引

1.6 集合相关的问题

1.6.1 集合和数组的区别

	集合	数组
长度是否可变	可变	不可变
存储的数据类型	只能存储引用数据类型	可以存储基本数据类型，也可以存储引用数据类型
存储的元素是否类型一致	可以是不同类型的数据	必须是同一个类型的数据

1.6.2 怎么确保一个集合不能被修改？

可以使用Collections.unmodifiableCollection(Collection c) 方法来创建一个只读集合，这样改变集合的任何操作都会抛出Java. lang. UnsupportedOperationException异常。示例：

 List<String> list = new ArrayList<>();list. add("x");Collection<String> clist = Collections. unmodifiableCollection(list);clist. add("y"); // 运行时此行报错System. out. println(list. size());

1.6.3 Enumeration和Iterator接口的区别？

Enumeration速度是Iterator的2倍，同时占用更少的内存。但是，Iterator远远比Enumeration安全，因为其他线程不能够修改正在被iterator遍历的集合里面的对象。同时，Iterator允许调用者删除底层集合里面的元素，这对Enumeration来说是不可能的。

1.6.4 与集合框架相关的有哪些最好的实践？

1、根据需要选择正确的集合类型。比如，如果指定了大小，我们会选用Array而非ArrayList。如果我们想根据插入顺序遍历一个Map，我们需要使用TreeMap。如果我们不想重复，我们应该使用Set。
2、一些集合类允许指定初始容量，所以如果我们能够估计到存储元素的数量，我们可以使用它，就避免了重新哈希或大小调整。
3、基于接口编程，而非基于实现编程，它允许我们后来轻易地改变实现。
4、总是使用类型安全的泛型，避免在运行时出现ClassCastException。
5、使用JDK提供的不可变类作为Map的key，可以避免自己实现hashCode()和equals()。
6、尽可能使用Collections工具类，或者获取只读、同步或空的集合，而非编写自己的实现。它将会提供代码重用性，它有着更好的稳定性和可维护性。

二、集合元素排序

2.1 Comparable和Comparator

Comparable出自java.lang包，有个compareTo(Object obj) 方法用来排序。
Comparator出自java.util包，有个compare(Object obj1, Object obj2)方法用来排序。
一般需要对一个集合使用自定义排序时，就要重写 compareTo() 方法或 compare()方法。

2.1.1 Comparable

Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点：这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话，那么这个对象必须实现Comparable接口。compareTo方法的返回值是int，有三种情况：

1、比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数
2、比较者等于被比较者，那么返回0
3、比较者小于被比较者，那么返回负整数

Comparable接口使用示例：

//实体类
public class Person implements Comparable<Person> {private String name;private int age;public Person(String name, int age) {super();this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}//重写compareTo方法实现按年龄来排序@Overridepublic int compareTo(Person o) {if (this.age > o.getAge()) {return 1;}if (this.age < o.getAge()) {return -1;}return 0;}
}

测试类：

    public static void main(String[] args) throws InterruptedException {TreeMap<Person, String> pdata = new TreeMap<Person, String>();pdata.put(new Person("张三", 30), "zhangsan");pdata.put(new Person("李四", 20), "lisi");pdata.put(new Person("王五", 10), "wangwu");pdata.put(new Person("赵六", 5), "xiaohong");// 得到key的值的同时得到key所对应的值Set<Person> keys = pdata.keySet();for (Person key : keys) {System.out.println(key.getAge() + "-" + key.getName());}}

结果：

5-赵六
10-王五
20-李四
30-张三

2.1.2 Comparator

Comparator可以认为是一个外比较器，有两种情况可以使用实现Comparator接口的方式：

一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较。

一个对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式。

Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：

1、o1大于o2，返回正整数
2、o1等于o2，返回0
3、o1小于o3，返回负整数

示例：

     ArrayList<Integer> arrayList = new ArrayList<Integer>();arrayList.add(-1);arrayList.add(3);arrayList.add(3);arrayList.add(-5);arrayList.add(7);arrayList.add(4);arrayList.add(-9);arrayList.add(-7);System.out.println("原始数组:");System.out.println(arrayList);Collections.sort(arrayList);System.out.println("原始排序:");System.out.println(arrayList);// 定制排序Collections.sort(arrayList, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2.compareTo(o1);}});System.out.println("定制排序：");System.out.println(arrayList);

结果：

原始数组:
[-1, 3, 3, -5, 7, 4, -9, -7]
原始排序:
[-9, -7, -5, -1, 3, 3, 4, 7]
定制排序：
[7, 4, 3, 3, -1, -5, -7, -9]

2.1.3 比较

Comparable和Comparator接口都可以用来实现集合中元素的比较、排序，Comparator位于包java.util下，而Comparable位于包java.lang下，Comparable接口将比较代码嵌入自身类中，而后者在一个独立的类中实现比较。
像Integer、String等这些基本类型的Java封装类都已经实现了Comparable接口，这些类对象本身就支持自比较，直接调用Collections.sort()就可以对集合中元素的排序，无需自己去实现Comparable接口。
而有些自定义类的List序列，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较，也就是指定使用Comparator（临时规则排序，也称作专门规则排序），如果不指定Comparator，那么就用自然规则排序，这里的自然顺序就是实现Comparable接口设定的排序方式。

Comparable和Comparator的区别：

参数	Comparable	Comparator
排序逻辑	排序逻辑必须在待排序对象的类中，所以称为自然排序	排序逻辑在另一个类中实现
实现接口	实现Comparable接口	实现Comparator接口
排序方法	int compareTo(Object o1)	int compare(Object o1,Object o2)
触发排序方式	Collections.sort(List)	Collect.sort(List.Comparator)
接口所在包	java.lang	java.util

总结一下，两种比较器Comparable和Comparator，后者相比前者有如下优点：

1、如果实现类没有实现Comparable接口，又想对两个类进行比较（或者实现类实现了Comparable接口，但是对compareTo方法内的比较算法不满意），那么可以实现Comparator接口，自定义一个比较器，写比较算法
2、实现Comparable接口的方式比实现Comparator接口的耦合性要强一些，如果要修改比较算法，则需要修改Comparable接口的实现类，而实现Comparator的类是在外部进行比较的，不需要对实现类有任何修改。从这个角度说，实现Comparable接口的方式其实有些不太好，尤其在我们将实现类的.class文件打成一个.jar文件提供给开发者使用的时候。实际上实现Comparator 接口的方式后面会写到就是一种典型的策略模式。

2.2 TreeMap和TreeSet在排序时如何比较元素？Collections工具类中的sort方法如何比较元素？

TreeSet要求存放的对象所属的类必须实现Comparable接口，该接口提供了比较元素的compareTo()方法，当插入元素时会回调该方法比较元素的大小。TreeMap 要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。
Collections工具类的 sort 方法有两种重载的形式：
1>第一种要求传入的待排序容器中存放的对象比较实现 Comparable 接口以实现元素的比较；
2>第二种不强制性的要求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator接口的子类型（需要重写compare方法实现元素的比较），相当于一个临时定义的排序规则，其实就是通过接口注入比较元素大小的算法，也是对回调模式的应用（Java中对函数式编程的支持）。

2.3 如何对一组对象进行排序？

如果需要对一个对象数组进行排序，可以使用Arrays.sort()方法。如果需要排序一个对象列表，可以使用Collection.sort()方法。两个类都有用于自然排序（使用Comparable）或基于标准的排序（使用Comparator）的重载方法sort()。Collections内部使用数组排序方法，所有它们两者都有相同的性能，只是Collections需要花时间将列表转换为数组。

三、Collections常用方法

Collections工具类常用方法：

排序；
查找、替换操作；
同步控制(不推荐，需要线程安全的集合类型时请考虑使用JUC包下的并发集合)。

3.1 排序方法

 //反转void reverse(List list)//随机排序void shuffle(List list)//按自然排序的升序排序void sort(List list)//定制排序，由Comparator控制排序逻辑void sort(List list, Comparator c)//交换两个索引位置的元素void swap(List list, int i , int j)

在JDK1.6中，Arrays.sort()和Collections.sort()使用的是MergeSort。在JDK1.7中，Collections.sort()的内部实现换成了TimeSort。
Collections.sort()方法有两种重载的形式，第一种要求传入的待排序容器中存放的对象比较实现Comparable接口以实现元素的比较；第二种不强制性的要求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator接口的子类型（需要重写compare方法实现元素的比较），相当于一个临时定义的排序规则，其实就是通过接口注入比较元素大小的算法。

3.2 查找替换方法

 //对List进行二分查找，返回索引，List必须是有序的int binarySearch(List list, Object key)//根据元素的自然顺序，返回最大的元素int max(Collection coll)//根据定制排序，返回最大元素，排序规则由Comparatator类控制int max(Collection coll, Comparator c)//用指定的元素代替指定list中的所有元素void fill(List list, Object obj)//统计元素出现次数int frequency(Collection c, Object o)//统计target在list中第一次出现的索引，找不到则返回-1int indexOfSubList(List list, List target)//用新元素替换旧元素boolean replaceAll(List list, Object oldVal, Object newVal)

3.3 同步控制方法

Collections提供了多个synchronizedXxx()方法，该方法可以将指定集合（比如：HashSet、TreeSet、ArrayList、LinkedList、HashMap、TreeMap等）包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。
不过最好不要用下面这些方法，因为效率低，需要线程安全的集合类型时请考虑使用JUC包下的并发集合。

 //返回指定Collection支持的线程安全的CollectionsynchronizedCollection(Collection<T> c) //返回指定List支持的线程安全的ListsynchronizedList(List<T> list)//返回由指定Map支持的线程安全的MapsynchronizedMap(Map<K,V> m)//返回指定Set支持的线程安全的setsynchronizedSet(Set<T> s)