以下是结合Java 17及最新技术趋势的实操内容，通过具体案例演示Java集合的高级用法和性能优化。
一、Java集合框架的现代应用
1. 使用Record类简化数据模型
Java 16引入的Record类可大幅简化POJO定义，配合集合框架使用更高效：
// 使用Record简化订单模型（Java 16+）
record Order(String orderId, String productName, double amount) {
}
public class RecordExample {
public static void main(String[] args) {
Map<String, Order> orderMap = new HashMap<>();
// 简洁的对象创建
orderMap.put("ORD1001", new Order("ORD1001", "MacBook Pro", 12999.0));
orderMap.put("ORD1002", new Order("ORD1002", "iPhone 14", 8999.0));
// Stream流处理集合
orderMap.values().stream()
.filter(order -> order.amount() > 10000)
.forEach(System.out::println);
}
}
2. 集合工厂方法（Java 9+）
使用List.of()、Set.of()、Map.of()创建不可变集合：
// 创建不可变集合
List<String> immutableList = List.of("Java", "Kotlin", "Scala");
Set<Integer> immutableSet = Set.of(1, 2, 3);
Map<String, Integer> immutableMap = Map.of("A", 1, "B", 2);
二、HashMap性能优化实战
1. 初始容量与负载因子调优
根据业务场景预先设置合理的初始容量，避免频繁扩容：
// 预估存储1000个元素，计算初始容量以避免扩容
int expectedSize = 1000;
float loadFactor = 0.75f;
int initialCapacity = (int) (expectedSize / loadFactor) + 1;
Map<String, Product> productMap = new HashMap<>(initialCapacity, loadFactor);
2. 使用ConcurrentHashMap替代HashTable
在多线程环境下，优先使用ConcurrentHashMap而非线程安全但性能较差的HashTable：
// 多线程环境下的高效并发Map
ConcurrentHashMap<String, Integer> counterMap = new ConcurrentHashMap<>();
// 原子更新操作（Java 8+）
counterMap.compute("key", (k, v) -> v == null ? 1 : v + 1);
三、集合流操作与并行处理
1. 复杂数据处理示例
结合Stream API和Lambda表达式实现复杂业务逻辑：
import java.util.*;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
List<Product> products = Arrays.asList(
new Product("P001", "手机", 5999.0, Category.ELECTRONICS),
new Product("P002", "书籍", 89.0, Category.BOOKS),
new Product("P003", "耳机", 399.0, Category.ELECTRONICS),
new Product("P004", "T恤", 129.0, Category.CLOTHING)
);
// 按类别分组并计算每组总价
Map<Category, Double> totalByCategory = products.stream()
.collect(Collectors.groupingBy(
Product::category,
Collectors.summingDouble(Product::price)
));
// 并行流处理大数据集（谨慎使用）
long count = products.parallelStream()
.filter(p -> p.price() > 100)
.count();
}
}
enum Category {
ELECTRONICS, BOOKS, CLOTHING }
record Product(String id, String name, double price, Category category) {
}
2. 集合转换与扁平化
处理嵌套集合时使用flatMap进行扁平化：
// 扁平化嵌套集合
List<List<Integer>> nestedList = Arrays.asList(
Arrays.asList(1, 2),
Arrays.asList(3, 4, 5)
);
List<Integer> flattenedList = nestedList.stream()
.flatMap(Collection::stream)
.collect(Collectors.toList()); // [1, 2, 3, 4, 5]
四、TreeMap与自定义排序
1. 基于TreeMap的优先级队列
使用TreeMap实现按价格排序的商品集合：
// 按价格排序的商品集合
NavigableMap<Double, List<Product>> priceIndex = new TreeMap<>();
// 添加商品到价格索引
products.forEach(product -> {
priceIndex.computeIfAbsent(product.price(), k -> new ArrayList<>())
.add(product);
});
// 查询价格区间内的商品
SortedMap<Double, List<Product>> expensiveProducts =
priceIndex.tailMap(1000.0);
2. 自定义比较器示例
使用Lambda表达式定义复杂比较逻辑：
// 按多个字段排序的比较器
Comparator<Product> complexComparator =
Comparator.comparing(Product::category)
.thenComparingDouble(Product::price)
.reversed();
// 应用比较器排序
products.sort(complexComparator);
五、集合性能测试与调优工具
1. JMH微基准测试框架
使用JMH测试不同集合的性能差异：
import org.openjdk.jmh.annotations.*;
import java.util.*;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Fork(1)
@Warmup(iterations = 3)
@Measurement(iterations = 5)
public class CollectionBenchmark {
private static final int SIZE = 1000;
private List<Integer> arrayList = new ArrayList<>();
private List<Integer> linkedList = new LinkedList<>();
@Setup
public void setup() {
for (int i = 0; i < SIZE; i++) {
arrayList.add(i);
linkedList.add(i);
}
}
@Benchmark
public void arrayListGet() {
arrayList.get(SIZE / 2);
}
@Benchmark
public void linkedListGet() {
linkedList.get(SIZE / 2);
}
}
2. 使用VisualVM分析集合内存占用
通过VisualVM监控HashMap内存使用情况，识别内存泄漏：
- 启动Java程序并附加VisualVM
- 在"监视"选项卡查看堆内存使用
- 执行GC后查看集合对象的保留大小
- 使用"堆dump"分析具体对象占用情况
六、现代集合框架的最佳实践
- 优先使用泛型：避免类型转换错误
- 使用Stream API：替代传统for循环，提高代码可读性
- 选择合适的集合类型：
- 随机访问频繁：ArrayList
- 插入/删除频繁：LinkedList
- 键值对存储：HashMap
- 排序需求：TreeMap/TreeSet
- 初始化时指定容量：避免HashMap等动态扩容
- 使用不可变集合：通过
Collections.unmodifiable*或工厂方法创建 - 线程安全场景：使用
ConcurrentHashMap而非synchronizedMap - 避免原始类型集合：如
List rawList = new ArrayList();
通过这些实操案例，可以更深入理解Java集合框架的现代用法和性能优化技巧。在实际开发中，应根据具体业务场景选择合适的数据结构，并结合Stream API和Lambda表达式提升代码质量与效率。
Java 集合框架，ArrayList,LinkedList,HashMap,HashSet,ConcurrentHashMap, 集合遍历，泛型，并发集合，集合线程安全，集合性能优化，集合与 IO 流，集合序列化，Collections 工具类，Java8 集合新特性
资源地址：
https://pan.quark.cn/s/14fcf913bae6
