在 Java 中，集合框架是非常重要的一个部分，用来处理动态数据的存储和操作。常见的集合类包括 List、Set、Map 等，它们都有各种常用的函数和操作方法。掌握这些集合类及其常见的函数使用是刷题时常见的需求，尤其是在算法和数据结构的题目中。以下是 Java 集合类常见操作及类型转换的总结：

---

一、Java 集合类

1、List

• 特点：有序，可重复的集合。使用 ArrayList 或 LinkedList 实现。
• 常用方法：
  • add(E e)：向列表中添加元素。
  • get(int index)：获取指定索引的元素。
  • remove(int index)：移除指定索引的元素。
  • contains(Object o)：判断列表中是否包含指定元素。
  • size()：获取列表的大小。
  • set(int index, E element)：替换指定位置的元素。
  • indexOf(Object o)：返回指定元素的索引位置。
  • clear()：清空列表。
  • isEmpty()：判断列表是否为空。
• 常见实现类：
  • ArrayList：基于数组实现，查找效率高，插入删除效率低。
  • LinkedList：基于链表实现，插入删除效率高，查找效率低。

2、Set

• 特点：无序，不重复的集合。使用 HashSet、LinkedHashSet 和 TreeSet 实现。
• 常用方法：
  • add(E e)：添加元素，返回是否成功。
  • contains(Object o)：判断集合中是否包含指定元素。
  • remove(Object o)：删除指定元素。
  • size()：获取集合的大小。
  • clear()：清空集合。
  • isEmpty()：判断集合是否为空。
  • iterator()：返回集合的迭代器。
• 常见实现类：
  • HashSet：基于哈希表实现，无序、不重复。
  • LinkedHashSet：继承 HashSet，元素插入顺序有序。
  • TreeSet：基于红黑树实现，元素自动排序。

3、Map

• 特点：键值对存储的数据结构，键不重复，值可以重复。使用 HashMap、TreeMap 和 LinkedHashMap 实现。
• 常用方法：
  • put(K key, V value)：添加键值对。
  • get(Object key)：根据键获取值。
  • remove(Object key)：删除指定键值对。
  • containsKey(Object key)：判断是否包含指定键。
  • containsValue(Object value)：判断是否包含指定值。
  • size()：获取 Map 中的键值对个数。
  • keySet()：获取所有键的集合。
  • values()：获取所有值的集合。
  • entrySet()：获取所有键值对的集合。
• 常见实现类：
  • HashMap：基于哈希表实现，键值对无序，查询速度快。
  • LinkedHashMap：继承 HashMap，维护插入顺序。
  • TreeMap：基于红黑树实现，按键的自然顺序或指定的比较器排序。

4、Queue

• 特点：先进先出（FIFO）的集合。常用实现类包括 LinkedList、PriorityQueue 等。
• 常用方法：
  • offer(E e)：向队列中添加元素。
  • poll()：移除并返回队列头元素。
  • peek()：返回队列头元素，但不移除。
  • isEmpty()：判断队列是否为空。
  • size()：获取队列大小。
• 常见实现类：
  • LinkedList：实现了 Queue 接口，可以作为队列使用。
  • PriorityQueue：基于优先队列实现，元素按照优先级排序。

---

二、Java 集合类常用操作示例

// 1. List 示例
List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("cherry");

System.out.println(list.get(1)); // 输出 "banana"
System.out.println(list.size()); // 输出 3
list.remove(0); // 移除 "apple"
System.out.println(list.contains("cherry")); // 输出 true

// 2. Set 示例
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);
set.add(2); // 重复的元素不会添加

System.out.println(set.contains(2)); // 输出 true
System.out.println(set.size()); // 输出 3

// 3. Map 示例
Map<String, Integer> map = new HashMap<>();
map.put("apple", 3);
map.put("banana", 5);
map.put("cherry", 2);

System.out.println(map.get("banana")); // 输出 5
System.out.println(map.containsKey("apple")); // 输出 true
System.out.println(map.size()); // 输出 3

// 4. Queue 示例
Queue<String> queue = new LinkedList<>();
queue.offer("apple");
queue.offer("banana");
queue.offer("cherry");

System.out.println(queue.peek()); // 输出 "apple"
queue.poll(); // 移除 "apple"
System.out.println(queue.peek()); // 输出 "banana"

---

三、Java 集合类型转换

在刷题过程中，常常需要在不同类型的集合之间进行转换。下面是一些常见的类型转换方法：

1. List 转 Set

   List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
   Set<String> set = new HashSet<>(list);

2. Set 转 List

   Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c"));
   List<String> list = new ArrayList<>(set);

3. List 转 Map

   List<String> list = Arrays.asList("apple", "banana", "cherry");
   Map<Integer, String> map = new HashMap<>();
   for (int i = 0; i < list.size(); i++) {
       map.put(i, list.get(i)); // 将列表元素索引作为键
   }

4. Map 转 Set（键值对）

   Map<String, Integer> map = new HashMap<>();
   map.put("apple", 3);
   map.put("banana", 5);

   // 获取键值对集合
   Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
   for (Map.Entry<String, Integer> entry : entrySet) {
       System.out.println(entry.getKey() + ": " + entry.getValue());
   }

5. List 转 String

   List<String> list = Arrays.asList("apple", "banana", "cherry");
   String result = String.join(", ", list);  // 输出 "apple, banana, cherry"

6. Set 转 Array

   Set<String> set = new HashSet<>(Arrays.asList("apple", "banana", "cherry"));
   String[] array = set.toArray(new String[0]);

7. Map 转 List

   Map<String, Integer> map = new HashMap<>();
   map.put("apple", 3);
   map.put("banana", 5);

   // 转换为列表，只取键
   List<String> keyList = new ArrayList<>(map.keySet());

   // 转换为列表，只取值
   List<Integer> valueList = new ArrayList<>(map.values());

---

四、常见的集合类算法

1. 查找最大/最小值

   List<Integer> list = Arrays.asList(1, 5, 3, 9, 7);
   int max = Collections.max(list); // 最大值
   int min = Collections.min(list); // 最小值

2. 排序

   List<Integer> list = Arrays.asList(1, 5, 3, 9, 7);
   Collections.sort(list); // 升序排序
   Collections.reverse(list); // 逆序排序

3. 去重

   List<Integer> list = Arrays.asList(1, 2, 2, 3, 4, 4);
   Set<Integer> set = new HashSet<>(list); // 使用 Set 去重

4. 遍历集合

   List<String> list = Arrays.asList("a", "b", "c");

   // 普通 for 循环
   for (int i = 0; i < list.size(); i++) {
       System.out.println(list

.get(i));
   }

   // 增强 for 循环
   for (String s : list) {
       System.out.println(s);
   }

   // 使用 Java 8 lambda 表达式
   list.forEach(s -> System.out.println(s));

---

通过不断刷题和实战，熟悉这些集合类及其方法，能够帮助你在实际开发和算法题中更加高效地处理数据结构和算法。