Java 集合框架可以分为两条大的支线：
①、Collection，主要由 List、Set、Queue 组成：
- List 代表有序、可重复的集合，典型代表就是封装了动态数组的 ArrayList 和封装了链表的 LinkedList；
- Set 代表无序、不可重复的集合，典型代表就是 HashSet 和 TreeSet；
- Queue 代表队列，典型代表就是双端队列 ArrayDeque，以及优先级队列 PriorityQueue。
②、Map，代表键值对的集合，典型代表就是HashMap
一、List
List 的特点是存取有序，可以存放重复的元素，可以用下标对元素进行操作。
（1）ArrayList
先来一段 ArrayList 的增删改查，学会用。
java
// 创建一个集合
ArrayList<String> list = new ArrayList<String>();
// 添加元素
list. Add("aa");
list. Add("bb");
list. Add("ccc");
// 遍历集合 for 循环
for (int i = 0; i < list.size(); i++) {
String s = list. Get(i);
System.out.println(s);
}
// 遍历集合 for each
for (String s : list) {
System.out.println(s);
}
// 删除元素
list.remove(1);
// 遍历集合
for (String s : list) {
System.out.println(s);
}
// 修改元素
list. Set(1, "aaa");
// 遍历集合
for (String s : list) {
System.out.println(s);
}简单介绍一下 ArrayList 的特征
- ArrayList 是由数组实现的，支持随机存取，也就是可以通过下标直接存取元素；
- 从尾部插入和删除元素会比较快捷，从中间插入和删除元素会比较低效，因为涉及到数组元素的复制和移动；
- 如果内部数组的容量不足时会自动扩容，因此当元素非常庞大的时候，效率会比较低。
(2) LinkedList
同样先来一段 LinkedList 的增删改查，和 ArrayList 几乎没什么差别。
java
// 创建一个集合
LinkedList<String> list = new LinkedList<String>();
// 添加元素
list. Add("aa");
list. Add("bb");
list. Add("ccc");
// 遍历集合 for 循环
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
// 遍历集合 for each
for (String s : list) {
System.out.println(s);
}
// 删除元素
list.remove(1);
// 遍历集合
for (String s : list) {
System.out.println(s);
}
// 修改元素
list. Set(1, "aaa");
// 遍历集合
for (String s : list) {
System.out.println(s);
}不过，LinkedList 和 ArrayList 仍然有较大的不同
- LinkedList 是由双向链表实现的，不支持随机存取，只能从一端开始遍历，直到找到需要的元素后返回；
- 任意位置插入和删除元素都很方便，因为只需要改变前一个节点和后一个节点的引用即可，不像 ArrayList 那样需要复制和移动数组元素；
- 因为每个元素都存储了前一个和后一个节点的引用，所以相对来说，占用的内存空间会比 ArrayList 多一些。
(3) Vector 和 Stack
List 的实现类还有一个 Vector，是一个元老级的类，比 ArrayList 出现得更早。ArrayList 和 Vector 非常相似，只不过 Vector 是线程安全的，像 get、set、add 这些方法都加了 synchronized 关键字，就导致执行效率会比较低，所以现在已经很少用了。
看一下 add 方法的源码
java
public synchronized boolean add(E e) {
elementData[elementCount++] = e;
return true;
}这种加了同步方法的类，注定会被淘汰掉，就像StringBuilder 取代 StringBuffer那样。JDK 源码也说了：
如果不需要线程安全，建议使用 ArrayList 代替 Vector。
Stack 是 Vector 的一个子类，本质上也是由动态数组实现的，只不过还实现了先进后出的功能（在 get、set、add 方法的基础上追加了 pop「返回并移除栈顶的元素」、peek「只返回栈顶元素」等方法），所以叫栈。
下面是这两个方法的源码，增删改查我就不写了，和 ArrayList 和 LinkedList 几乎一样。
java
public synchronized E pop() {
E obj;
int len = size();
obj = peek();
removeElementAt(len - 1);
return obj;
}
public synchronized E peek() {
int len = size();
if (len == 0)
throw new EmptyStackException();
return elementAt(len - 1);
}不过，由于 Stack 执行效率比较低（方法上同样加了 synchronized 关键字），就被双端队列 ArrayDeque 取代了.
二、Set
Set 的特点是存取无序，不可以存放重复的元素，不可以用下标对元素进行操作，和 List 有很多不同。
（1）HashSet
HashSet 其实是由 HashMap 实现的，只不过值由一个固定的 Object 对象填充，而键用于操作。来简单看一下它的源码。
java
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
{
private transient HashMap<E,Object> map;
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
public HashSet() {
map = new HashMap<>();
}
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
}实际开发中，HashSet 并不常用，比如，如果我们需要按照顺序存储一组元素，那么 ArrayList 和 LinkedList 可能更适合；如果我们需要存储键值对并根据键进行查找，那么 HashMap 可能更适合。
来一段增删改查体验一下：
java
// 创建一个新的HashSet
HashSet<String> set = new HashSet<>();
// 添加元素
set. Add("aa");
set. Add("bb");
set. Add("ccc");
// 输出HashSet的元素个数
System.out.println("HashSet size: " + set.size()); // output: 3
// 判断元素是否存在于HashSet中
boolean containsWanger = set. Contains("bb");
System.out.println("Does set contain 'bb'? " + containsWanger); // output: true
// 删除元素
boolean removeWanger = set. Remove("bb");
System.out.println("Removed 'bb'? " + removeWanger); // output: true
// 修改元素，需要先删除后添加
Boolean removeChenmo = set. Remove("aa");
Boolean addBuChenmo = set. Add("aaa");
System.out.println("Modified set? " + (removeChenmo && addBuChenmo)); // output: true
// 输出修改后的HashSet
System.out.println("HashSet after modification: " + set); // output: [ccc, aaa]HashSet 主要用于去重，比如，我们需要统计一篇文章中有多少个不重复的单词，就可以使用 HashSet 来实现。
java
// 创建一个 HashSet 对象
HashSet<String> set = new HashSet<>();
// 添加元素
set. Add("aa");
set. Add("bb");
set. Add("ccc");
set. Add("aa");
// 输出 HashSet 的元素个数
System.out.println("HashSet size: " + set.size()); // output: 3
// 遍历 HashSet
for (String s : set) {
System.out.println(s);
}从上面的例子可以看得出，HashSet 会自动去重，因为它是用 HashMap 实现的，HashMap 的键是唯一的（哈希值），相同键的值会覆盖掉原来的值，于是第二次 set.add("沉默") 的时候就覆盖了第一次的 set.add("aa")。
(2)LinkedHashSet
LinkedHashSet 虽然继承自 HashSet，其实是由 LinkedHashMap 实现的。
这是 LinkedHashSet 的无参构造方法：
java
public LinkedHashSet() {
super(16, .75f, true);
}super 的意思是它将调用父类的 HashSet 的一个有参构造方法：
java
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}LinkedHashSet 的增删改查
java
LinkedHashSet<String> set = new LinkedHashSet<>();
// 添加元素
set. Add("aa");
set. Add("bb");
set. Add("ccc");
// 删除元素
set. Remove("bb");
// 修改元素
set. Remove("aa");
set. Add("aaaaa");
// 查找元素
Boolean hasChenQingYang = set. Contains("ccc");
System.out.println("set包含ccc吗？" + hasccc);在以上代码中，我们首先创建了一个 LinkedHashSet 对象，然后使用 add 方法依次添加了三个元素：aa、bb和ccc。接着，我们使用 remove 方法删除了bb这个元素，并使用 remove 和 add 方法修改了aa这个元素。最后，我们使用 contains 方法查找了ccc这个元素是否存在于 set 中，并打印了结果。
LinkedHashSet 是一种基于哈希表实现的 Set 接口，它继承自 HashSet，并且使用链表维护了元素的插入顺序。因此，它既具有 HashSet 的快速查找、插入和删除操作的优点，又可以维护元素的插入顺序。
(3)TreeSet
与 TreeMap 相似，TreeSet 是一种基于红黑树实现的有序集合，它实现了 SortedSet 接口，可以自动对集合中的元素进行排序。按照键的自然顺序或指定的比较器顺序进行排序。
java
// 创建一个 TreeSet 对象
TreeSet<String> set = new TreeSet<>();
// 添加元素
set. Add("aa");
set. Add("bb");
set. Add("ccc");
System.out.println(set); // 输出 [aa, bb, ccc]
// 删除元素
set. Remove("bb");
System.out.println(set); // 输出 [aa, ccc]
// 修改元素：TreeSet 中的元素不支持直接修改，需要先删除再添加
set. Remove("ccc");
set. Add("cbc");
System.out.println(set); // 输出 [aa, cbc]
// 查找元素
System.out.println(set. Contains("aa")); // 输出 true
System.out.println(set. Contains("bb")); // 输出 false需要注意的是，TreeSet 不允许插入 null 元素，否则会抛出 NullPointerException 异常。
总体上来说，Set 集合不是关注的重点，因为底层都是由 Map 实现的，为什么要用 Map 实现呢？
因为 Map 的键不允许重复、无序.