HashSet去重函数

HashSet是Java中常用的无序、不重复的集合类。它底层是通过HashMap实现的，并且对于相同的元素，只会存储一次。因此，HashSet可以很好地帮助我们实现去重功能。

HashSet有两种构造方法：

- HashSet()：创建一个空HashSet。

- HashSet(Collection c)：创建一个包含指定集合中的元素的HashSet。

在我们使用HashSet时，需要先创建一个HashSet对象，然后调用其add()方法添加元素。当我们添加元素时，HashSet会自动判断该元素是否已经存在于集合中。如果不存在，则将其添加到集合中，如果已经存在，则不进行任何操作。

下面是一个使用HashSet去重的示例：

import java.util.HashSet;

public class RemoveDuplicateElements {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 5, 4, 3, 2, 1};

        HashSet<Integer> set = new HashSet<>();

        for (int i : arr) {
            set.add(i);
        }

        System.out.println(set); // 输出 [1, 2, 3, 4, 5]
    }
}

在上面的代码中，我们定义了一个整型数组arr，该数组包含重复元素。然后创建了一个HashSet对象set，并使用for-each循环依次将arr中的元素添加到set中。由于HashSet会自动去重，因此最终输出的set集合中不会包含重复元素。

当然，在实际开发中，我们可能会遇到更加复杂的数据结构，例如对象、数组、集合等。对于这些复杂的数据结构，我们可以编写相应的去重函数。

下面是一个去重数组中自定义对象的示例：

import java.util.Arrays;
import java.util.HashSet;

public class RemoveDuplicateObjects {

    public static void main(String[] args) {
        Person[] people = {
                new Person("张三", 18),
                new Person("李四", 20),
                new Person("王五", 18),
                new Person("张三", 18),
                new Person("李四", 20)
        };

        Person[] distinctPeople = removeDuplicateObjects(people);

        System.out.println(Arrays.toString(distinctPeople)); // 输出 [Person{name='张三', age=18}, Person{name='李四', age=20}, Person{name='王五', age=18}]
    }

    public static Person[] removeDuplicateObjects(Person[] arr) {
        HashSet<Person> set = new HashSet<>();

        for (Person p : arr) {
            set.add(p);
        }

        return set.toArray(new Person[0]);
    }

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

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + age;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

在上面的代码中，我们定义了一个Person类，该类包含name和age两个属性。然后创建一个Person类型的数组people，并包含重复元素。我们根据重写的equals()和hashCode()方法来判断是否相等。对于类中的每个对象，我们将其添加到HashSet集合set中，最终使用set的toArray()方法将所有去重后的元素转换为一个数组并返回。

当然，除了使用HashSet外，我们还可以使用其他数据结构来实现去重，例如使用TreeSet来自动排序去重，使用HashMap来快速定位去重等等。不同的数据结构可以针对不同的需求实现相应的去重功能。

总之，使用HashSet去重可以很好地帮助我们实现去重功能，并且HashSet还提供了丰富的API来帮助我们进行相关操作。在编写去重函数时，我们需要根据实际需求选择适合的数据结构，并结合具体场景进行优化，从而实现更好的性能和效率。