Analisis mendalam tentang lima kaedah praktikal untuk penyahduplikasian dalam tatasusunan Java

Analisis mendalam tentang lima kaedah praktikal penyahduplikasi tatasusunan Java

Di Java, tatasusunan pemprosesan ialah operasi yang sangat biasa. Deduplikasi tatasusunan adalah masalah yang sering dihadapi dalam pembangunan sebenar. Artikel ini akan menyediakan analisis mendalam tentang lima kaedah praktikal untuk penyahduplikasi tatasusunan Java dan menyediakan contoh kod khusus.

1. Gunakan HashSet untuk membuang pendua
HashSet ialah koleksi dalam Java yang mempunyai fungsi penyahduplikasi automatik. Kita boleh menggunakan ciri-ciri HashSet untuk menambah elemen dalam tatasusunan kepada HashSet untuk mencapai kesan penyahduplikasian.

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

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

2. Gunakan LinkedHashSet untuk mengalih keluar pendua
LinkedHashSet ialah subkelas HashSet Selain mempunyai fungsi penyingkiran pendua, ia juga boleh mengekalkan susunan sisipan. Jika anda perlu mengekalkan susunan asal dan mengalih keluar elemen pendua, anda boleh menggunakan LinkedHashSet.

import java.util.LinkedHashSet;
import java.util.Arrays;

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

3. Gunakan TreeSet untuk mengalih keluar pendua
TreeSet ialah set tersusun, yang secara semula jadi menyusun elemen secara lalai. Menggunakan ciri deduplikasi TreeSet, anda boleh menambah elemen dalam tatasusunan pada TreeSet, dan kemudian menukar TreeSet menjadi tatasusunan untuk mencapai penyahduplikasian.

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

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

4 Gunakan Stream API untuk mengalih keluar pendua
Stream API ialah API baharu yang diperkenalkan dalam Java 8, yang menyediakan cara operasi penstriman. Digabungkan dengan kaedah Strim yang berbeza, anda boleh mengalih keluar tatasusunan pendua dengan mudah.

import java.util.Arrays;
import java.util.stream.IntStream;

public class ArrayDuplicateRemoval {
    public static int[] removeDuplicates(int[] array){
        int[] result = IntStream.of(array).distinct().toArray();
        return result;
    }
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 4, 5, 5, 6};
        int[] result = removeDuplicates(array);
        System.out.println(Arrays.toString(result));
    }
}

5. Gunakan gelung berganda untuk mengalih keluar pendua
Kaedah terakhir ialah menggunakan gelung berganda untuk melintasi tatasusunan untuk menandakan dan mengalih keluar elemen pendua.

import java.util.Arrays;

public class ArrayDuplicateRemoval {
    public static int[] removeDuplicates(int[] array){
        int length = array.length;
        for(int i=0;i<length-1;i++){
            if(array[i]!=-1){
                for(int j=i+1;j<length;j++){
                    if(array[j]==array[i]){
                        array[j] = -1; // 标记为重复元素
                    }
                }
            }
        }
        int[] result = new int[length];
        int index = 0;
        for(int i=0;i<length;i++){
            if(array[i]!=-1){
                result[index++] = array[i];
            }
        }
        return Arrays.copyOf(result, index);
    }
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 4, 5, 5, 6};
        int[] result = removeDuplicates(array);
        System.out.println(Arrays.toString(result));
    }
}

Melalui pengenalan di atas, kami telah menerangkan secara terperinci lima kaedah praktikal penyahduplikasi tatasusunan Java dan menyediakan contoh kod khusus. Bergantung pada situasi dan keperluan sebenar, anda boleh memilih kaedah yang sesuai untuk menyelesaikan masalah penyahduplikasian tatasusunan. Saya harap artikel ini akan membantu anda dalam pembangunan sebenar!

Atas ialah kandungan terperinci Analisis mendalam tentang lima kaedah praktikal untuk penyahduplikasian dalam tatasusunan Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!