【 JAVA中常见的集合操作】

JAVA中常见的集合操作

Java 提供了丰富的集合框架（Java Collections Framework），包括多种集合接口和实现类。集合操作可以分为基本操作和高级操作。下面介绍一些常见的集合操作，并给出相应的代码示例。

基本集合操作

创建集合

Java 集合框架包括 List、Set 和 Map 三种主要接口。

import java.util.*;public class BasicCollectionOperations {public static void main(String[] args) {// List 示例List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// Set 示例Set<String> set = new HashSet<>();set.add("One");set.add("Two");set.add("Three");// Map 示例Map<String, Integer> map = new HashMap<>();map.put("One", 1);map.put("Two", 2);map.put("Three", 3);System.out.println("List: " + list);System.out.println("Set: " + set);System.out.println("Map: " + map);}
}

访问元素

import java.util.*;public class AccessElements {public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));// 访问 List 元素String firstElement = list.get(0);System.out.println("First Element: " + firstElement);// 访问 Set 元素（通过迭代器）Set<String> set = new HashSet<>(Arrays.asList("One", "Two", "Three"));Iterator<String> iterator = set.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}// 访问 Map 元素Map<String, Integer> map = new HashMap<>();map.put("One", 1);map.put("Two", 2);map.put("Three", 3);for (Map.Entry<String, Integer> entry : map.entrySet()) {System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());}}
}

修改集合

import java.util.*;public class ModifyCollection {public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));// 修改 List 元素list.set(1, "Blueberry");System.out.println("Modified List: " + list);// 添加元素到 SetSet<String> set = new HashSet<>(Arrays.asList("One", "Two", "Three"));set.add("Four");System.out.println("Modified Set: " + set);// 修改 Map 元素Map<String, Integer> map = new HashMap<>();map.put("One", 1);map.put("Two", 2);map.put("Three", 3);map.put("Two", 22); // 修改键为 "Two" 的值System.out.println("Modified Map: " + map);}
}

删除元素

import java.util.*;public class RemoveElement {public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));// 删除 List 元素list.remove("Banana");System.out.println("List after removing Banana: " + list);// 删除 Set 元素Set<String> set = new HashSet<>(Arrays.asList("One", "Two", "Three"));set.remove("Two");System.out.println("Set after removing Two: " + set);// 删除 Map 元素Map<String, Integer> map = new HashMap<>();map.put("One", 1);map.put("Two", 2);map.put("Three", 3);map.remove("Two");System.out.println("Map after removing Two: " + map);}
}

高级集合操作

遍历集合

import java.util.*;public class TraverseCollection {public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));// 使用增强型 for 循环遍历 Listfor (String fruit : list) {System.out.println(fruit);}Set<String> set = new HashSet<>(Arrays.asList("One", "Two", "Three"));// 使用迭代器遍历 SetIterator<String> iterator = set.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}Map<String, Integer> map = new HashMap<>();map.put("One", 1);map.put("Two", 2);map.put("Three", 3);// 使用 entrySet 遍历 Mapfor (Map.Entry<String, Integer> entry : map.entrySet()) {System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());}}
}

集合转换

import java.util.*;public class CollectionConversion {public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));// List 转 SetSet<String> set = new HashSet<>(list);System.out.println("Set from List: " + set);// Set 转 ListList<String> listFromSet = new ArrayList<>(set);System.out.println("List from Set: " + listFromSet);// Map 转 Set of KeysMap<String, Integer> map = new HashMap<>();map.put("One", 1);map.put("Two", 2);map.put("Three", 3);Set<String> keySet = map.keySet();System.out.println("Set of Keys: " + keySet);// Map 转 Collection of ValuesCollection<Integer> values = map.values();System.out.println("Collection of Values: " + values);}
}

排序和查找

import java.util.*;public class SortAndSearch {public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("Banana", "Apple", "Cherry"));// 排序Collections.sort(list);System.out.println("Sorted List: " + list);// 查找元素int index = list.indexOf("Apple");System.out.println("Index of Apple: " + index);// 查找最大值和最小值String max = Collections.max(list);String min = Collections.min(list);System.out.println("Max: " + max + ", Min: " + min);}
}

线程安全的集合

import java.util.*;
import java.util.concurrent.*;public class ThreadSafeCollections {public static void main(String[] args) {// 使用 Vector 实现线程安全的 ListList<String> threadSafeList = new Vector<>();threadSafeList.add("Apple");threadSafeList.add("Banana");System.out.println("Thread-safe List: " + threadSafeList);// 使用 Hashtable 实现线程安全的 MapMap<String, Integer> threadSafeMap = new Hashtable<>();threadSafeMap.put("One", 1);threadSafeMap.put("Two", 2);System.out.println("Thread-safe Map: " + threadSafeMap);// 使用 ConcurrentHashMap 实现线程安全的 MapMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();concurrentMap.put("Three", 3);concurrentMap.put("Four", 4);System.out.println("Concurrent Map: " + concurrentMap);}
}

进阶操作

Java 8引入了许多新的集合操作功能，这些功能主要通过Stream API实现，使得对集合进行各种操作变得更加简洁和灵活。以下是对Java 8中对集合的主要操作及其示例的归纳：

创建流

从集合创建流

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> numberStream = numbers.stream();

中间操作

中间操作会返回一个新的流，允许多个操作连续进行。

filter：根据指定的条件过滤集合中的元素。

List<String> words = Arrays.asList("apple", "banana", "orange", "pear", "peach");
Stream<String> longWords = words.stream().filter(word -> word.length() >= 5);
longWords.forEach(System.out::println); // 输出长度大于等于5的单词

map：将集合中的每个元素映射为另一个元素。

List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredNums = nums.stream().map(n -> n * n).collect(Collectors.toList());
squaredNums.forEach(System.out::println); // 输出每个数字的平方

sorted：对集合中的元素进行排序。

List<String> sortedWords = words.stream().sorted((a, b) -> a.length() - b.length()).collect(Collectors.toList());
sortedWords.forEach(System.out::println); // 按长度升序排序的单词列表

distinct：去除集合中重复的元素。

List<Integer> distinctNums = nums.stream().distinct().collect(Collectors.toList());
distinctNums.forEach(System.out::println); // 去重后的数字列表

limit：限制集合中元素的数量。

List<Integer> limitedNums = nums.stream().limit(3).collect(Collectors.toList());
limitedNums.forEach(System.out::println); // 前3个数字

skip：跳过集合中指定数量的元素。

List<Integer> skippedNums = nums.stream().skip(3).collect(Collectors.toList());
skippedNums.forEach(System.out::println); // 跳过前3个数字后的列表

终端操作

终端操作会触发流的计算，并产生一个结果。

forEach：对集合中的每个元素执行某个操作。

nums.forEach(System.out::println); // 打印每个数字

collect：将流中的元素收集到一个集合中。

前面已经多次使用collect(Collectors.toList())来收集流中的元素到列表中，这里不再重复示例。

reduce：将集合中的元素进行累积运算，得到一个最终结果。

int sum = nums.stream().reduce(0, (a, b) -> a + b);
System.out.println("Sum: " + sum); // 输出数字总和

或者，使用无初始值的reduce方法（注意，这要求集合中的元素类型支持某种形式的累积运算，如数字相加）：

Optional<Integer> max = nums.stream().reduce(Integer::max);
max.ifPresent(System.out::println); // 输出最大值（如果存在）

count：统计集合中元素的数量。

long count = nums.stream().count();
System.out.println("Count: " + count); // 输出数字数量

max/min：获取集合中的最大/最小元素。

Optional<Integer> maxNum = nums.stream().max(Integer::compare);
maxNum.ifPresent(System.out::println); // 输出最大值（如果存在）Optional<Integer> minNum = nums.stream().min(Integer::compare);
minNum.ifPresent(System.out::println); // 输出最小值（如果存在）

anyMatch/allMatch/noneMatch：判断集合中是否存在/所有/不存在满足指定条件的元素。

boolean hasEven = nums.stream().anyMatch(n -> n % 2 == 0);
System.out.println("Has even: " + hasEven); // 是否存在偶数boolean allPositive = nums.stream().allMatch(n -> n > 0);
System.out.println("All positive: " + allPositive); // 是否所有数字都是正数boolean noNegative = nums.stream().noneMatch(n -> n < 0);
System.out.println("No negative: " + noNegative); // 是否不存在负数

findFirst/findAny：找出集合中第一个/任意一个符合条件的元素。

Optional<Integer> firstEven = nums.stream().filter(n -> n % 2 == 0).findFirst();
firstEven.ifPresent(System.out::println); // 输出第一个偶数（如果存在）Optional<Integer> anyEven = nums.stream().filter(n -> n % 2 == 0).findAny();
anyEven.ifPresent(System.out::println); // 输出任意一个偶数（如果存在）

其他操作

flatMap：将嵌套集合中的元素展平成一维集合。

List<List<Integer>> nestedNums = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4), Arrays.asList(5, 6));
List<Integer> flattenedNums = nestedNums.stream().flatMap(Collection::stream).collect(Collectors.toList());
flattenedNums.forEach(System.out::println); // 展平后的数字列表

partitioningBy：根据条件对集合进行分区，分成两个区域。

Map<Boolean, List<Integer>> partitionedNums = nums.stream().collect(Collectors.partitioningBy(n -> n % 2 == 0));
partitionedNums.forEach((key, value) -> {System.out.println("Key: " + key + ", Value: " + value); // 输出分区结果
});

以上示例涵盖了Java 中主要的集合操作，熟练这些操作，可以使得对集合进行各种处理变得更加简洁和高效。