五種經典的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中文網其他相關文章！