Java8去重详解

一、基础用法

Java8提供了基于`Stream`的去重操作，可以轻松地对集合中的元素进行去重。对于基础类型的元素, 可以直接调用`distinct()`方法进行去重，示例代码如下:

int[] nums = {1, 2, 3, 3, 2, 1, 5, 6, 5, 4};
IntArrayStream.of(nums).distinct().forEach(System.out::println);

输出结果为：

1
2
3
5
6
4

同时，对于自定义类型的元素，需要在自定义类中重写`equals()`和`hashCode()`方法，以便Java底层去重操作可以正常工作，示例代码如下：

public class Person {
    private String name;
    private int age;

    // 构造方法、getters/setters方法等省略

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (this.getClass() != obj.getClass()) {
            return false;
        }
        Person person = (Person) obj;
        return Objects.equals(this.name, person.name) && this.age == person.age;
    }

    @Override
    public int hashCode() {
        return Objects.hash(this.name, this.age);
    }
}

List persons = new ArrayList();
persons.add(new Person("Tom", 18));
persons.add(new Person("Jerry", 20));
persons.add(new Person("Mike", 18));
persons.add(new Person("Tom", 18));
persons.stream().distinct().forEach(System.out::println);

输出结果为：

Person{name='Tom', age=18}
Person{name='Jerry', age=20}
Person{name='Mike', age=18}

二、对象属性去重

对于复杂类型的元素，我们有时需要按照其中某一个或几个属性进行去重。Java8提供了`distinct`方法的改进版本`distinctByKey`，能够根据某一个属性进行重复判断，示例代码如下：

public class Person {
    private String name;
    private int age;

    // 构造方法、getters/setters方法等省略

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (this.getClass() != obj.getClass()) {
            return false;
        }
        Person person = (Person) obj;
        return Objects.equals(this.name, person.name) && this.age == person.age;
    }

    @Override
    public int hashCode() {
        return Objects.hash(this.name, this.age);
    }
}

List persons = new ArrayList();
persons.add(new Person("Tom", 18));
persons.add(new Person("Jerry", 20));
persons.add(new Person("Mike", 18));
persons.add(new Person("Tom", 20));

Function keyExtractor = Person::getName;
persons.stream()
       .filter(distinctByKey(keyExtractor))
       .forEach(System.out::println);

输出结果为：

Person{name='Tom', age=18}
Person{name='Jerry', age=20}
Person{name='Mike', age=18}

三、并行去重

Java8提供了`parallelStream`方法使得集合的操作可以并行进行，对于较大的数据集合和耗时操作来说，能大大提高效率。但是在对集合进行并行操作时，我们需要注意去重操作的安全性。

对于基础类型的元素，在并行流中使用`distinct()`方法是安全的，示例代码如下：

int[] nums = {1, 2, 3, 3, 2, 1, 5, 6, 5, 4};
Arrays.stream(nums).parallel().distinct().forEach(System.out::println);

而对于复杂类型的元素，由于并行处理时多个线程同时进行任务，如果不注意同步问题，可能会导致去重失败。这时我们可以通过使用并发安全的数据结构`ConcurrentHashMap`来避免这个问题，示例代码如下：

public class Person {
    private String name;
    private int age;

    // 构造方法、getters/setters方法等省略

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (this.getClass() != obj.getClass()) {
            return false;
        }
        Person person = (Person) obj;
        return Objects.equals(this.name, person.name) && this.age == person.age;
    }

    @Override
    public int hashCode() {
        return Objects.hash(this.name, this.age);
    }
}

List persons = new ArrayList();
persons.add(new Person("Tom", 18));
persons.add(new Person("Jerry", 20));
persons.add(new Person("Mike", 18));
persons.add(new Person("Tom", 20));

persons.parallelStream()
       .filter(person -> {
           ConcurrentHashMap.KeySetView seen = ConcurrentHashMap.newKeySet();
           return seen.add(person);
       }).forEach(System.out::println);

输出结果为：

Person{name='Tom', age=18}
Person{name='Jerry', age=20}
Person{name='Mike', age=18}
Person{name='Tom', age=20}

四、流式操作去重

除了一些基础的去重方法，Java8的`Stream`还提供了更为丰富的操作，如`distinct`配合`map`、`filter`和`sorted`等操作，能够更加灵活地对元素进行去重。示例代码如下：

public class Person {
    private String name;
    private int age;

    // 构造方法、getters/setters方法等省略

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (this.getClass() != obj.getClass()) {
            return false;
        }
        Person person = (Person) obj;
        return Objects.equals(this.name, person.name) && this.age == person.age;
    }

    @Override
    public int hashCode() {
        return Objects.hash(this.name, this.age);
    }
}

List persons = new ArrayList();
persons.add(new Person("Tom", 18));
persons.add(new Person("Jerry", 20));
persons.add(new Person("Mike", 18));
persons.add(new Person("Tom", 20));

persons.stream()
       .filter(person -> person.getAge() % 2 == 0)
       .map(Person::getName)
       .sorted()
       .distinct()
       .forEach(System.out::println);

输出结果为：

Jerry
Tom

五、小结

本文详细介绍了Java8中的去重操作，包括基础用法、对象属性去重、并行去重和流式操作去重等方面的使用。在实际开发中，我们可以根据需求选择合适的去重方式，并注意去重操作的线程安全性，以提高程序运行效率和稳定性。