Explication détaillée de cinq algorithmes classiques de déduplication de tableaux Java

Explication détaillée de cinq algorithmes classiques de déduplication de tableaux Java

En programmation Java, nous rencontrons souvent des situations où nous devons dédupliquer des tableaux, c'est-à-dire supprimer les éléments en double dans le tableau et conserver les éléments uniques. Ce qui suit présente cinq algorithmes classiques de déduplication de tableaux Java et fournit des exemples de code correspondants.

1. Utiliser HashSet
   HashSet est une classe de collection en Java qui supprime automatiquement les éléments en double. Cette fonctionnalité peut être utilisée pour réaliser rapidement la déduplication de tableau.
   Exemple de code :

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. Utilisation de TreeSet
   TreeSet est une classe de collection ordonnée en Java qui déduplique et trie automatiquement les éléments. La déduplication de tableau peut être réalisée en ajoutant des éléments du tableau à un TreeSet, puis en convertissant le TreeSet en tableau.
   Exemple de code :

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. Utilisation de l'API Stream
   L'API Stream introduite dans Java 8 et versions ultérieures peut simplifier les opérations de déduplication de tableau. En convertissant le tableau en flux, utilisez la méthode distincte du flux pour supprimer les éléments en double, puis convertissez-le en tableau.
   Exemple de code :

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. Utilisation de la double boucle
   La double boucle est un algorithme de déduplication de tableau courant. En comparant les éléments adjacents, les éléments en double sont définis sur une valeur illégale spécifiée, puis la valeur illégale est supprimée.
   Exemple de code :

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. Utilisation de HashMap
   HashMap est une structure de table de hachage en Java. Les éléments du tableau sont insérés en tant que clés à l'aide de la méthode put de HashMap. Les éléments en double sont automatiquement supprimés si la clé existe déjà.
   Exemples de code :

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

Ce qui précède sont des introductions détaillées et des exemples de code de cinq algorithmes classiques de déduplication de tableaux Java. Dans les applications pratiques, le choix d'un algorithme de déduplication approprié en fonction de circonstances spécifiques peut améliorer les performances et la lisibilité du programme.

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!