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 iterator = list.iterator();
                    while (iterator.hasNext()) {
                        E element = iterator.next();
                        System.out.println(element);
                    }

                    特别注意

                    • 对于Stack，除了上述通用操作外，还可以使用push(E item)和pop()方法来模拟栈的“压栈”和“弹栈”操作。
                    • Vector的操作方式与ArrayList相似，但由于线程安全设计，在多线程环境下无需额外的同步措施，但通常推荐使用Collections.synchronizedList(List 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 hashSet = new HashSet<>();
                        Set linkedHashSet = new LinkedHashSet<>();
                        Set 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 hashMap = new HashMap<>();
                            Map linkedHashMap = new LinkedHashMap<>(16, 0.75f, true); // 第三个参数true表示按访问顺序排序
                            Map treeMap = new TreeMap<>(); // 自然排序
                            Map hashtable = new Hashtable<>();
                            Map 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 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 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集合框架的主要组成部分，它们为处理和操作集合提供了高度灵活和强大的工具。选择合适的集合类型取决于具体的应用场景，如是否需要线程安全、是否关心元素的顺序、是否需要排序等。