概述
集合是Java中比较基础的模块，所有的集合类都处于 java.util包下，其中支持多线程的集合类位于 java.util.concurrent包下，有兴趣的朋友可以去看看相关的源代码。
本文尝试以全局的角度，一窥Java集合框架的全貌；Java集合大致上可分 3 个部分，分别为： List、 Set、Map；文章会依次介绍三者各自的作用以及区别。
话不多说，Let't Go！！！
迭代器Iterator
在开始介绍具体的容器之前，让我们先来看看迭代器为何物。迭代器提供了一种遍历容器中元素的方式，也即是说：我们可以通过迭代器来遍历集合元素。Iterator迭代器接口定义了迭代器所应该具有的功能，具体源码如下：
public interface Iterator<E> {
/**
* 判断集合是否还有下一个元素
* @return boolean
*/
boolean hasNext();
/**
* 获取下一个元素
* @return E
*/
E next();
/**
* Java8 提供的默认方法
* 迭代的过程中不允许移除元素,会抛出操作不支持异常
* @throws UnsupportedOperationException
*/
default void remove() {
throw new UnsupportedOperationException("remove");
}
/**
* Java8 提供的默认方法
*/
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
复制代码迭代器 Iterator接口定义了迭代器应具备的功能，其中 hasNext()和 next()方法由具体的容器来实现，迭代器只能通过容器本身得到，每个容器都通过内部类实现了自己的迭代器，因此迭代器的使用方式如下：
@Test
public void test(){
List<Integer> list = new ArrayList<>(6);
for (int i = 0; i < 6; i++) {
list.add(i);
}
// 迭代器只能通过容器本身得到 （PS：可能有些容器会实现一些迭代器的子接口，诸如ListIterator，只是一些优化）
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
复制代码Collection
Collection是一个接口，它是一个高度抽象出来的接口，定义了集合的基本操作： 添加、删除、清空、遍历、是否为空、获取大小等方法。我们来看看Collection接口的类图：
从图中我们可以看出，Collection接口主要有 2 个子分支： List和 Set，并且定义了 AbstractCollection抽象类让其他类继承，AbstractCollection实现了 Collection中的绝大部分方法；我们可以看出 AbstractList和 AbstractSet都继承于 AbstractCollection。
其次，我们看到 Collection接口依赖于 Iterator接口，（依赖关系：依赖就是一个类 A 使用到了另一个类 B，因此类 B 的变化会影响到类 A。比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖。表现在代码层面，为类 B 作为参数被类 A 在某个method方法中使用。）
Collection依赖于 Iterator，展现在源码中是 Collection接口定义了方法 Iterator<E> iterator()，用以返回集合的迭代器来遍历集合。在 List接口中，通过 listIterator()方法返回一个 ListIterator对象；ListIterator接口是 List特有的。
Collection接口的所有子类（直接子类和间接子类）都必须实现 2 种构造函数：无参构造函数 和 参数为 Collection的构造函数。带参数的构造函数可以用来转换 Collection的类型。下面是 Collection接口中定义的API(JDK1.8)：
public interface Collection<E> extends Iterable<E> {
// 迭代器 每个容器都通过内部类实现了迭代器
Iterator<E> iterator();
// 添加元素
boolean add(E e);
// 批量添加元素
boolean addAll(Collection<? extends E> c);
// 移除元素
boolean remove(Object o);
// 批量删除元素
boolean removeAll(Collection<?> c);
// 是否包含元素o
boolean contains(Object o);
// 是否包含元素集
boolean containsAll(Collection<?> c);
// 保留元素
boolean retainAll(Collection<?> c);
// 获取集合长度
int size();
// 集合是否为空
boolean isEmpty();
//转换成数组
<T> T[] toArray(T[] a);
// 清空
void clear();
// equals方法
boolean equals(Object o);
// hashCode方法
int hashCode();
// java8 默认方法 转换成数组
default <T> T[] toArray(IntFunction<T[]> generator) {
return toArray(generator.apply(0));
}
// java8 提供默认方法 满足条件移除元素
default boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
boolean removed = false;
final Iterator<E> each = iterator();
while (each.hasNext()) {
if (filter.test(each.next())) {
each.remove();
removed = true;
}
}
return removed;
}
// java8 提供的默认方法
@Override
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, 0);
}
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
}
复制代码List
List接口的定义如下：
public interface List<E> extends Collection<E> {
//...
}
复制代码从 List定义中可以看出，它继承于 Collection接口，即 List是集合的一种。List是有序的队列，可以存储重复元素，List中的每一个元素都有一个索引，第一个元素的索引值为0，往后的元素的索引值依次 + 1，List中允许有重复的元素。
让我们来看看 List集合相关的类图：
从类图中我们看到，List接口继承于 Collection接口，并且于下有一个抽象类 AbstractList以及后续的具体子类： ArrayList、LinkedList等。单纯从这一条链路 List ----> AbstractList ----> ArrayList/LinkedList来看，有一股 模板方法模式 的味道，顶层接口定义好了具体行为，抽象类提供了可复用的 算法骨架，然后具体子类根据自己的特点自定义实现相关功能。
回到 List上来，由于继承了 Collection接口，自然包含了其所有的API，但由于 List是有序集合，所以它也有自己额外的API:
从图中我们可以看出，List接口新增的API主要有：获取元素的get()、设置元素的 set()、以及符合自身有序集合的指定索引index的添加元素方法 add(int, E)、还有获取元素索引值的 indexOf相关方法等……
具体源码如下：
public interface List<E> extends Collection<E> {
// Query Operations
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
// Modification Operations
boolean add(E e);
boolean remove(Object o);
// Bulk Modification Operations
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean addAll(int index, Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
default void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
final ListIterator<E> li = this.listIterator();
while (li.hasNext()) {
li.set(operator.apply(li.next()));
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
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);
}
}
void clear();
// Comparison and hashing
boolean equals(Object o);
int hashCode();
// Positional Access Operations
E get(int index);
E set(int index, E element);
void add(int index, E element);
E remove(int index);
// Search Operations
int indexOf(Object o);
int lastIndexOf(Object o);
// List Iterators
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
List<E> subList(int fromIndex, int toIndex);
@Override
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, Spliterator.ORDERED);
}
}
复制代码AbstractList
AbstractList抽象类的定义如下：
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
//....
}
复制代码从定义中我们可以看出，AbstractList继承了 AbstractCollection抽象类，并且实现了 List接口；它实现了 List中除 get(int index)之外的大部分方法（PS：很多方法的实现细节上只是抛出了一个UnsupportedOperationException异常，有点不太理解其含义）。
从源码上来看，AbstractList主要是提供了 迭代遍历 的相关操作（通过迭代器来实现），为后续子类提供了迭代遍历上的简化。
AbstractSequentialList
AbstractSequentialList抽象类的定义如下：
public abstract class AbstractSequentialList<E> extends AbstractList<E> {
// ...
}
复制代码从其定义我们看看到它继承于 AbstractList抽象类，那它到底是做有什么实际上的用途呢？我们来看看它的API：
我们可以看到，它所重写的 API中大部分都含有参数：索引index。
AbstractSequentialList实现了本来只能 顺序访问/操作 的数据存储结构（例如：链表）的 get(int index)、 add（int index, E element)等 随机访问/操作 的方法。这句话可能有点绕，稍加解释一番：链表是一种只能顺序访问的数据存储结构，而 AbstractSequentialList抽象类对这类只能 顺序访问/操作 的数据存储结构，也提供了类数组般的随机访问/操作 的能力。其底层是基于迭代器顺序遍历（说到底还是需要遍历，只不过是它帮我们做了这一步~）来实现的。
一般情况下，对于支持随机访问的数据结构 (例如:ArrayList) 会继承 AbstractList抽象类，不支持随机访问的数据结构（例如： LinkedList）则会继承 AbstactSequentialList抽象类。但是需要注意的是： ArrayList和 LinkedList都大量重写了 AbstractList和 AbstactSequentialList的相关实现，可真是任性的小朋友呀。
前朝遗孤般的Vector和Stack
在 List的类图中，我们看到了两个被标注为遗留的类，分别是： Vector和 Stack。
这两个类是历史遗留产物，在JDK的后续发展中都有想对应的替代产物，Vector是线程安全的 List，在实际的开发中我们可以使用 CopyOnWriteArrayList来代替；Stack提供了栈功能，我们可以使用 LinkedList来代替。
另外，关于 ArrayList和 LinkedList有专门的介绍，具体参考文章：
Set
Set的定义如下:
public interface Set<E> extends Collection<E> {
// ...
}
复制代码从定义我们可以看出，Set接口继承于 Collection，也是集合的一种，它代表的是数学概念中的集合——不能有重复的元素。
通过查看源码可以看到，Set并没有像 List一般定义了自己的API；Set中的所有方法都是继承于 Collection接口。
接下来看一下集合 Set的家庭成员：
从类图中我们可以看出，Set集合家庭中，供我们使用的主要有： TreeSet、HashSet以及 LinkedHashSet这三个类。
-
TreeSet：有序的存放，线程不安全，可以对Set集合中的元素进行排序，由红黑树来实现排序，TreeSet实际上也是SortedSet接口的子类，其在方法中实现了SortedSet的所有方法，并使用comparator()方法进行排序。 -
HashSet：底层数据结构由HashMap的键来实现。不保证集合中元素的顺序，即不能保证迭代的顺序与插入的顺序一致。是线程不安全的。 -
LinkedHashSet：底层由链表实现，按照元素插入的顺序进行迭代，即迭代输出的顺序与插入的顺序保持一致。
关于这三者的详细介绍，请参考如下文章：
-
todo1:
-
todo2:
-
todo3:
Map
Map的定义如下：
public interface Map<K,V> {
// ..
}
复制代码我们可以看到，Map接口并没有继承于 Collection；Map是一种把键对象(key)和 值对象(value)进行关联的容器。对于键对象(key)来说，像 Set一样，一个Map容器中的键对象不允许重复，也即键对象key是唯一的，同时一个 键对象key只能映射一个 值对象value。对于 值对象value并没有唯一性要求，理论上可以将多个 key都映射到同一个 value之上；虽然程序不会报错，但是可能会对使用者造成困扰（到底是哪个key映射过来的呢？）
注意：由于 Map中作为 key的对象将通过计算其散列函数来确定与之对应的存放 value的位置，因此任何作为 key的对象都必须实现hashCode和 equals方法。
我们来看看 Map集合的家庭成员有哪些：
从类图中我们可以看出，Map系列集合提供的可供使用的子类有 6 个，分别为： HashMap、LinkedHashMap、 WeakHashMap、HashTable(前朝遗孤)、IdentityHashMap以及 TreeMap；而实际的开发中，使用最为频繁的为： HashMap、LinkedHashMap以及 TreeMap。
后续的文章也会针对这 3 个 Map进行源码分析。
Map作为一个集合，所提供的功能始终跳不出这几种：新增、删除、查找等……我们来瞅瞅JDK设计者为其设计了哪些具体的API吧！
public interface Map<K,V> {
// 返回集合长度
int size();
// 判断集合是否为空
boolean isEmpty();
// 是否包含指定的key
boolean containsKey(Object key);
// 是否包含指定value
boolean containsValue(Object value);
// 通过key获取对应的value
V get(Object key);
// Modification Operations
// 往集合map中添加 key和value
V put(K key, V value);
// 根据key移除键值对，并返回对应的value
V remove(Object key);
// Bulk Operations
// 批量添加key
void putAll(Map<? extends K, ? extends V> m);
// 清除集合map中的所有键值对
void clear();
// Views
// 获取key的集合
Set<K> keySet();
Collection<V> values();
Set<Map.Entry<K, V>> entrySet();
// entry是存储的键值对对象
interface Entry<K,V> {
K getKey();
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getKey().compareTo(c2.getKey());
}
public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getValue().compareTo(c2.getValue());
}
public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
}
public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
}
}
// Comparison and hashing
boolean equals(Object o);
int hashCode();
// Defaultable methods
default V getOrDefault(Object key, V defaultValue) {
V v;
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}
default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
action.accept(k, v);
}
}
default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
Objects.requireNonNull(function);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
// ise thrown from function is not a cme.
v = function.apply(k, v);
try {
entry.setValue(v);
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
}
}
default V putIfAbsent(K key, V value) {
V v = get(key);
if (v == null) {
v = put(key, value);
}
return v;
}
default boolean remove(Object key, Object value) {
Object curValue = get(key);
if (!Objects.equals(curValue, value) ||
(curValue == null && !containsKey(key))) {
return false;
}
remove(key);
return true;
}
default boolean replace(K key, V oldValue, V newValue) {
Object curValue = get(key);
if (!Objects.equals(curValue, oldValue) ||
(curValue == null && !containsKey(key))) {
return false;
}
put(key, newValue);
return true;
}
default V replace(K key, V value) {
V curValue;
if (((curValue = get(key)) != null) || containsKey(key)) {
curValue = put(key, value);
}
return curValue;
}
default V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction) {
Objects.requireNonNull(mappingFunction);
V v;
if ((v = get(key)) == null) {
V newValue;
if ((newValue = mappingFunction.apply(key)) != null) {
put(key, newValue);
return newValue;
}
}
return v;
}
default V computeIfPresent(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
V oldValue;
if ((oldValue = get(key)) != null) {
V newValue = remappingFunction.apply(key, oldValue);
if (newValue != null) {
put(key, newValue);
return newValue;
} else {
remove(key);
return null;
}
} else {
return null;
}
}
default V compute(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
V oldValue = get(key);
V newValue = remappingFunction.apply(key, oldValue);
if (newValue == null) {
// delete mapping
if (oldValue != null || containsKey(key)) {
// something to remove
remove(key);
return null;
} else {
// nothing to do. Leave things as they were.
return null;
}
} else {
// add or replace old mapping
put(key, newValue);
return newValue;
}
}
default V merge(K key, V value,
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
Objects.requireNonNull(value);
V oldValue = get(key);
V newValue = (oldValue == null) ? value :
remappingFunction.apply(oldValue, value);
if(newValue == null) {
remove(key);
} else {
put(key, newValue);
}
return newValue;
}
}
复制代码总结
本文主要以全局的角度介绍了 Java 集合的全貌，Java 集合同时又是比较基础的模块；也是面试过程中经常被问到的知识点！