List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4);
List<Integer> unique = numbers.stream()
    .distinct()
    .collect(Collectors.toList());  // [1, 2, 3, 4]

// ReferencePipeline.java
public final Stream<P_OUT> distinct() {
    return new DistinctOps<P_OUT, P_OUT>(this);
}
 
// DistinctOps.java
@Override
public void accept(P_OUT t) {
    if (set.add(t)) {  // 調(diào)用HashSet的add方法，返回false表示重復(fù)
        down.accept(t);
    }
}

+----------------+     +----------------+     +----------------+
|  子任務(wù)1: HashSet |---->|  子任務(wù)2: HashSet |---->|  合并階段: HashMap |
|  存儲(chǔ)元素A,B,C   |     |  存儲(chǔ)元素B,D,E   |     |  最終結(jié)果A,B,C,D,E |
+----------------+     +----------------+     +----------------+

class User {
    private String id;
    private String name;
    
    @Override
    public int hashCode() {
        return Objects.hash(id);  // 僅用id計(jì)算哈希值
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);  // 僅比較id
    }
    // 其他方法省略
}
 
// 使用示例
List<User> users = Arrays.asList(
    new User("1", "Alice"),
    new User("1", "Bob"),  // id相同，會(huì)被去重
    new User("2", "Charlie")
);
List<User> uniqueUsers = users.stream()
    .distinct()
    .collect(Collectors.toList());  // 保留兩個(gè)用戶

class ErrorUser {
    private String id;
    // 錯(cuò)誤：未重寫hashCode
    @Override
    public boolean equals(Object o) {
        // 正確實(shí)現(xiàn)equals...
    }
}
// 使用distinct時(shí)，兩個(gè)id相同的ErrorUser可能因hashCode不同被視為不同元素

// 優(yōu)化前：無序流去重
List<Integer> randomData = getRandomNumbers(1000000);
randomData.stream().distinct().count();  // 全量哈希表查找
 
// 優(yōu)化后：先排序再去重
randomData.stream()
    .sorted()
    .distinct()
    .count();  // 相鄰重復(fù)元素只需一次比較

// 低效：對(duì)象流裝箱
Stream<Integer> boxedStream = data.stream().distinct();
 
// 高效：IntStream直接操作
IntStream primitiveStream = data.stream().mapToInt(Integer::intValue).distinct();

// 分塊去重示例
int chunkSize = 100000;
List<Integer> result = new ArrayList<>();
for (int i = 0; i < data.size(); i += chunkSize) {
    int end = Math.min(i + chunkSize, data.size());
    List<Integer> chunk = data.subList(i, end);
    result.addAll(chunk.stream().distinct().collect(Collectors.toList()));
}
// 最后再去重一次合并結(jié)果
List<Integer> finalResult = result.stream().distinct().collect(Collectors.toList());

class EfficientSpliterator implements Spliterator<Integer> {
    private final List<Integer> list;
    private int index;
    private static final int CHUNK_SIZE = 10000;  // 分塊大小
    
    public EfficientSpliterator(List<Integer> list) {
        this.list = list;
        this.index = 0;
    }
    
    @Override
    public Spliterator<Integer> trySplit() {
        int size = list.size() - index;
        if (size < CHUNK_SIZE) return null;
        int splitPos = index + size / 2;
        Spliterator<Integer> spliterator = 
            new EfficientSpliterator(list.subList(index, splitPos));
        index = splitPos;
        return spliterator;
    }
    // 其他方法省略...
}
 
// 使用示例
List<Integer> data = ...;
Stream<Integer> optimizedStream = StreamSupport.stream(
    new EfficientSpliterator(data), true);  // 啟用并行

class Product {
    private String id;
    private String name;
    private double price;
    // 構(gòu)造器、getter省略
}
 
// 按id去重
List<Product> uniqueProducts = products.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.toMap(Product::getId, p -> p, (p1, p2) -> p1),
        map -> new ArrayList<>(map.values())
    ));

class LogEntry {
    private String message;
    private long timestamp;
    // 構(gòu)造器、getter省略
}
 
List<LogEntry> latestLogs = logs.stream()
    .collect(Collectors.toMap(
        LogEntry::getMessage, 
        entry -> entry, 
        (oldEntry, newEntry) -> newEntry.getTimestamp() > oldEntry.getTimestamp() 
            ? newEntry : oldEntry
    ))
    .values()
    .stream()
    .collect(Collectors.toList());

List<String> fuzzyUnique = strings.stream()
    .filter(s -> !strings.stream()
        .anyMatch(t -> s != t && levenshteinDistance(s, t) < 2))
    .collect(Collectors.toList());