Déduplication de tableaux Java : démarrer et maîtriser cinq méthodes courantes

Du débutant à la maîtrise : cinq façons courantes de dédupliquer des tableaux Java

Introduction : Dans le développement Java, les opérations sur les tableaux sont l'une des opérations les plus courantes. La déduplication des baies est l'un des problèmes souvent rencontrés. Dans cet article, nous présenterons cinq méthodes courantes d'implémentation de la déduplication de matrice Java pour vous aider à passer du début à la maîtrise de la déduplication de matrice.

1. Utiliser la collection Set
Une méthode courante consiste à utiliser les caractéristiques de la collection Set pour réaliser la déduplication de tableau. La collection Set est une collection qui n'autorise pas les éléments en double, donc placer les éléments du tableau dans la collection Set supprimera automatiquement les éléments en double.

Exemple de code :

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. Utiliser le parcours de boucle
Une autre méthode courante consiste à utiliser une boucle pour parcourir le tableau, à déterminer si les éléments sont répétés un par un et à placer les éléments non répétitifs dans un nouveau tableau.

Exemple de code :

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. Utilisation de Stream
Après Java 8, le concept d'opérations de streaming a été introduit, qui peut facilement gérer des collections et des tableaux. Les éléments en double peuvent être supprimés à l'aide de la méthode distinct() du flux Stream.

Exemple de code :

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. Utiliser HashMap
L'utilisation de HashMap pour réaliser la déduplication de tableau est également une méthode courante. Parcourez le tableau, placez les éléments du tableau comme clé dans le HashMap, les éléments en double seront écrasés et enfin supprimez la clé du HashMap.

Exemple de code :

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. Utiliser la récursion
La récursion est une technique de programmation avancée qui peut être utilisée pour réaliser la déduplication de tableau. Chaque récursion compare le premier élément du tableau avec les éléments suivants s'ils sont identiques, les éléments suivants sont supprimés jusqu'à la fin de la récursion.

Exemple de code :

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

Conclusion : grâce aux cinq méthodes courantes ci-dessus, nous pouvons facilement implémenter des opérations de déduplication de tableaux Java. Que nous utilisions la collection Set, le parcours de boucles, le flux Stream, HashMap ou la récursivité, cela peut nous aider à mieux gérer les besoins de déduplication de tableaux. J'espère que cet article pourra vous aider à démarrer et à maîtriser la déduplication de tableaux Java.

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!