Java陣列去重：五種常用方法的入門與精通

從入門到精通：Java陣列去重的五種常用方式

導語：在Java開發中，陣列運算是非常常見的操作之一。而陣列去重則是常遇到的問題之一。在本文中，我們將介紹五種常用的方式來實作Java陣列去重，幫助你從入門到精通陣列去重的操作。

一、使用Set集合
常見的方式是利用Set集合的特性來實現陣列去重。 Set集合是不允許重複元素的集合，所以將陣列的元素放入Set集合中，自動移除重複元素。

程式碼範例：

import java.util.*;

public class ArrayDuplicateRemover {
    public static void main(String[] args) {
        // 原始数组
        Integer[] array = {1, 2, 3, 4, 3, 2, 1};
        
        // 利用Set集合去重
        Set<Integer> set = new HashSet<>(Arrays.asList(array));
        
        // 去重后的数组
        Integer[] result = set.toArray(new Integer[0]);
        
        // 打印结果
        System.out.println(Arrays.toString(result));
    }
}

二、利用循環遍歷
另一種常見的方式是利用循環遍歷數組，逐個判斷元素是否重複，並將不重複的元素放入新的數組中。

程式碼範例：

import java.util.Arrays;

public class ArrayDuplicateRemover {
    public static void main(String[] args) {
        // 原始数组
        Integer[] array = {1, 2, 3, 4, 3, 2, 1};
        
        // 借助循环遍历去重
        Integer[] result = new Integer[array.length];
        int index = 0;
        for (Integer num : array) {
            boolean isDuplicate = false;
            for (int i = 0; i < index; i++) {
                if (num == result[i]) {
                    isDuplicate = true;
                    break;
                }
            }
            if (!isDuplicate) {
                result[index++] = num;
            }
        }
        
        // 去重后的数组
        result = Arrays.copyOf(result, index);
        
        // 打印结果
        System.out.println(Arrays.toString(result));
    }
}

三、利用Stream流
在Java 8之後，引入了串流運算的概念，可以方便地處理集合和陣列。利用Stream流的distinct()方法可以去除重複元素。

程式碼範例：

import java.util.Arrays;

public class ArrayDuplicateRemover {
    public static void main(String[] args) {
        // 原始数组
        Integer[] array = {1, 2, 3, 4, 3, 2, 1};
        
        // 利用Stream流去重
        Integer[] result = Arrays.stream(array).distinct().toArray(Integer[]::new);
        
        // 打印结果
        System.out.println(Arrays.toString(result));
    }
}

四、利用HashMap
使用HashMap來實作陣列去重也是常用的方式。遍歷數組，將數組元素作為Key放入HashMap中，重複的元素會被覆蓋，最後將HashMap中的Key取出即可。

程式碼範例：

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

public class ArrayDuplicateRemover {
    public static void main(String[] args) {
        // 原始数组
        Integer[] array = {1, 2, 3, 4, 3, 2, 1};
        
        // 利用HashMap去重
        Map<Integer, Integer> map = new HashMap<>();
        for (Integer num : array) {
            map.put(num, num);
        }
        Integer[] result = map.keySet().toArray(new Integer[0]);
        
        // 打印结果
        System.out.println(Arrays.toString(result));
    }
}

五、利用遞迴
遞迴是一種高階的程式設計技巧，可以利用遞迴實作陣列去重。每次遞迴將陣列的第一個元素與後面的元素比較，若相同則去掉後面的元素，直到遞迴結束。

程式碼範例：

import java.util.Arrays;

public class ArrayDuplicateRemover {
    public static void main(String[] args) {
        // 原始数组
        Integer[] array = {1, 2, 3, 4, 3, 2, 1};
        
        // 利用递归去重
        Integer[] result = removeDuplicates(array, array.length);
        
        // 打印结果
        System.out.println(Arrays.toString(result));
    }
    
    public static Integer[] removeDuplicates(Integer[] array, int length) {
        if (length == 1) {
            return array;
        }
        
        if (array[0] == array[length-1]) {
            return removeDuplicates(Arrays.copyOf(array, length-1), length-1);
        } else {
            return removeDuplicates(array, length-1);
        }
    }
}

結語：透過以上五種常用的方式，我們可以輕鬆實現Java陣列去重操作。無論是利用Set集合、循環遍歷、Stream流、HashMap或遞歸，都能幫助我們更好地處理數組去重的需求。希望本文能幫助你從入門到精通Java陣列去重。

以上是Java陣列去重：五種常用方法的入門與精通的詳細內容。更多資訊請關注PHP中文網其他相關文章！