java循环如何去重

在Java中，去重循环的核心方法包括使用集合类（如HashSet）、使用双重循环、使用Stream API。其中，使用集合类是最为常见和高效的方法。下面我们将详细探讨这些方法，并举例说明如何在不同场景下应用它们。

一、使用集合类去重

集合类（如HashSet）是Java提供的一种数据结构，它不允许存储重复的元素。利用这一特性，可以非常方便地去除重复元素。

1.1 HashSet去重

HashSet 是一个最常用的集合类，它基于哈希表实现，不允许存储重复元素。以下是一个简单的例子，演示如何使用HashSet去重：

import java.util.HashSet;
public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 2, 3, 4, 4, 5};
        HashSet<Integer> set = new HashSet<>();
        for (int number : numbers) {
            set.add(number);
        }
        System.out.println(set);
    }
}

在这个例子中，HashSet自动处理了重复元素，最终输出的集合中不包含任何重复的数字。

1.2 TreeSet去重

TreeSet 是另一个集合类，它不仅可以去重，还可以对元素进行自然排序。

import java.util.TreeSet;
public class Main {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 1, 2, 2, 4, 4};
        TreeSet<Integer> set = new TreeSet<>();
        for (int number : numbers) {
            set.add(number);
        }
        System.out.println(set);
    }
}

在这个例子中，TreeSet不仅去除了重复元素，还对剩下的元素进行了排序。

二、双重循环去重

尽管集合类提供了便捷的去重方法，有时我们可能需要手动实现去重逻辑。双重循环是一种传统且有效的方法。

2.1 双重循环去重示例

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 2, 3, 4, 4, 5};
        int[] uniqueNumbers = new int[numbers.length];
        int uniqueCount = 0;
        for (int i = 0; i < numbers.length; i++) {
            boolean isUnique = true;
            for (int j = 0; j < uniqueCount; j++) {
                if (numbers[i] == uniqueNumbers[j]) {
                    isUnique = false;
                    break;
                }
            }
            if (isUnique) {
                uniqueNumbers[uniqueCount++] = numbers[i];
            }
        }
        for (int i = 0; i < uniqueCount; i++) {
            System.out.print(uniqueNumbers[i] + " ");
        }
    }
}

在这个例子中，外层循环遍历原始数组的每一个元素，内层循环检查该元素是否已经存在于结果数组中。如果不存在，则将其添加到结果数组。

三、使用Stream API去重

Java 8引入的Stream API提供了更加简洁和优雅的去重方法。利用Stream的distinct()方法，可以轻松实现去重。

3.1 使用Stream API去重示例

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
        List<Integer> uniqueNumbers = numbers.stream()
                                             .distinct()
                                             .collect(Collectors.toList());
        System.out.println(uniqueNumbers);
    }
}

在这个例子中，distinct()方法用于去除Stream中的重复元素，collect(Collectors.toList())用于将结果收集到一个列表中。

四、去重的复杂场景

有时，去重操作不仅限于简单的数据类型，还可能涉及复杂对象。下面我们将探讨在复杂场景下如何进行去重。

4.1 使用HashSet去重复杂对象

当我们需要去重的元素是复杂对象（如自定义类的实例）时，需要重写类的hashCode()和equals()方法。

import java.util.HashSet;
class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int hashCode() {
        return name.hashCode() + age;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }
}
public class Main {
    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();
        set.add(new Person("Alice", 30));
        set.add(new Person("Bob", 25));
        set.add(new Person("Alice", 30));
        System.out.println(set);
    }
}

在这个例子中，重写hashCode()和equals()方法确保了HashSet能够正确识别和去除重复的Person对象。

五、性能和优化

选择合适的去重方法不仅取决于代码的简洁性，还取决于性能需求。以下是一些性能优化的建议：

5.1 使用适当的数据结构

对于大多数场景，使用HashSet是最优的选择，因为其时间复杂度为O(1)。但如果需要排序，可以考虑TreeSet，尽管其时间复杂度为O(log n)。

5.2 避免不必要的循环

在选择双重循环去重时，注意避免不必要的循环，以提高性能。例如，可以使用标记数组来减少内层循环的次数。

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 2, 3, 4, 4, 5};
        boolean[] isDuplicate = new boolean[numbers.length];
        int uniqueCount = 0;
        for (int i = 0; i < numbers.length; i++) {
            if (!isDuplicate[i]) {
                for (int j = i + 1; j < numbers.length; j++) {
                    if (numbers[i] == numbers[j]) {
                        isDuplicate[j] = true;
                    }
                }
                numbers[uniqueCount++] = numbers[i];
            }
        }
        for (int i = 0; i < uniqueCount; i++) {
            System.out.print(numbers[i] + " ");
        }
    }
}

这个例子中，使用一个布尔数组标记已经发现的重复元素，避免了不必要的内层循环。

六、总结

在Java中，去重循环的方法多种多样，包括使用集合类（如HashSet、TreeSet）、使用双重循环、使用Stream API等。根据具体的需求和场景，选择合适的方法可以提高代码的简洁性和性能。对于简单数据类型，集合类通常是最优的选择；而在处理复杂对象时，重写hashCode()和equals()方法是必要的。此外，性能优化也是不可忽视的重要方面，通过选择合适的数据结构和避免不必要的循环，可以显著提高去重操作的效率。