Une analyse approfondie de cinq méthodes pratiques de déduplication des tableaux Java

Analyse approfondie de cinq méthodes pratiques de déduplication de tableaux Java

En Java, le traitement des tableaux est une opération très courante. La déduplication des baies est un problème souvent rencontré dans le développement réel. Cet article fournira une analyse approfondie de cinq méthodes pratiques de déduplication de tableaux Java et fournira des exemples de code spécifiques.

1. Utilisez HashSet pour supprimer les doublons
HashSet est une collection en Java qui a la fonction de déduplication automatique. Nous pouvons utiliser les caractéristiques de HashSet pour ajouter des éléments du tableau à HashSet afin d'obtenir l'effet de déduplication.

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. Utilisez LinkedHashSet pour supprimer les doublons
LinkedHashSet est une sous-classe de HashSet en plus d'avoir la fonction de suppression des doublons, il peut également maintenir l'ordre d'insertion. Si vous devez conserver l'ordre d'origine et supprimer les éléments en double, vous pouvez utiliser 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. Utilisez TreeSet pour supprimer les doublons
TreeSet est un ensemble ordonné, qui trie naturellement les éléments par défaut. À l'aide de la fonctionnalité de déduplication de TreeSet, vous pouvez ajouter des éléments du tableau au TreeSet, puis convertir le TreeSet en tableau pour réaliser la déduplication.

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. Utilisez l'API Stream pour supprimer les doublons
L'API Stream est une nouvelle API introduite dans Java 8, qui fournit un moyen d'effectuer des opérations de streaming. Combiné avec la méthode distincte de Stream, vous pouvez facilement supprimer les tableaux en double.

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. Utilisez une double boucle pour supprimer les doublons
La dernière méthode consiste à utiliser une double boucle pour parcourir le tableau afin de marquer et de supprimer les éléments en double.

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

Grâce à l'introduction ci-dessus, nous avons expliqué en détail cinq méthodes pratiques de déduplication de tableaux Java et fourni des exemples de code spécifiques. En fonction de la situation et des besoins réels, vous pouvez choisir une méthode appropriée pour résoudre le problème de la déduplication des baies. J'espère que cet article vous sera utile dans le développement réel !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!