五种经典的Java数组去重算法详解

五种经典的Java数组去重算法详解

在Java编程中，经常会遇到需要对数组进行去重操作的情况，即去除数组中的重复元素，保留唯一的元素。下面将介绍五种经典的Java数组去重算法，并提供相应的代码示例。

1. 使用HashSet
   HashSet是Java中的一个集合类，它会自动去除重复元素，利用这一特性可以快速实现数组去重。
   代码示例：

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

public class ArrayDeduplicateExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 2, 4, 3, 5};
        
        HashSet<Integer> set = new HashSet<>();
        for (int i : array) {
            set.add(i);
        }
        
        int[] result = new int[set.size()];
        int index = 0;
        for (int i : set) {
            result[index++] = i;
        }
        
        System.out.println(Arrays.toString(result));
    }
}

2. 使用TreeSet
   TreeSet是Java中的有序集合类，它会自动去重并排序元素。通过将数组中的元素添加到TreeSet中，再将TreeSet转为数组，就可以实现数组去重。
   代码示例：

import java.util.Arrays;
import java.util.TreeSet;

public class ArrayDeduplicateExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 2, 4, 3, 5};
        
        TreeSet<Integer> set = new TreeSet<>();
        for (int i : array) {
            set.add(i);
        }
        
        Integer[] result = set.toArray(new Integer[0]);
        int[] deduplicatedArray = Arrays.stream(result).mapToInt(Integer::intValue).toArray();
        
        System.out.println(Arrays.toString(deduplicatedArray));
    }
}

3. 使用Stream API
   Java 8及以上版本引入的Stream API可以简化数组去重操作。通过将数组转为流，利用流的distinct方法去除重复元素，再转为数组即可。
   代码示例：

import java.util.Arrays;

public class ArrayDeduplicateExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 2, 4, 3, 5};
        
        int[] deduplicatedArray = Arrays.stream(array).distinct().toArray();
        
        System.out.println(Arrays.toString(deduplicatedArray));
    }
}

4. 使用双重循环
   双重循环是一种常见的数组去重算法，通过比较相邻元素，将重复元素置为一个指定的非法值，然后再进行去除非法值操作。
   代码示例：

import java.util.Arrays;

public class ArrayDeduplicateExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 2, 4, 3, 5};
        
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i] != Integer.MIN_VALUE) {
                for (int j = i + 1; j < array.length; j++) {
                    if (array[i] == array[j]) {
                        array[j] = Integer.MIN_VALUE;
                    }
                }
            }
        }
        
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] != Integer.MIN_VALUE) {
                array[count++] = array[i];
            }
        }
        
        int[] deduplicatedArray = Arrays.copyOf(array, count);
        
        System.out.println(Arrays.toString(deduplicatedArray));
    }
}

5. 使用HashMap
   HashMap是Java中的一个哈希表结构，通过使用HashMap的put方法将数组元素作为键插入，如果键已经存在则会自动去除重复元素。
   代码示例：

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class ArrayDeduplicateExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 2, 4, 3, 5};
        
        Map<Integer, Object> map = new HashMap<>();
        for (int i : array) {
            map.put(i, null);
        }
        
        int[] deduplicatedArray = new int[map.size()];
        int index = 0;
        for (int i : map.keySet()) {
            deduplicatedArray[index++] = i;
        }
        
        System.out.println(Arrays.toString(deduplicatedArray));
    }
}

以上是五种经典的Java数组去重算法的详细介绍和代码示例。实际应用中，根据具体情况选择适合的去重算法，可以提高程序的性能和可读性。

以上就是五种经典的Java数组去重算法详解的详细内容，更多请关注php中文网其它相关文章！