Java集合操作详解：ArrayList、LinkedList、HashSet、HashMap等实战应用
1. 使用 ArrayList 存储一组字符串，并遍历打印
ArrayList 是 Java 中一个基于动态数组实现的集合类，它允许我们存储一组对象，并且可以方便地对其进行操作。ArrayList 的特点包括：
- 元素可以动态添加和删除。
- 元素是有序的，即元素的存储顺序与添加顺序一致。
- 允许存储重复的元素。
- 提供了丰富的操作方法，如添加、删除、查找等。
代码实现
import java.util.ArrayList;
public class ArrayListExample {
public static void main(String[] args) {
// 创建一个 ArrayList 对象，用于存储字符串
ArrayList<String> list = new ArrayList<>();
// 添加字符串元素
list.add("Java");
list.add("Python");
list.add("C++");
list.add("JavaScript");
// 遍历 ArrayList 并打印每个元素
System.out.println("遍历 ArrayList 中的字符串：");
for (String str : list) {
System.out.println(str);
}
}
}
详细描述
- 创建
ArrayList对象：通过new ArrayList<>()创建一个ArrayList对象，指定其泛型为String，表示该集合只能存储字符串类型的元素。 - 添加元素：使用
add()方法将字符串添加到ArrayList中。add()方法会将元素添加到集合的末尾。 - 遍历集合：使用增强型
for循环（for-each循环）来遍历ArrayList中的每个元素。在每次循环中，str会依次取集合中的每个字符串，并通过System.out.println()打印出来。
2. 使用 LinkedList 存储一组整数，并在头部和尾部添加元素
LinkedList 是 Java 中一个基于双向链表实现的集合类，它也可以存储一组对象。LinkedList 的特点包括：
- 元素可以动态添加和删除。
- 元素是有序的，存储顺序与添加顺序一致。
- 允许存储重复的元素。
- 提供了丰富的操作方法，如在头部或尾部添加、删除元素等。
代码实现
import java.util.LinkedList;
public class LinkedListExample {
public static void main(String[] args) {
// 创建一个 LinkedList 对象，用于存储整数
LinkedList<Integer> list = new LinkedList<>();
// 在尾部添加元素
list.add(10);
list.add(20);
list.add(30);
// 在头部添加元素
list.addFirst(5);
list.addLast(40);
// 打印 LinkedList 中的元素
System.out.println("LinkedList 中的元素：");
for (Integer num : list) {
System.out.println(num);
}
}
}
详细描述
- 创建
LinkedList对象：通过new LinkedList<>()创建一个LinkedList对象，指定其泛型为Integer，表示该集合只能存储整数类型的元素。 - 在尾部添加元素：使用
add()方法将整数添加到LinkedList的尾部。add()方法是LinkedList的默认添加方法，会将元素添加到集合的末尾。 - 在头部添加元素：使用
addFirst()方法将元素添加到LinkedList的头部。 - 在尾部添加元素：使用
addLast()方法将元素添加到LinkedList的尾部。虽然add()方法也可以实现尾部添加，但addLast()方法更明确地表达了意图。 - 遍历集合：使用增强型
for循环来遍历LinkedList中的每个元素，并通过System.out.println()打印出来。
3. 使用 HashSet 存储一组不重复的整数，并判断某个元素是否存在
HashSet 是 Java 中一个基于哈希表实现的集合类，它用于存储一组不重复的元素。HashSet 的特点包括：
- 元素是无序的，即存储顺序与添加顺序无关。
- 不允许存储重复的元素。
- 提供了高效的查找操作。
代码实现
import java.util.HashSet;
public class HashSetExample {
public static void main(String[] args) {
// 创建一个 HashSet 对象，用于存储整数
HashSet<Integer> set = new HashSet<>();
// 添加整数元素
set.add(10);
set.add(20);
set.add(30);
// 判断某个元素是否存在
int searchElement = 20;
if (set.contains(searchElement)) {
System.out.println("元素 " + searchElement + " 存在于 HashSet 中");
} else {
System.out.println("元素 " + searchElement + " 不存在于 HashSet 中");
}
}
}
详细描述
- 创建
HashSet对象：通过new HashSet<>()创建一个HashSet对象，指定其泛型为Integer，表示该集合只能存储整数类型的元素。 - 添加元素：使用
add()方法将整数添加到HashSet中。由于HashSet不允许存储重复的元素，如果尝试添加一个已经存在的元素，add()方法会返回false，表示添加失败。 - 判断元素是否存在：使用
contains()方法判断某个元素是否存在于HashSet中。如果元素存在，contains()方法返回true；否则返回false。
4. 使用 HashMap 存储一组键值对，并查找某个键对应的值
HashMap 是 Java 中一个基于哈希表实现的集合类，它用于存储一组键值对（key-value）。HashMap 的特点包括：
- 键（
key）是唯一的，不能重复。 - 值（
value）可以重复。 - 提供了高效的查找操作。
代码实现
import java.util.HashMap;
public class HashMapExample {
public static void main(String[] args) {
// 创建一个 HashMap 对象，用于存储键值对
HashMap<String, Integer> map = new HashMap<>();
// 添加键值对
map.put("Java", 10);
map.put("Python", 20);
map.put("C++", 30);
// 查找某个键对应的值
String key = "Python";
if (map.containsKey(key)) {
System.out.println("键 " + key + " 对应的值是：" + map.get(key));
} else {
System.out.println("键 " + key + " 不存在于 HashMap 中");
}
}
}
详细描述
- 创建
HashMap对象：通过new HashMap<>()创建一个HashMap对象，指定其泛型为String和Integer，表示该集合的键是字符串类型，值是整数类型。 - 添加键值对：使用
put()方法将键值对添加到HashMap中。如果键已经存在，put()方法会用新的值覆盖旧的值。 - 查找键对应的值：使用
containsKey()方法判断某个键是否存在于HashMap中。如果键存在，使用get()方法获取该键对应的值。
5. 使用 TreeSet 存储一组字符串，并按字典序排序
TreeSet 是 Java 中一个基于红黑树实现的集合类，它用于存储一组有序的元素。TreeSet 的特点包括：
- 元素是有序的，按照自然顺序或指定的比较器顺序排序。
- 不允许存储重复的元素。
- 提供了高效的查找操作。
代码实现
import java.util.TreeSet;
public class TreeSetExample {
public static void main(String[] args) {
// 创建一个 TreeSet 对象，用于存储字符串
TreeSet<String> set = new TreeSet<>();
// 添加字符串元素
set.add("Java");
set.add("Python");
set.add("C++");
set.add("JavaScript");
// 遍历 TreeSet 中的元素
System.out.println("TreeSet 中的字符串（按字典序排序）：");
for (String str : set) {
System.out.println(str);
}
}
}
详细描述
- 创建
TreeSet对象：通过new TreeSet<>()创建一个TreeSet对象，指定其泛型为String，表示该集合只能存储字符串类型的元素。由于String类实现了Comparable接口，因此TreeSet会按照字符串的自然顺序（字典序）对元素进行排序。 - 添加元素：使用
add()方法将字符串添加到TreeSet中。由于TreeSet不允许存储重复的元素，如果尝试添加一个已经存在的元素，add()方法会返回false，表示添加失败。 - 遍历集合：使用增强型
for循环来遍历TreeSet中的每个元素，并通过System.out.println()打印出来。由于TreeSet是有序的，因此遍历的结果会按照字典序排列。
6. 使用 TreeMap 存储一组键值对，并按键的自然顺序排序
TreeMap 是 Java 中一个基于红黑树实现的集合类，它用于存储一组有序的键值对。TreeMap 的特点包括：
- 键（
key）是唯一的，不能重复。 - 值（
value）可以重复。 - 键是有序的，按照自然顺序或指定的比较器顺序排序。
- 提供了高效的查找操作。
代码实现
import java.util.TreeMap;
public class TreeMapExample {
public static void main(String[] args) {
// 创建一个 TreeMap 对象，用于存储键值对
TreeMap<String, Integer> map = new TreeMap<>();
// 添加键值对
map.put("Java", 10);
map.put("Python", 20);
map.put("C++", 30);
map.put("JavaScript", 40);
// 遍历 TreeMap 中的键值对
System.out.println("TreeMap 中的键值对（按键的自然顺序排序）：");
for (String key : map.keySet()) {
System.out.println("键：" + key + "，值：" + map.get(key));
}
}
}
详细描述
- 创建
TreeMap对象：通过new TreeMap<>()创建一个TreeMap对象，指定其泛型为String和Integer，表示该集合的键是字符串类型，值是整数类型。由于String类实现了Comparable接口，因此TreeMap会按照键的自然顺序（字典序）对键值对进行排序。 - 添加键值对：使用
put()方法将键值对添加到TreeMap中。如果键已经存在，put()方法会用新的值覆盖旧的值。 - 遍历集合：使用
keySet()方法获取TreeMap中的所有键，并使用增强型for循环来遍历这些键。在每次循环中，通过map.get(key)获取对应的值，并通过System.out.println()打印出来。由于TreeMap是有序的，因此遍历的结果会按键的自然顺序排列。
7. 将一个数组转换为 ArrayList，并进行排序
Java 提供了多种方式将数组转换为 ArrayList，并且可以使用 Collections.sort() 方法对 ArrayList 进行排序。
代码实现
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class ArrayToArrayListExample {
public static void main(String[] args) {
// 创建一个数组
String[] array = {"Java", "Python", "C++", "JavaScript"};
// 将数组转换为 ArrayList
ArrayList<String> list = new ArrayList<>(Arrays.asList(array));
// 对 ArrayList 进行排序
Collections.sort(list);
// 打印排序后的 ArrayList
System.out.println("排序后的 ArrayList：");
for (String str : list) {
System.out.println(str);
}
}
}
详细描述
- 创建数组：通过
new String[]创建一个字符串数组，并初始化数组元素。 - 将数组转换为
ArrayList：使用Arrays.asList()方法将数组转换为一个固定大小的List，然后通过new ArrayList<>(...)将其包装为一个可动态修改的ArrayList。 - 对
ArrayList进行排序：使用Collections.sort()方法对ArrayList进行排序。Collections.sort()方法会按照元素的自然顺序对集合进行排序。 - 遍历集合：使用增强型
for循环来遍历排序后的ArrayList，并通过System.out.println()打印每个元素。
8. 使用 Collections 类对 ArrayList 进行反转
Collections 类提供了多种静态方法，用于操作集合。其中，Collections.reverse() 方法可以反转集合中的元素顺序。
代码实现
import java.util.ArrayList;
import java.util.Collections;
public class ReverseArrayListExample {
public static void main(String[] args) {
// 创建一个 ArrayList
ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
list.add("JavaScript");
// 反转 ArrayList
Collections.reverse(list);
// 打印反转后的 ArrayList
System.out.println("反转后的 ArrayList：");
for (String str : list) {
System.out.println(str);
}
}
}
详细描述
- 创建
ArrayList：通过new ArrayList<>()创建一个ArrayList对象，并使用add()方法添加字符串元素。 - 反转集合：使用
Collections.reverse()方法反转ArrayList中的元素顺序。该方法会直接修改集合的内容，将元素的顺序完全颠倒。 - 遍历集合：使用增强型
for循环来遍历反转后的ArrayList，并通过System.out.println()打印每个元素。
9. 使用 Iterator 遍历一个 HashSet 集合
Iterator 是 Java 中一个用于遍历集合的接口。通过 Iterator，我们可以安全地遍历集合中的元素，同时还可以在遍历过程中删除元素。
代码实现
import java.util.HashSet;
import java.util.Iterator;
public class IteratorExample {
public static void main(String[] args) {
// 创建一个 HashSet
HashSet<Integer> set = new HashSet<>();
set.add(10);
set.add(20);
set.add(30);
// 使用 Iterator 遍历 HashSet
Iterator<Integer> iterator = set.iterator();
System.out.println("使用 Iterator 遍历 HashSet：");
while (iterator.hasNext()) {
Integer num = iterator.next();
System.out.println(num);
}
}
}
详细描述
- 创建
HashSet：通过new HashSet<>()创建一个HashSet对象，并使用add()方法添加整数元素。 - 获取
Iterator：通过set.iterator()获取一个Iterator对象，用于遍历HashSet。 - 遍历集合：使用
while循环和iterator.hasNext()方法判断是否还有下一个元素。如果还有下一个元素，通过iterator.next()获取当前元素，并通过System.out.println()打印出来。 - 安全性：使用
Iterator遍历时，如果在遍历过程中直接修改集合的内容（例如通过set.remove()方法），会抛出ConcurrentModificationException异常。但如果通过iterator.remove()方法删除元素，则是安全的。
10. 使用 Stream API 过滤出一个 ArrayList 中所有偶数
Java 8 引入了 Stream API，它提供了一种高效且简洁的方式来处理集合。通过 Stream API，我们可以方便地对集合进行过滤、排序、转换等操作。
代码实现
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
// 创建一个 ArrayList
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
// 使用 Stream API 过滤出所有偶数
List<Integer> evenNumbers = list.stream()
.filter(num -> num % 2 == 0)
.collect(Collectors.toList());
// 打印过滤后的结果
System.out.println("过滤后的偶数：");
for (Integer num : evenNumbers) {
System.out.println(num);
}
}
}
详细描述
- 创建
ArrayList：通过new ArrayList<>()创建一个ArrayList对象，并使用add()方法添加整数元素。 - 创建
Stream：通过list.stream()方法将ArrayList转换为一个Stream对象。Stream是一个中间层，用于对集合进行操作。 - 过滤操作：使用
filter()方法对Stream中的元素进行过滤。filter()方法接收一个Predicate函数式接口，用于定义过滤条件。在这里，我们使用num -> num % 2 == 0来判断一个数是否为偶数。 - 收集结果：使用
collect()方法将过滤后的Stream收集为一个新的集合。Collectors.toList()是一个常用的收集器，用于将Stream收集为一个List。 - 遍历集合：使用增强型
for循环来遍历过滤后的集合，并通过System.out.println()打印每个偶数。
浙公网安备 33010602011771号