集合类：List、Set、Map超详细讲解并附带代码块

总结：

• List 是有序的集合类型，可以通过索引访问元素，允许重复元素。

• Set 是无序的集合类型，不允许重复元素。

• Map 是一组键值对的集合，每个键只能对应一个值，键是唯一的。

List

List 是 Java 集合框架中最基础的一种集合类型。它代表一个有序的元素序列，每个元素可以通过索引访问到。

创建 List

创建一个空的 List 可以使用以下代码：

List<String> list = new ArrayList<>();

如果你需要在创建 List 的时候初始化数据，可以使用以下代码：

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

添加元素

添加元素到 List 中可以使用以下方法：

• add(E e)：在 List 的末尾添加指定元素。
• add(int index, E element)：在 List 的指定位置插入指定元素。
• addAll(Collection<? extends E> c)：将指定集合中的所有元素追加到 List 的末尾。
• addAll(int index, Collection<? extends E> c)：将指定集合中的所有元素插入到 List 的指定位置。

例如，以下代码演示了如何向 List 中添加元素：

List<String> list = new ArrayList<>();
list.add("a");
list.add(1, "b");
list.addAll(Arrays.asList("c", "d"));
list.addAll(2, Arrays.asList("e", "f"));

获取元素

获取 List 中的元素可以使用以下方法：

• get(int index)：返回 List 中指定位置的元素。
• subList(int fromIndex, int toIndex)：返回 List 中指定范围内的元素，包含起始索引处的元素，不包含结束索引处的元素。
• indexOf(Object o)：返回 List 中第一次出现指定元素的位置索引。
• lastIndexOf(Object o)：返回 List 中最后一次出现指定元素的位置索引。

例如，以下代码演示了如何获取 List 中的元素：

List<String> list = Arrays.asList("a", "b", "c", "d");
String firstElement = list.get(0);
List<String> subList = list.subList(1, 3);
int indexOfB = list.indexOf("b");
int lastIndexOfC = list.lastIndexOf("c");

修改元素

修改 List 中的元素可以使用以下方法：

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

例如，以下代码演示了如何修改 List 中的元素：

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

删除元素

从 List 中删除元素可以使用以下方法：

• remove(int index)：删除 List 中指定位置的元素。
• remove(Object o)：删除 List 中第一次出现指定元素的元素。
• removeAll(Collection<?> c)：删除 List 中与指定集合中相同的所有元素。
• clear()：删除 List 中的所有元素。

例如，以下代码演示了如何删除 List 中的元素：

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
list.remove(1);
list.remove("c");
list.removeAll(Arrays.asList("a", "b"));
list.clear();

遍历 List

遍历 List 可以使用以下方法：

• 使用 for 循环遍历。
• 使用增强型 for 循环遍历。
• 使用迭代器遍历。
• 使用 Stream API 遍历。

例如，以下代码演示了如何遍历 List：

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

// 使用 for 循环遍历
for (int i = 0; i < list.size(); i++) {
    String element = list.get(i);
    System.out.println(element);
}

// 使用增强型 for 循环遍历
for (String element : list) {
    System.out.println(element);
}

// 使用迭代器遍历
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

// 使用 Stream API 遍历
list.stream().forEach(System.out::println);

Set

Set 是 Java 集合框架中的一种集合类型。它代表一个不包含重复元素的无序集合。

创建 Set

创建一个空的 Set 可以使用以下代码：

Set<String> set = new HashSet<>();

如果你需要在创建 Set 的时候初始化数据，可以使用以下代码：

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

添加元素

添加元素到 Set 中可以使用以下方法：

• add(E e)：向 Set 中添加指定元素。
• addAll(Collection<? extends E> c)：将指定集合中的所有元素追加到 Set 中。

例如，以下代码演示了如何向 Set 中添加元素：

Set<String> set = new HashSet<>();
set.add("a");
set.addAll(Arrays.asList("b", "c"));

获取元素

Set 中没有像 List 一样通过位置索引获取元素的方法，因为 Set 是无序的。你可以使用以下方法来获取元素：

• contains(Object o)：判断 Set 中是否包含指定元素。

例如，以下代码演示了如何获取 Set 中的元素：

Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c"));
boolean containsA = set.contains("a");

删除元素

从 Set 中删除元素可以使用以下方法：

• remove(Object o)：删除 Set 中指定元素。
• removeAll(Collection<?> c)：删除 Set 中与指定集合中相同的所有元素。
• clear()：删除 Set 中的所有元素。

例如，以下代码演示了如何删除 Set 中的元素：

Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c", "d"));
set.remove("a");
set.removeAll(Arrays.asList("b", "c"));
set.clear();

遍历 Set

遍历 Set 可以使用以下方法：

• 使用增强型 for 循环遍历。
• 使用迭代器遍历。
• 使用 Stream API 遍历。

例如，以下代码演示了如何遍历 Set：

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

// 使用增强型 for 循环遍历
for (String element : set) {
    System.out.println(element);
}

// 使用迭代器遍历
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

// 使用 Stream API 遍历
set.stream().forEach(System.out::println);

Map

Map 是 Java 集合框架中的一种集合类型。它代表了一组键值对，每个键只能对应一个值。

创建 Map

创建一个空的 Map 可以使用以下代码：

Map<String, Integer> map = new HashMap<>();

如果你需要在创建 Map 的时候初始化数据，可以使用以下代码：

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);

添加元素

向 Map 中添加元素可以使用以下方法：

• put(K key, V value)：将指定的键值对添加到 Map 中。
• putAll(Map<? extends K, ? extends V> m)：将指定 Map 中的所有键值对添加到当前 Map 中。

例如，以下代码演示了如何向 Map 中添加元素：

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.putAll(new HashMap<String, Integer>() {{
    put("b", 2);
    put("c", 3);
}});

获取元素

获取 Map 中的元素可以使用以下方法：

• get(Object key)：返回与指定键关联的值。
• containsKey(Object key)：判断 Map 中是否包含指定键。
• containsValue(Object value)：判断 Map 中是否包含指定值。

例如，以下代码演示了如何获取 Map 中的元素：

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
int aValue = map.get("a");
boolean containsA = map.containsKey("a");
boolean containsValue2 = map.containsValue(2);

修改元素

修改 Map 中的元素可以使用 put 方法。如果指定键在 Map 中不存在，则会将指定键值对添加到 Map 中；否则，会用新值替换原来的值。

例如，以下代码演示了如何修改 Map 中的元素：

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("a", 3);

删除元素

从 Map 中删除元素可以使用以下方法：

• remove(Object key)：删除 Map 中指定键对应的键值对。
• clear()：删除 Map 中的所有键值对。

例如，以下代码演示了如何删除 Map 中的元素：

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.remove("a");
map.clear();

遍历 Map

遍历 Map 可以使用以下方法：

• 使用增强型 for 循环遍历。
• 使用迭代器遍历。
• 使用 Stream API 遍历。

例如，以下代码演示了如何遍历 Map：

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);

// 使用增强型 for 循环遍历
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + ": " + value);
}

// 使用迭代器遍历
Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + ": " + value);
}

// 使用 Stream API 遍历
map.entrySet().stream().forEach(entry -> {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + ": " + value);
});

创建集合对象：

• List：List<String> list = new ArrayList<>();

• Set：Set<String> set = new HashSet<>();

• Map：Map<String, Integer> map = new HashMap<>();

常用操作：

• 添加元素：

  • List：list.add(element);
  • Set：set.add(element);
  • Map：map.put(key, value);

• 获取元素：

  • List：String element = list.get(index);
  • Set：boolean containsElement = set.contains(element);
  • Map：Integer value = map.get(key);

• 修改元素：

  • List：list.set(index, element);
  • Map：map.put(key, newValue);

• 删除元素：

  • List：list.remove(index);
  • Set：set.remove(element);
  • Map：map.remove(key);

• 遍历元素：

  • List：使用 for 循环、增强型 for 循环、迭代器或 Stream API。
  • Set：使用增强型 for 循环、迭代器或 Stream API。
  • Map：使用增强型 for 循环、迭代器或 Stream API。

这些是 List、Set 和 Map 的基本用法和常见操作。根据实际需求，你可以选择适合的集合类型来存储和操作数据。