Java集合高级特性详解

并发集合

ConcurrentHashMap

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class ConcurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        Runnable writer = () -> {
            for (int i = 0; i < 1000; i++) {
                map.put("key" + i, i);
            }
        };

        Runnable reader = () -> {
            for (int i = 0; i < 1000; i++) {
                map.get("key" + i);
            }
        };

        Thread[] writers = new Thread[5];
        Thread[] readers = new Thread[5];

        for (int i = 0; i < 5; i++) {
            writers[i] = new Thread(writer);
            readers[i] = new Thread(reader);
        }

        for (Thread t : writers) t.start();
        for (Thread t : readers) t.start();

        for (Thread t : writers) t.join();
        for (Thread t : readers) t.join();

        System.out.println("最终大小: " + map.size());
    }
}

CopyOnWriteArrayList

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListDemo {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();

        Runnable writer = () -> {
            for (int i = 0; i < 1000; i++) {
                list.add(i);
            }
        };

        Runnable reader = () -> {
            for (int i = 0; i < 1000; i++) {
                if (!list.isEmpty()) {
                    list.get(0);
                }
            }
        };

        Thread t1 = new Thread(writer);
        Thread t2 = new Thread(reader);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("列表大小: " + list.size());
    }
}

CopyOnWriteArraySet

import java.util.concurrent.CopyOnWriteArraySet;

public class CopyOnWriteArraySetDemo {
    public static void main(String[] args) {
        CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<>();

        for (int i = 0; i < 10; i++) {
            set.add("元素" + i);
        }

        set.add("元素0");

        System.out.println("集合大小: " + set.size());
        set.forEach(System.out::println);
    }
}

不可变集合

使用Collections.unmodifiable*

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UnmodifiableCollectionDemo {
    public static void main(String[] args) {
        List<String> mutableList = new ArrayList<>(List.of("Java", "Python", "C++"));
        List<String> immutableList = Collections.unmodifiableList(mutableList);

        System.out.println("不可变列表: " + immutableList);

        try {
            immutableList.add("Go");
        } catch (UnsupportedOperationException e) {
            System.out.println("不能修改不可变集合");
        }

        mutableList.add("Go");
        System.out.println("修改后不可变视图: " + immutableList);

        Map<String, Integer> mutableMap = new HashMap<>(Map.of("Java", 100, "Python", 90));
        Map<String, Integer> immutableMap = Collections.unmodifiableMap(mutableMap);

        try {
            immutableMap.put("C++", 85);
        } catch (UnsupportedOperationException e) {
            System.out.println("不能修改不可变Map");
        }
    }
}

Java 9+ 不可变集合工厂方法

import java.util.List;
import java.util.Map;
import java.util.Set;

public class ImmutableFactoryDemo {
    public static void main(String[] args) {
        List<String> list = List.of("Java", "Python", "C++");
        System.out.println("List.of: " + list);

        Set<Integer> set = Set.of(1, 2, 3, 4, 5);
        System.out.println("Set.of: " + set);

        Map<String, Integer> map = Map.of(
            "Java", 100,
            "Python", 90,
            "C++", 85
        );
        System.out.println("Map.of: " + map);

        List<String> listOfNullable = List.ofNullable("Java");
        System.out.println("List.ofNullable: " + listOfNullable);
    }
}

集合性能优化

预分配容量

import java.util.ArrayList;
import java.util.HashMap;

public class CapacityOptimization {
    public static void main(String[] args) {
        int expectedSize = 10000;

        ArrayList<String> list = new ArrayList<>(expectedSize);
        for (int i = 0; i < expectedSize; i++) {
            list.add("item" + i);
        }

        HashMap<String, Integer> map = new HashMap<>((int) (expectedSize / 0.75) + 1);
        for (int i = 0; i < expectedSize; i++) {
            map.put("key" + i, i);
        }

        System.out.println("优化完成");
    }
}

选择合适的集合

import java.util.*;

public class CollectionSelection {
    public static void main(String[] args) {
        List<Integer> arrayList = new ArrayList<>();
        List<Integer> linkedList = new LinkedList<>();

        for (int i = 0; i < 100000; i++) {
            arrayList.add(i);
            linkedList.add(i);
        }

        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            arrayList.get(i);
        }
        long arrayTime = System.nanoTime() - start;

        start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            linkedList.get(i);
        }
        long linkedTime = System.nanoTime() - start;

        System.out.println("ArrayList随机访问: " + arrayTime + "ns");
        System.out.println("LinkedList随机访问: " + linkedTime + "ns");
    }
}

Streams与集合

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

public class StreamCollectionDemo {
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie", "David");

        List<String> upperNames = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());
        System.out.println("大写名称: " + upperNames);

        Map<Integer, List<String>> grouped = names.stream()
            .collect(Collectors.groupingBy(String::length));
        System.out.println("按长度分组: " + grouped);

        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Map<Boolean, List<Integer>> partitioned = numbers.stream()
            .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        System.out.println("偶数奇数分区: " + partitioned);
    }
}

集合最佳实践总结

1. 根据使用场景选择合适的集合类型
2. 并发场景使用并发集合类
3. 需要不可变集合时使用工厂方法或包装器
4. 预估集合大小并预分配容量
5. 使用Stream API简化集合操作

总结

掌握Java集合的高级特性，包括并发集合、不可变集合和性能优化技巧，能帮助你编写更高效、更安全的Java程序。