文章目录

基本概念
Collection 接口
Map 接口
附：Iterator 接口（不是容器，，用于遍历）
- - - foreach 循环迭代
附：Collections 类

基本概念

在编程时，可以用数组来保存多个对象，但数组的长度不可变化，一旦在初始化数组时指定了数组长度，这个数组长度就是不可改变的；除此之外，数组无法保存具有映射关系的对象。
为了保存数量不确定的数据，以及保存具有映射关系的数据（也称关联数组），Java提供了容器类。Java容器类的用途是保存对象（实际上只是保存对象的引用变量，但通常习惯上认为容器里保存的是对象），其主要由以下两个接口派生而出：Collection 和 Map 。

Collection 接口

一个独立元素的序列，这些元素都服从一条或者多条规则。其继承树如下图所示：
Collection继承树
说明：

List 容器必须按照插入的顺序保存元素，容器中的元素可以重复。
Set 容器中不能有重复的元素，容器中的元素是无序的。
Queue 容器按照排队规则来确定对象产生的顺序

Collection 接口中操作容器中元素的方法

boolean add(Object o)：向容器中添加一个元素。如果容器中的对象被添加操作改变了，则返回 true。
boolean addAll(Collection c)：把容器c 里的所有元素添加到指定容器里。如果容器中的对象被添加操作改变了，则返回 true。
void clear()：清除容器里的所有元素，将容器长度变为 0。
boolean contains(Object o)：返回容器里是否包含该元素。
boolean containsAll(Collection c)：返回容器里是否包含 c 容器中的所有元素。
boolean isEmpty()：返回容器是否为空。当容器长度为0时返回 true，否则返回 false。
Iterator iterator()：返回一个 Iterator 对象，用于遍历容器里的元素。
boolean remove(Object o)：删除容器中的指定元素 o，当容器中包含了一个或者多个 o 元素时，该方法只删除第一个符合条件的元素。删除成功时返回 true。
boolean removeAll(Collection c)：从容器中删除容器 c 里不包含的元素（相当于把调用该方法的容器内容变成该容器的内容与 c 容器中的内容的交集），如果该操作改变了调用该方法的容器，则返回 true。
int size()：返回容器中的元素的个数。
Object[] toArray()：把容器转换成一个数组，容器中的所有对象变成对应的数组元素。

List 接口

List 是 Collection 接口的子接口，可以使用 Collection 接口中的所有方法，此外，List 增加了一些根据索引来操作容器的方法。

void add(int index, Object element)：将元素 element 插入到 List 容器的 index 处。
boolean addAll(int index, Collection c)：将容器 c 所包含的所有元素都插入到 List 容器的 index 处。
Object get(int index)：返回容器 index 索引处的元素。
int indexOf(Object o)：返回对象 o 在 List 容器中第一次出现的位置索引。
int lastIndexOf(Object o)：返回对象 o 在 List 容器中最后一次出现的位置索引。
Object remove(int index)：删除并返回 index 索引处的元素。
Object set(int index, Object element)：将 index 索引处的元素替换成 element 对象，返回被替换的旧元素。
List subList(int fromIndex, int toIndex)：返回从索引 fromIndex （包含）到索引 toIndex （不包含）处所有容器元素组成的子集合。
void replaceAll(UnaryOperator operator)：根据 operator 指定的计算规则重新设置 List 容器的所有元素。
void sort(Comparator c)：根据 Comparator 参数对 List 容器的元素排序。

ArrayList 类与 Vector 类的比较

名称	默认扩容方式	线程是否安全	速度	有效个数的属性
ArrayList	增长50%	线程不安全	快	size
Vector	增长一倍	线程安全	慢	elementCount
共同点	数组长度不够时会自动扩容	-	remove，add 方法都会导致数组内部的数据拷贝操作，效率较低	-

ArrayList 类与 LinkedList 类的比较

名称	底层数据结构	线程是否安全	插入和删除效率	是否支持快速随机访问	内存空间占用
ArrayList	数组	线程不安全	插入和删除元素的时间复杂度受元素位置的影响	支持	空间浪费主要体现在在list列表的结尾会预留一定的容量空间
LinkedList	双向链表	线程不安全	删除元素时间复杂度不受元素位置的影响，都是近似 O（1）	不支持	空间花费体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）

Set 接口

Set 容器与 Collection 容器基本相同，没有提供任何额外的方法，只是在行为上有所区别：Set 容器不允许包含相同的元素，如果试图把两个相同的元素加入同一个 Set 容器中，则添加操作失败，add 方法返回 false，新元素加入失败。

HashSet 类

HashSet是Set接口的典型实现，HashSet使用HASH算法来存储容器中的元素，因此具有良好的存取和查找性能。其具有以下特点：

不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也可能发生变化。
线程不安全
容器中的元素值可以是 null。

当向 HashSet 容器中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据该 HashCode值决定该对象在 HashSet 中的存储位置。如果有两个元素通过 equals() 方法比较返回 true，但它们的 hashCode() 方法返回值不相等，HashSet 会把它们储存在不同的位置，但是依然可以添加成功。
因此，HashSet 容器判断两个元素相等的标准是两个对象通过 equals() 方法比较相等，并且两个对象的 hashCode() 方法的返回值相等。

LinkedHashSet 类

LinkedHashSet 是 HashSet 的子类，它也是根据元素的 hashCode 值来决定元素的存储位置，但和 HashSet 不同的是，它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。因此，当遍历 LinkedHashSet 容器里的元素时，LinkedHashSet 将会按元素的添加顺序来访问容器里的元素。
LinkedHashSet 需要维护元素的插入顺序，因此性能略低于 HashSet 的性能，但在迭代访问容器里的全部元素时将有很好的性能，因为其底层数据结构是链表。

SortedSet 接口

此接口主要用于排序操作，实现了此接口的子类都属于排序的子类

TreeSet 类

TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保容器中的元素处于排序状态。其新增的方法如下：

Comparator comparator()：如果该 TreeSet 采用了定制排序，则返回所使用的的 Comparator；如果采用自然排序，则返回 null。
Object first()：返回容器中的第一个元素。
Object last()：返回容器中的最后一个元素。
Object lower(Object e)：返回容器中小于指定元素的最大元素（指定元素不需要是 TreeSet 容器中的元素）。
Object higher(Object e)：返回容器中大于指定元素的最小元素（指定元素不需要是 TreeSet 容器中的元素）。
SortedSet subSet(Object fromElement, Object toElement)：返回 Set 的子集，范围从 fromElement（包含）到 toElement（不包含）。
SortedSet headSet(Object toElement)返回 Set 的子集，有小于或等于 toElement 的元素组成。
SortedSet tailSet(Object fromElement)：返回 Set 的子集，有大于或等于 fromElement 的元素组成。

TreeSet 的排序方式：

自然排序：调用容器中元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将元素按照升序排序。自然排序容器中的元素必须是实现 Comparable 接口的，因此可以通过 Comparable 接口中的 compareTo 方法来比较大小。
定制排序：需要在创建 TreeSet 容器对象时，提供一个 Comparator 对象与该 TreeSet 容器关联，由该 Comparator 对象负责容器元素的排序逻辑。

EnumSet 类

EnumSet 是一个专门为枚举类设计的容器类，EnumSet 中所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建 EnumSet 时显式、或隐式地指定。EnumSet 的容器元素也是有序的，以枚举值在 Enum 类内的定义顺序来决定容器元素的顺序。
EnumSet 类提供的用来创建 EnumSet 对象的方法如下：

EnumSet allOf(Class elementType)：创建一个包含指定枚举类里所有枚举值的 EnumSet 容器。
EnumSet complementOf(EnumSet s)：创建一个其元素类型与指定 EnumSet 里元素类型相同的 EnumSet 容器，新 EnumSet 容器包含原 EnumSet 容器所不包含的、此枚举类剩下的枚举值（即两个容器中的元素加起来就是该枚举类的所有枚举值）。
EnumSet copyOf(Collection c)：使用一个普通容器来创建一个 EnumSet 容器。
EnumSet copyOf(EnumSet s)：创建一个与指定 EnumSet 具有相同元素类型、相同容器元素的 EnumSet 容器。
EnumSet noneOf(Class elementType)：创建一个元素类型为指定枚举类型的空 EnumSet。
EnumSet of(E first, E… rest)：创建一个包含一个或多个枚举值的 EnumSet 容器，传入的多个枚举值必须属于同一个枚举类。
EnumSet range(E from, E to)：创建一个包含从 from 枚举值到 to 枚举值范围内所有枚举值的 EnumSet 容器。

各个 Set 之间的比较

HashSet 与 TreeSet：HashSet 的性能比 TreeSet 的性能好，因为 TreeSet 需要通过红黑树算法来维护容器中元素的顺序，因此只有在需要保持排序时才使用 TreeSet。
HashSet 与 LinkedHashSet：对于普通的插入、删除操作，LinkedHashSet 比 HashSet 要慢一点，这是由维护链表所带来的的额外开销造成的，但也因为有链表的存在，LinkedHashSet 在遍历时速度更快。
EnumSet 是所有 Set 实现类中性能最好的。
EnumSet、HashSet 与 TreeSet 都是线程不安全的。

Queue 接口

此接口用于模拟队列这种数据结构（FIFO）。新插入的元素放在队尾，队头存放着保存时间最长的元素。通常队列不允许随机访问队列中的元素。Queue 接口中定义的新方法如下：

void add(Object e)：将指定元素加入此队列的尾部。
Object element()：获取队列头部的元素，但是不删除该元素。
boolean offer(Object e)：将指定元素加入此队列的尾部。当使用有容量限制的队列时，此方法通常比 add 方法更好。
Object peek()：获取队列头部的元素，并删除该元素。如果此队列为空，返回 null。
Object poll()：获取队列头部的元素，并删除该元素。如果此队列为空，则返回 null。
Object remove()：获取队列头部的元素，并删除该元素。

PriorityQueue 类

PriorityQueue 并不是按照加入队列的顺序来排列元素，而是按照队列元素的大小进行重新排序。PriorityQueue 对队列的排序方式也有自然排序和定制排序两种，其要求与 TreeSet 容器对元素的要求一致。

Deque 接口（双端队列）

Deque 接口里定义了一些双端队列的方法，这些方法允许从两端来操作队列的元素。

void addFirst(Object e) ：将指定元素插入改双端队列的开头。
void addLast(Object e)：将指定元素插入该双端队列的末尾。
Iterator descendingIterator()：返回该双端队列对应的迭代器，该迭代器将以逆向顺序来迭代队列中的元素。
Object getFirst()：获取但不删除双端队列的第一个元素。
Object getLast()：获取但不删除双端队列的最后一个元素。
boolean offerFirst(Object e)：将指定元素插入该双端队列的开头。
boolean offerLast(Object e)：将指定元素插入该双端队列的末尾。
Object peekFirst()：获取但不删除双端队列的第一个元素。若此双端队列为空，则返回null。
Object peekLast()：获取但不删除双端队列的最后一个元素。若此双端队列为空，则返回null。
Object pollFirst()：获取并删除双端队列的第一个元素。若此双端队列为空，则返回null。
Object pollLast()：获取并删除双端队列的最后一个元素。若此双端队列为空，则返回null。
Object pop()：pop出该双端队列所表示的栈的栈顶元素。相当于 removeFirst()。
void push(Object e)：将一个元素 push 进该双端队列所表示的栈的栈顶。相当于addFirst(e)。
Object removeFirst()：获取并删除该双端队列的第一个元素。
Object removeFirstOccurrence(Object o)：删除该双端队列的第一次出现的元素 o。
Object removeLast()：获取并删除该双端队列的最后一个元素。
boolean removeLastOccurrence(Object o)：删除该双端队列的最后一次出现的元素 o。

ArrayDeque 类

基于数组实现的双端队列，创建 Deque 的时候可以指定一个 numElements 参数，该参数用于指定 Object[] 数组的长度；如果不指定 numElements 参数，Deque 底层数组的长度为 16。

LinkedList 类

如上文所示。

Map 接口

Map 实现类用于保存具有映射关系的数据，其继承树如下：
Collection继承树
说明：

Map 容器中的数据都持有键（key）-值（value）两个对象，key 和 value 都可以是任何应用类型的数据。
Map 中的 key 不允许重复，但是 value 可以重复。
Map 中可以有多个 value 为 null，但是只能有一个 key 为 null。
key 和 value 之间存在着单向一对一的关系，即通过指定的 key，总能找到唯一的、确定的 value。

Map 接口中操作容器中元素的方法

void clear()：删除该 Map 对象中的所有 key-value 对。
boolean containsKey(Object key)：查询 Map 中是否包含指定的 key，如果包含则返回 true。
boolean containsValue(Object value)：查询 Map 中是否包含一个或者多个 value，如果包含则返回 true。
Set entrySet()：返回 Map 中包含的 key-value 对所组成的 Set 集合，每个集合元素都是 Map.Entry 对象。
Object get(Object key)：返回指定 key 所对应的 value；如果此 Map 中不包含该 key，返回 null。
boolean isEmpty()：查询该 Map 是否为空，为空则返回 null。
Set keySet()：返回该 Map 中所有 key 组成的 Set 集合。
Object put(Object key, Object value)：添加一个 key-value 对，如果该 Map 中已经有一个与该 key 相等的 key-value 对，则新的 key-value 对会覆盖原来的 key-value 对。
void putAll(Map m)：将指定 Map 中的 key-value 对复制到本 Map 中。
Object remove(Object key)：删除指定 key 所对应的 key-value 对，返回被删除的 key 所关联的 value，若 key 不存在，则返回 null。
boolean remove(Object key, Object value)：删除指定 key、value 所对应的 key-value 对。成功返回 true，失败返回 false。
int size()：返回该 Map 里所有的 key-value 对的个数。
Collection values()：返回该 Map 里所有 value 组成的 Collection。
Map 中包含了一个内部类 Entry ，该类封装了一个 key-value 对。其三个方法如下：
Object getKey()：返回该 Entry 里包含的 key 值。
Object getValue()：返回该 Entry 里包含的 value 值。
Object setValue(V value)：设置该 Entry 里包含的 value 值，并返回新设置的 value 值。

HashMap 类

和 HashSet 集合不能保证元素的顺序一样，HashMap 也不能保证 key-value 对的顺序。并且类似于 HashSet 判断两个 key 是否相等的标准一样: 两个 key 通过 equals() 方法比较返回 true、同时两个 key 的 hashCode 值也必须相等。

LinkedHashMap 类

与 LinkedHashSet 一样，LinkedHashMap 也使用双向链表来维护 key-value 对的次序（只考虑 key 的次序），该链表负责维护 Map 的迭代顺序，与 key-value 对的插入顺序保持一致。

HashTable 类

是一个古老的 Map 实现类。与 HashMap 一样不能保证 key-value 对的顺序，判断两个 key 是否相等的标准也一样。

Properties 类

Properties 对象在处理属性文件时特别方便（Windows 操作平台的上的 ini 文件就是一种属性文件）。Properties 类可以把 Map 对象和属性文件关联起来，从而把 Map 对象的 key-value 对写入到属性文件中，也可把属性文件中的“属性名-属性值”加载进 Map 对象中。（Properties 相当于一个 key、value 都是 String 类型的 Map）。其操作方法如下：

String getProperty(String key)：获取 Properties 中指定属性名对应的属性值，，类似于 Map 的 get(Object key) 方法。
String getProperty(String key, String defaultValue)：与上一个方法基本相似，不同在于此方法中，当 Properties 中不存在指定的 key 时，则该方法指定默认值。
Object setProperty(String key, String value)：设置属性值。
void load(InputStream inStream)：从属性文件（以输入流表示）中加载 key-value 对，把加载到的 key-value 对追加到 Properties 里。
void store(OutputStream out, String comments)：将 Properties 中的 key-value 对输出到指定的属性文件（以输出流表示）中。

SortedMap 接口

与 SortedSet 接口类似。

TreeMap 类

TreeMap 就是一个红黑树结构，每个 key-value 对即作为红黑树的一个节点。TreeMap 存储 key-value 对时，需要根据 key 对节点进行排序，TreeMap 可以保证所有的 key-value 对处于有序状态。排序方式也有自然排序和定制排序两种。其新增的操作方法如下：

Map.Entry firstEntry()：返回该 Map 中最小 key 所对应的 key-value 对，如果该 Map 为空，则返回 null。
Object firstKey()：返回该 Map 中最小 key 值，如果该 Map 为空，则返回 null。
Map.Entry lastEntry()：返回该 Map 中最大 key 所对应的 key-value 对，如果该 Map 为空或不存在这样的 key-value 对，则返回 null。
Object lastKey()：返回该 Map 中最大 key 值，如果该 Map 为空或不存在这样的 key-value 对，则返回 null。
Map.Entry higherEntry(Object key)：返回该 Map 中位于 key 后一位的 key-value 对（由于 TreeMap 为有序结构，即返回大于指定 key 的最小 key 所对应的 key-value 对）。如果该 Map 为空，则返回 null。
Object higherKey(Object key)：返回该 Map 中位于 key 后一位的 key 值（即大于指定 key 的最小 key 值）。如果该 Map 为空或者不存在这样的 key-value 对，则返回 null。
Map.Entry lowerEntry(Object key)：返回该 Map 中位于 key 前一位的 key-value 对（由于 TreeMap 为有序结构，即返回小于指定 key 的最大 key 所对应的 key-value 对）。如果该 Map 为空或者不存在这样的 key-value 对，则返回 null。
Object lowerKey(Object key)：返回该 Map 中位于 key 前一位的 key 值（即小于指定 key 的最大 key 值）。如果该 Map 为空不存在这样的 key-value 对，则返回 null。
NavigableMap subMap(Object fromKey, boolean fromInclusive, Object toKey, noolean to Inclusive)：返回该 Map 的子 Map，其 key 的范围是从 fromKey（是否包括取决于第二个参数）到 toKey（是否包括取决于第四个参数）。
SortedMap subMap(Object fromKey, Object toKey)：返回该 Map 的子 Map，其 key 的范围是从 fromKey（包括）到 toKey（不包括）。
SortedMap tailMap(Object fromKey)：返回该 Map 的子 Map，其 key 的范围是大于 fromKey（包括）的所有 key。
NavigableMap tailMap(Object fromKey, boolean fromInclusive)：返回该 Map 的子 Map，其 key 的范围是从 fromKey（是否包括取决于第二个参数）的所有 key。
SortedMap headMap(Object toKey)：返回该 Map 的子 Map，其 key 的范围是小于 toKey（不包括）的所有 key。
NavigableMap headMap(Object toKey, boolean inclusive)：返回该 Map 的子 Map，其 key 的范围小于 toKey（是否包括取决于第二个参数）的所有 key。

WeakHashMap 类

与 HashMap 的用法基本相同。与 HashMap 的区别如下：

HashMap 的 key 保留了对实际对象的强引用，这意味着只要该 HashMap 对象不被销毁，该 HashMap 的所有 key 所引用的对象就不会被垃圾回收，HashMap 也不会自动删除这些 key 所对应的 key-value 对。
WeakHashMap 的 key 只保留了对实际对象的弱引用，这意味着如果 WeakHashMap 对象的 key 所引用的对象没有被其他强引用变量所引用，则这些 key 所引用的对象可能被垃圾回收，WeakHashMap 也可能自动删除这些 key 所对应的 key-value 对。（当垃圾回收了该 key 所对应的实际对象之后，WeakHashMap 会自动删除这些 key 所对应的 key-value 对。）

IdentityHashMap 类

这个类的实现机制和 HashMap 基本相似：

都允许使用 null 作为 key 和 value
两者都不保证 key-value 对之间的顺序，更不能保证它们的顺序随时间推移保持不变。
两者的区别如下：
在 IdentityHashMap 中，当且仅当两个 key 严格相等 (key1 == key2) 时，IdentityHashMap 才认为两个 key 相等。
在 HashMap 中，只要 key1 和 key2 通过 equals() 方法比较返回 true，且它们的 hashCode 值相等即可。

EnumMap 类

EnumMap 是一个与枚举类一起使用的 Map 实现，EnumMap 中的所有 key 都必须是单个枚举类的枚举值。创建 EnumMap 时必须显式或隐式指定它对应的枚举类。其特征如下：

EnumMap 在内部以数组的形式保存。
EnumMap 根据 key 的自然顺序存储。
EnumMap 不允许使用 null 作为 key，但允许使用 null 作为 value。

各个 Map 实现类的性能分析

HashMap 与 Hashtable：两者的实现机制几乎一样，但 Hashtable 是一个古老的、线程安全的容器，因此速度通常比 HashMap 慢。
TreeMap 与 HashMap、Hashtable：因为 TreeMap 要维护红黑树结构，因此速度比较慢，但是该容器中 key-value 对总是处于有序状态。
LinkedHashMap 与 HashMap：LinkedHashMap 需要用链表来保持 key-value 对的插入顺序，因此速度比 HashMap 慢。
EnumMap 的性能最好，但是只能使用同一个枚举类的枚举值作为 key。

HashMap 与 Hashtable 的比较

继承的父类不同：Hashtable 继承自 Dictionary 类，而 HashMap 继承自 AbstractMap 类。但二者都实现了 Map 接口。
线程安全性不同：Hashtable 中的方法是线程安全的，而 HashMap 中的方法是线程不安全的。
是否提供 contains 方法：HashMap 把 Hashtable 的 contains 方法去掉了，改成 containsValue 和 containsKey；Hashtable 则保留了 contains，containsValue 和 containsKey 三个方法，其中 contains 和 containsValue 功能相同。
key 和 value 是否允许 null 值：Hashtable 中，key 和 value 都不允许出现 null 值；HashMap 中，null 可以作为 key，这样的 key 只有一个，可以有一个或多个 value 的值为 null。
内部实现使用的数组初始化和扩容方式不同：HashTable 中 hash 数组默认大小是11，增加的方式是 old*2+1。HashMap 中 hash 数组的默认大小是16，扩容时变为原来的两倍。、

附：Iterator 接口（不是容器，，用于遍历）

该接口主要用于遍历 Collection 容器中的元素，Iterator 对象页称为迭代器，其定义的方法如下：

boolean hasNext()：如果被迭代的容器中的元素还没有被遍历完，则返回 true。
Object next()：返回集合里的下一个元素。
void remove()：删除集合里上一次 next 方法返回的元素。
void forEachRemaining(Consumer action)：使用 Lambda 表达式来遍历。

说明：Iterator 对象必须依附于 Collection 对象，若有一个 Iterator 对象，则必有一个与之关联的 Collection 对象。

foreach 循环迭代

可以使用 foreach 循环像 Iterator 一样来实现遍历。

for (Object obj : 容器对象){
    
    
	...
}

附：Collections 类

操作容器的工具类，提供了大量方法对容器中元素进行排序、查询和修改等操作。

常用的排序List集合元素的方法如下：

void reverse(List list)：反转容器中的元素顺序。
void shuffle(List list)：对容器中的元素进行随机排序。
void sort(List list)：根据元素的自然元素对容器中的元素进行升序排序。
void sort(List list, Comparator c)：根据指定的 Comparator 产生的顺序对 List 容器的元素进行排序。
void swap(List list, int i, int j)：将制定 List 容器中的 i 处元素与 j 处元素进行交换。
void rotate(List list, int distance)：当 distance 为正数时，将 list 容器的后 distance 个元素移到前面；当 distance 为负数时，将 list 容器的前 distance 个元素移到后面。该方法不改变容器的长度。

查找、替换操作

int binarySearch(List list, Object key)：使用二分查找获得对象在容器中的索引（容器中的元素必须已经处于有序状态）。
Object max(Collection coll)：根据元素的自然顺序，返回容器中的最大元素。
Object max(Collection coll, Comparator comp)：根据 Comparator 指定的顺序，返回给定集合中的最大元素。
Object min(Collection coll)：根据元素的自然顺序，返回容器中的最小元素。
Object min(Collection coll, Comparator comp)：根据 Comparator 指定的顺序，返回给定集合中的最小元素。
void fill(List list, Object obj)：使用指定元素 obj 替换容器中的所有元素。
int frequency(Collection c, Object o)：返回元素在容器中出现的次数。
int indexOfSubList(List source, List target)：返回子 List 在父 List 中第一次出现的位置索引。若父 List 中没有该子 List，返回 -1。
int lastIndexOfSubList(List source, List target)：返回子 List 在父 List 中最后一次出现的位置索引。若父 List 中没有该子 List，返回 -1。
boolean replaceAll(List list, Object oldVal, Object newVal)：使用一个新值 newVal 替换 List 中的所有旧值 oldVal。

同步控制

使用 synchronizedXxx 方法将 HashSet、TreeSet、ArrayList、ArrayDeque、LinkedList、HashMap 和 TreeMap 包装成线程安全的。示例如下：

Collection c = Collections.synchronizedCollection(new ArrayList());
List list = Collections.synchronizedList(new ArrayList());
Set s = Collections.synchronizedSet(new HashSet());

设置不可变（只可访问不可修改）集合

emptyXxx()：返回一个空的、不可变的容器对象，此处的容器可以是 List、Set、SortedSet、Map 和 SortedMap 等。
singletonXxx()：返回一个只包含指定对象的、不可变的集合对象，此处的容器既可以是 List，也可以是 Map。
unmodifiableXxx()：返回指定集合对象的不可变视图，此处的容器可以是 List、Set、SortedSet、Map 和 SortedMap 等。

Java基础知识总结——容器