Penyahduaan tatasusunan Java: Bermula dan menguasai lima kaedah biasa

Dari Pemula hingga Penguasaan: Lima Cara Biasa untuk Menyahduplikasi Tatasusunan Java

Pengenalan: Dalam pembangunan Java, operasi tatasusunan adalah salah satu operasi yang paling biasa. Deduplikasi tatasusunan adalah salah satu masalah yang sering dihadapi. Dalam artikel ini, kami akan memperkenalkan lima cara biasa untuk melaksanakan penyahduplikasi tatasusunan Java untuk membantu anda bermula daripada menjadi mahir dalam penyahduplikasian tatasusunan.

1. Gunakan koleksi Set
Cara biasa ialah menggunakan ciri koleksi Set untuk mencapai penyahduplikasian tatasusunan. Koleksi set ialah koleksi yang tidak membenarkan elemen pendua, jadi meletakkan elemen tatasusunan ke dalam koleksi Set akan mengalih keluar elemen pendua secara automatik.

Contoh kod:

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));
    }
}

2. Gunakan gelung traversal
Satu lagi cara biasa ialah menggunakan gelung untuk merentasi tatasusunan, tentukan sama ada elemen diulang satu demi satu dan meletakkan elemen tidak berulang ke dalam tatasusunan baharu.

Contoh kod:

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));
    }
}

3 Menggunakan Strim
Selepas Java 8, konsep operasi penstriman diperkenalkan, yang boleh mengendalikan koleksi dan tatasusunan dengan mudah. Elemen pendua boleh dialih keluar menggunakan kaedah distinct() bagi aliran Strim.

Contoh kod:

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));
    }
}

4 Gunakan HashMap
Menggunakan HashMap untuk mencapai penyahduplikasi tatasusunan juga merupakan cara biasa. Lintas tatasusunan, letakkan elemen tatasusunan sebagai Kunci ke dalam HashMap, elemen pendua akan ditimpa dan akhirnya keluarkan Kunci daripada HashMap.

Contoh kod:

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));
    }
}

5. Gunakan rekursi
Rekursi ialah teknik pengaturcaraan lanjutan yang boleh digunakan untuk mencapai penyahduplikasi tatasusunan. Setiap rekursi membandingkan elemen pertama tatasusunan dengan elemen berikut Jika ia adalah sama, elemen berikut dialih keluar sehingga rekursi tamat.

Contoh kod:

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);
        }
    }
}

Kesimpulan: Melalui lima kaedah biasa di atas, kami boleh melaksanakan operasi penyahduplikasi tatasusunan Java dengan mudah. Sama ada kami menggunakan koleksi Set, traversal gelung, Aliran Strim, HashMap atau rekursi, ini boleh membantu kami mengendalikan keperluan penyahduplikasi tatasusunan dengan lebih baik. Saya harap artikel ini dapat membantu anda daripada mula menjadi mahir dalam deduplikasi tatasusunan Java.

Atas ialah kandungan terperinci Penyahduaan tatasusunan Java: Bermula dan menguasai lima kaedah biasa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!