Java中的集合框架是Java语言的核心部分，提供了强大的数据结构来存储和操作对象集合。集合框架位于java.util包中，主要可以分为两大类：Collection（单列集合）和Map（双列集合）。下面是对它们的总结分类：

Collection（单列集合）

1. List（列表）

   • ArrayList：基于动态数组实现，随机访问快，插入和删除慢（尤其是列表开头）。
   • LinkedList：基于双向链表实现，插入和删除操作快，随机访问慢。
   • Vector：线程安全的动态数组实现，功能类似于ArrayList，但因同步开销大，不推荐日常使用。
   • Stack：继承自Vector，实现了后进先出(LIFO)栈的行为，但通常建议使用Deque作为栈。

以下是针对Java List集合（包括ArrayList、LinkedList、Vector、Stack）的一些基本使用方式和常用增删改查操作的汇总。请注意，尽管示例代码会以ArrayList为主，但大部分操作对于所有List实现都是通用的，除非特别说明。

增加元素

• add(E element)：在列表末尾添加一个元素。

list.add("New Element");

• add(int index, E element)：在指定位置插入元素。

list.add(0, "Inserted Element"); // 在索引0处插入

删除元素

• remove(Object o)：删除第一次出现的指定元素。

list.remove("Element to Remove");

• remove(int index)：根据索引删除元素。

list.remove(0); // 删除索引为0的元素

修改元素

• set(int index, E element)：替换指定位置的元素。

list.set(0, "Updated Element"); // 将索引0处的元素更新

查询元素

• get(int index)：返回指定位置的元素。

E element = list.get(0); // 获取索引0处的元素

• contains(Object o)：检查列表是否包含指定元素。

boolean contains = list.contains("Search Element");

• size()：返回列表中的元素数量。

int size = list.size();

遍历元素

• 使用增强型for循环：

for (E element : list) {
    System.out.println(element);
}

• 或者使用迭代器Iterator：

Iterator<E> iterator = list.iterator();
while (iterator.hasNext()) {
    E element = iterator.next();
    System.out.println(element);
}

特别注意

• 对于Stack，除了上述通用操作外，还可以使用push(E item)和pop()方法来模拟栈的“压栈”和“弹栈”操作。
• Vector的操作方式与ArrayList相似，但由于线程安全设计，在多线程环境下无需额外的同步措施，但通常推荐使用Collections.synchronizedList(List<T> list)或CopyOnWriteArrayList作为替代，以获得更好的性能。

请根据实际需求选择合适的List实现，并注意它们在并发访问时的安全性和性能差异。

1. set集合

   • HashSet：基于哈希表实现，无序、不允许重复元素，性能依赖于哈希码的质量。
   • LinkedHashSet：基于哈希表与双向链表实现，保持插入顺序，不允许重复元素。
   • TreeSet：基于红黑树实现，自然排序或自定义比较器排序，不允许重复元素。

对于Set集合中的HashSet, LinkedHashSet, 和 TreeSet，它们的增删查操作基本一致，因为它们都遵循Set接口的规范，但各自的特性和内部实现有所不同。下面是它们共有的常用操作方法以及一些特定于实现的特性说明：

共同的增删查方法

1. 添加元素：add(E element)
   向集合中添加一个元素。如果该元素已经存在于集合中（根据对象的equals方法判断），则此操作不会改变集合，并返回false。否则，元素会被成功添加并返回true。

2. 删除元素：remove(Object o)
   从集合中移除指定的对象。如果集合中存在该元素（根据equals方法判断），则会将其移除并返回true，否则返回false。

3. 检查元素是否存在：contains(Object o)
   判断集合中是否包含指定的元素，基于对象的equals方法进行比较。

4. 清空集合：clear()
   移除集合中的所有元素。

5. 获取集合大小：size()
   返回集合中的元素数量。

特定实现的注意事项

• HashSet

  • 无序存储，不保证插入顺序。
  • 性能最优，特别是在元素的哈希码分布良好的情况下。
  • 特有方法：无，因为HashSet主要依赖于其基础的哈希表特性。

• LinkedHashSet

  • 除了基于哈希表实现外，还维护了一个双向链表来记录插入顺序。
  • 提供了迭代时的插入顺序保证。
  • 性能略低于HashSet，因为需要维护额外的链表结构。

• TreeSet

  • 基于红黑树实现，自然排序或自定义比较器排序，保证元素有序。
  • 提供了丰富的排序相关操作，如first(), last(), higher(E e), lower(E e)等，可以方便地获取集合中的最小、最大或指定范围的元素。
  • 插入、删除和查找的时间复杂度通常是O(log n)，其中n是集合中的元素数量。
  • 特有方法：可以通过构造函数传入Comparator来自定义排序逻辑。

示例代码片段

// 创建集合实例
Set<String> hashSet = new HashSet<>();
Set<String> linkedHashSet = new LinkedHashSet<>();
Set<String> treeSet = new TreeSet<>();

// 添加元素
hashSet.add("Apple");
linkedHashSet.add("Banana");
treeSet.add("Cherry");

// 删除元素
hashSet.remove("Apple");

// 检查元素
boolean contains = treeSet.contains("Cherry");

// 集合大小
int size = linkedHashSet.size();

// 清空集合
treeSet.clear();

这些方法为操作Set集合的基本手段，具体选择哪种实现应根据是否需要有序性、是否关心插入顺序或是否有特定的排序需求等因素来决定。

Map（双列集合）

• HashMap：基于哈希表实现，键值对映射，非线程安全，允许null键和null值。
• LinkedHashMap：基于哈希表与双向链表实现，维护插入顺序或访问顺序。
• TreeMap：基于红黑树实现，键自然排序或自定义比较器排序，键唯一。
• Hashtable：线程安全的哈希表，较老的实现，不推荐用于新代码，已被ConcurrentHashMap取代。
• ConcurrentHashMap：线程安全的哈希表，支持高效并发读写，优于Hashtable。

对于Map集合中的HashMap, LinkedHashMap, TreeMap, Hashtable, 和 ConcurrentHashMap，它们都遵循Map接口，提供了一套共同的操作方法来管理键值对，但也各有特色。以下是一些常见的操作方法及其特定实现的特点：

共同的增删查方法

1. 添加/更新元素：put(K key, V value)
   将指定的键值对放入此映射中。如果此映射中已存在该键的映射关系，则旧值将被替换。

2. 获取元素：get(Object key)
   根据键获取对应的值，如果键不存在则返回null。

3. 删除元素：remove(Object key)
   根据键删除对应的映射关系，如果存在则返回被删除的值。

4. 检查键是否存在：containsKey(Object key)
   判断映射中是否包含指定的键。

5. 检查值是否存在：containsValue(Object value)
   判断映射中是否包含指定的值。

6. 清空映射：clear()
   移除此映射中的所有映射关系。

7. 获取映射大小：size()
   返回此映射中的键值对数量。

特定实现的特性与操作

• HashMap

  • 特点：非线程安全，允许null键和null值，性能较高，特别是当哈希码分布良好时。
  • 特有方法：无特别独有的方法，重点在于其非线程安全性和性能优势。

• LinkedHashMap

  • 特点：维护了插入顺序或访问顺序（通过构造函数指定），基于HashMap实现，提供了迭代时的顺序保证。
  • 特有方法：无特定新增方法，主要是通过构造函数控制迭代顺序的特性。

• TreeMap

  • 特点：键自然排序或自定义比较器排序，保证了键的有序性，基于红黑树实现。
  • 特有方法：提供了丰富的基于排序的操作，如firstKey(), lastKey(), lowerEntry(K key), higherEntry(K key)等。

• Hashtable

  • 特点：线程安全的哈希表，较老的实现，不允许null键和null值，同步操作可能导致性能下降。
  • 特有方法：相对较少特有方法，主要是其线程安全性的实现方式已过时。

• ConcurrentHashMap

  • 特点：线程安全，支持高效的并发读写，通过分段锁技术降低了锁的竞争，优于Hashtable。
  • 特有方法：提供了一些高级并发操作，如putIfAbsent(V value, K key), replace(K key, V oldValue, V newValue)等，这些操作在原子性上有更好的保证。

示例代码片段

// 创建映射实例
Map<String, Integer> hashMap = new HashMap<>();
Map<String, Integer> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true); // 第三个参数true表示按访问顺序排序
Map<String, Integer> treeMap = new TreeMap<>(); // 自然排序
Map<String, Integer> hashtable = new Hashtable<>();
Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();

// 添加元素
hashMap.put("One", 1);

// 获取元素
Integer value = hashMap.get("One");

// 删除元素
hashMap.remove("One");

// 检查键是否存在
boolean containsKey = hashMap.containsKey("One");

// 获取映射大小
int size = hashMap.size();

// 清空映射
hashMap.clear();

根据具体需求选择合适的Map实现，比如需要线程安全时考虑ConcurrentHashMap，需要维持插入顺序时选择LinkedHashMap，需要键有序时使用TreeMap。

Queue（队列）

• Queue 接口，代表一个先进先出(FIFO)的队列。
  • LinkedList：也可作为队列使用。
  • PriorityQueue：基于优先堆的无界优先队列，没有固定顺序，元素按照自然排序或比较器排序。
  • ArrayBlockingQueue：基于数组的有界阻塞队列，线程安全。
  • LinkedBlockingQueue：基于链表的可选有界阻塞队列，线程安全。
  • DelayQueue：基于优先级队列的延迟无界阻塞队列，元素只有在延迟期满后才能被获取。
  • ConcurrentLinkedQueue：基于链表的无界并发队列，线程安全，非阻塞。

对于Java中的Queue接口及其常见实现，包括LinkedList, PriorityQueue, ArrayBlockingQueue, LinkedBlockingQueue, DelayQueue, 和 ConcurrentLinkedQueue，它们作为队列的主要操作包括入队（添加元素）、出队（移除并获取元素）、查看队首元素等。下面是它们的使用方式和基本操作的汇总：

公共操作

1. 入队（添加元素）

   • add(E element)：如果队列未满，则添加元素，队满时抛出IllegalStateException。
   • offer(E element)：尝试加入元素，队列满时返回false，而不是抛出异常。
   • put(E element)：对于阻塞队列（如ArrayBlockingQueue, LinkedBlockingQueue），如果队列满，当前线程将被阻塞，直到空间可用。

2. 出队（移除并获取元素）

   • remove() 或 poll()：移除并返回队首元素，队列为空时，remove() 抛出异常，而 poll() 返回null。
   • take()：对于阻塞队列，如果队列为空，当前线程将被阻塞，直到有元素可用。

3. 查看队首元素

   • element() 或 peek()：返回队首元素但不移除，队列为空时，element() 抛出异常，peek() 返回null。

特定实现的特性

• LinkedList

  • 作为动态数组实现的List，也可以当作FIFO队列使用，但不支持阻塞操作。
  • 常用操作：直接调用addLast(E element)入队，removeFirst()或pollFirst()出队。

• PriorityQueue

  • 基于优先堆的无界优先队列，保证最高优先级的元素先出队。
  • 特有操作：无特定的队列操作，但其排序特性（基于自然排序或Comparator）是其特色。

• ArrayBlockingQueue

  • 固定大小的阻塞队列，线程安全。
  • 特有操作：支持公平策略和非公平策略的阻塞控制。

• LinkedBlockingQueue

  • 可选固定大小的阻塞队列，基于链表实现，线程安全。
  • 特有操作：默认无界（除非构造时指定了容量），提供了阻塞和非阻塞的put/take操作。

• DelayQueue

  • 基于优先级队列的无界阻塞队列，元素需实现Delayed接口，只有延迟到期的元素才可被消费。
  • 特有操作：入队元素需实现getDelay()方法，以确定其到期时间。

• ConcurrentLinkedQueue

  • 无界的并发队列，基于链表实现，线程安全，非阻塞。
  • 特有操作：专门设计用于高并发场景，无需锁定，采用CAS操作保证线程安全。

示例代码片段

Queue<String> queue;

// 使用LinkedList作为队列
queue = new LinkedList<>();
queue.offer("A");
queue.poll();

// 使用PriorityQueue
queue = new PriorityQueue<>();
queue.offer("B");
queue.poll();

// 使用ArrayBlockingQueue（阻塞队列）
queue = new ArrayBlockingQueue<>(10);
queue.put("C");
queue.take();

// 使用LinkedBlockingQueue
queue = new LinkedBlockingQueue<>();
queue.put("D");
queue.take();

// 使用DelayQueue
queue = new DelayQueue<>();
queue.put(new DelayedElement("Delayed E"));
queue.take();

// 使用ConcurrentLinkedQueue
queue = new ConcurrentLinkedQueue<>();
queue.offer("F");
queue.poll();

请注意，使用DelayQueue时，元素必须实现Delayed接口，并重写getDelay()方法和compareTo()方法。

Deque（双端队列）

• Deque 接口，扩展了Queue，允许两端进行插入和删除操作。
  • ArrayDeque：基于可调整大小的数组实现，可作为栈或队列使用，非线程安全。
  • LinkedList：同样实现了Deque接口，提供了双端队列的功能。

对于Java中的Deque接口及其两个主要实现类ArrayDeque和LinkedList，它们提供了丰富的双端队列操作，支持在队列的头部和尾部进行高效的插入和删除。以下是它们的使用方式和常用操作的汇总：

公共操作（适用于ArrayDeque和LinkedList）

1. 在前端操作

   • 插入：addFirst(E element) / offerFirst(E element) 在队列头部添加元素。
   • 移除：removeFirst() / pollFirst() 移除并返回队列头部的元素；如果队列为空，removeFirst()会抛出异常，而pollFirst()返回null。
   • 查看：getFirst() / peekFirst() 查看队列头部的元素但不移除；如果队列为空，getFirst()抛出异常，peekFirst()返回null。

2. 在后端操作

   • 插入：addLast(E element) / offerLast(E element) 在队列尾部添加元素。
   • 移除：removeLast() / pollLast() 移除并返回队列尾部的元素；如果队列为空，removeLast()抛出异常，pollLast()返回null。
   • 查看：getLast() / peekLast() 查看队列尾部的元素但不移除；如果队列为空，getLast()抛出异常，peekLast()返回null。

3. 其他通用操作

   • 大小查询：size() 返回队列中元素的数量。
   • 是否为空：isEmpty() 判断队列是否为空。

实现类特性

• ArrayDeque

  • 特点：基于可调整大小的环形数组实现，提供了非常高的访问和修改性能，特别是对于随机访问和循环迭代。非线程安全，适用于不需要线程同步的高性能场景。
  • 优势：在大多数场景下，由于其底层数据结构的优化，性能优于LinkedList。

• LinkedList

  • 特点：基于双向链表实现，既是List也是Deque，因此支持更多的操作，如索引访问等。适合于需要频繁进行插入和删除操作的场景，尤其是当这些操作发生在集合中间时。非线程安全。
  • 优势：对于插入、删除操作，尤其是在链表中间的操作，表现优秀，但随机访问性能不如ArrayDeque。

示例代码片段

Deque<String> deque;

// 使用ArrayDeque
deque = new ArrayDeque<>();
deque.addFirst("Front");
deque.addLast("Back");
String first = deque.peekFirst(); // 查看队首元素
deque.pollLast(); // 移除并返回队尾元素

// 使用LinkedList作为Deque
deque = new LinkedList<>();
deque.offerFirst("Front");
deque.offerLast("Back");
String last = deque.peekLast(); // 查看队尾元素
deque.pollFirst(); // 移除并返回队首元素

根据具体需求选择合适的数据结构：对于追求性能和简单操作的场景，ArrayDeque可能是更好的选择；而对于需要更多灵活性和链表特性的操作，LinkedList会更加适用。

以上是Java集合框架的主要组成部分，它们为处理和操作集合提供了高度灵活和强大的工具。选择合适的集合类型取决于具体的应用场景，如是否需要线程安全、是否关心元素的顺序、是否需要排序等。