Day-02 Java 集合框架拓展与 Stream 流深度解析

ConcurrentHashMap 是线程安全的哈希表实现，它在多线程环境下能高效地进行并发操作。与传统的 Hashtable 相比，ConcurrentHashMap 采用了分段锁机制（Java 8 之前）或 CAS（Compare-And-Swap）算法（Java 8 及以后），大大提高了并发性能。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("apple", 1);
        map.put("banana", 2);
        System.out.println(map.get("apple"));
    }
}

1.1.2 `CopyOnWriteArrayList`

CopyOnWriteArrayList 是线程安全的列表实现，它在进行写操作（如 add、remove）时会创建一个新的数组副本，从而避免了在迭代过程中出现并发修改异常。不过，由于每次写操作都需要复制数组，所以写操作的性能相对较低，适合读多写少的场景。

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("element1");
        list.add("element2");
        for (String element : list) {
            System.out.println(element);
        }
    }
}

1.2 不可变集合

不可变集合是指创建后不能再修改的集合，它提供了更高的线程安全性和性能。Java 9 引入了一系列工厂方法来创建不可变集合。

1.2.1 不可变列表

import java.util.List;

public class ImmutableListExample {
    public static void main(String[] args) {
        List<String> immutableList = List.of("apple", "banana", "cherry");
        // 以下操作会抛出 UnsupportedOperationException
        // immutableList.add("date"); 
        System.out.println(immutableList);
    }
}

1.2.2 不可变集合

import java.util.Set;

public class ImmutableSetExample {
    public static void main(String[] args) {
        Set<String> immutableSet = Set.of("apple", "banana", "cherry");
        System.out.println(immutableSet);
    }
}

1.2.3 不可变映射

import java.util.Map;

public class ImmutableMapExample {
    public static void main(String[] args) {
        Map<String, Integer> immutableMap = Map.of("apple", 1, "banana", 2, "cherry", 3);
        System.out.println(immutableMap);
    }
}

二、Stream 流

2.1 Stream 流的概念

Stream 流是 Java 8 引入的一个新特性，它提供了一种高效且易于使用的方式来处理集合中的元素。Stream 流可以看作是一个元素序列，它支持各种聚合操作（如过滤、映射、排序等），并且可以并行处理，提高处理效率。

2.2 Stream 流的创建

可以通过集合、数组等方式创建 Stream 流。

2.2.1 从集合创建

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamCreationFromCollection {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        Stream<String> stream = list.stream();
    }
}

2.2.2 从数组创建

import java.util.stream.IntStream;

public class StreamCreationFromArray {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        IntStream stream = Arrays.stream(array);
    }
}

2.3 Stream 流的操作

Stream 流的操作分为中间操作和终端操作。中间操作会返回一个新的 Stream 流，而终端操作会触发流的处理并返回一个结果。

2.3.1 中间操作

过滤：使用 filter 方法过滤出满足条件的元素。

import java.util.Arrays;
import java.util.List;

public class StreamFilterExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.stream()
           .filter(s -> s.startsWith("a"))
           .forEach(System.out::println);
    }
}

映射：使用 map 方法将元素进行转换。

import java.util.Arrays;
import java.util.List;

public class StreamMapExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.stream()
           .map(String::toUpperCase)
           .forEach(System.out::println);
    }
}

排序：使用 sorted 方法对元素进行排序。

import java.util.Arrays;
import java.util.List;

public class StreamSortedExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.stream()
           .sorted()
           .forEach(System.out::println);
    }
}

2.3.2 终端操作

收集：使用 collect 方法将流中的元素收集到一个集合中。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamCollectExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        List<String> newList = list.stream()
                                   .filter(s -> s.startsWith("a"))
                                   .collect(Collectors.toList());
        System.out.println(newList);
    }
}

计数：使用 count 方法统计流中元素的数量。

import java.util.Arrays;
import java.util.List;

public class StreamCountExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        long count = list.stream()
                         .filter(s -> s.startsWith("a"))
                         .count();
        System.out.println(count);
    }
}

查找：使用 findFirst 或 findAny 方法查找流中的元素。

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class StreamFindExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        Optional<String> first = list.stream()
                                     .filter(s -> s.startsWith("a"))
                                     .findFirst();
        first.ifPresent(System.out::println);
    }
}

2.4 并行流

并行流是 Stream 流的一种特殊形式，它可以利用多核处理器的优势，并行处理流中的元素，从而提高处理效率。

import java.util.Arrays;
import java.util.List;

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        long sum = list.parallelStream()
                       .mapToInt(Integer::intValue)
                       .sum();
        System.out.println(sum);
    }
}

通过对集合框架拓展和 Stream 流的学习，我们可以更加高效地处理集合数据，提高 Java 程序的性能和可维护性。