【 JAVA中常见的集合操作】

JAVA中常见的集合操作

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

基本集合操作

创建集合

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

java 复制代码

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);
    }
}

访问元素

java 复制代码

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());
        }
    }
}

修改集合

java 复制代码

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);
 
        // 添加元素到 Set
        Set<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);
    }
}

删除元素

java 复制代码

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);
    }
}

高级集合操作

遍历集合

java 复制代码

import java.util.*;
 
public class TraverseCollection {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));
 
        // 使用增强型 for 循环遍历 List
        for (String fruit : list) {
            System.out.println(fruit);
        }
 
        Set<String> set = new HashSet<>(Arrays.asList("One", "Two", "Three"));
 
        // 使用迭代器遍历 Set
        Iterator<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 遍历 Map
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

集合转换

java 复制代码

import java.util.*;
 
public class CollectionConversion {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));
 
        // List 转 Set
        Set<String> set = new HashSet<>(list);
        System.out.println("Set from List: " + set);
 
        // Set 转 List
        List<String> listFromSet = new ArrayList<>(set);
        System.out.println("List from Set: " + listFromSet);
 
        // Map 转 Set of Keys
        Map<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 Values
        Collection<Integer> values = map.values();
        System.out.println("Collection of Values: " + values);
    }
}

排序和查找

java 复制代码

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);
    }
}

线程安全的集合

java 复制代码

import java.util.*;
import java.util.concurrent.*;
 
public class ThreadSafeCollections {
    public static void main(String[] args) {
        // 使用 Vector 实现线程安全的 List
        List<String> threadSafeList = new Vector<>();
        threadSafeList.add("Apple");
        threadSafeList.add("Banana");
        System.out.println("Thread-safe List: " + threadSafeList);
 
        // 使用 Hashtable 实现线程安全的 Map
        Map<String, Integer> threadSafeMap = new Hashtable<>();
        threadSafeMap.put("One", 1);
        threadSafeMap.put("Two", 2);
        System.out.println("Thread-safe Map: " + threadSafeMap);
 
        // 使用 ConcurrentHashMap 实现线程安全的 Map
        Map<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中对集合的主要操作及其示例的归纳：

创建流

从集合创建流

java 复制代码

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

中间操作

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

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

java 复制代码

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：将集合中的每个元素映射为另一个元素。

java 复制代码

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：对集合中的元素进行排序。

java 复制代码

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

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

java 复制代码

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

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

java 复制代码

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

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

java 复制代码

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

终端操作

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

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

java 复制代码

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

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

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

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

java 复制代码

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

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

java 复制代码

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

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

java 复制代码

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

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

java 复制代码

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：判断集合中是否存在/所有/不存在满足指定条件的元素。

java 复制代码

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：找出集合中第一个/任意一个符合条件的元素。

java 复制代码

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：将嵌套集合中的元素展平成一维集合。

java 复制代码

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：根据条件对集合进行分区，分成两个区域。

java 复制代码

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 中主要的集合操作，熟练这些操作，可以使得对集合进行各种处理变得更加简洁和高效。