Detaillierte Erläuterung von fünf klassischen Java-Array-Deduplizierungsalgorithmen

Detaillierte Erläuterung der fünf klassischen Java-Array-Deduplizierungsalgorithmen

Bei der Java-Programmierung stoßen wir häufig auf Situationen, in denen wir Arrays deduplizieren müssen, d. h. doppelte Elemente im Array entfernen und eindeutige Elemente beibehalten müssen. Im Folgenden werden fünf klassische Java-Array-Deduplizierungsalgorithmen vorgestellt und entsprechende Codebeispiele bereitgestellt.

1. HashSet verwenden
   HashSet ist eine Sammlungsklasse in Java, die automatisch doppelte Elemente entfernt. Diese Funktion kann verwendet werden, um eine Array-Deduplizierung schnell zu erreichen.
   Codebeispiel:

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. TreeSet verwenden
   TreeSet ist eine geordnete Sammlungsklasse in Java, die Elemente automatisch dedupliziert und sortiert. Die Array-Deduplizierung kann erreicht werden, indem Elemente im Array zu einem TreeSet hinzugefügt und das TreeSet dann in ein Array konvertiert werden.
   Codebeispiel:

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. Verwenden der Stream-API
   Die in Java 8 und höher eingeführte Stream-API kann Array-Deduplizierungsvorgänge vereinfachen. Durch Konvertieren des Arrays in einen Stream verwenden Sie die eindeutige Methode des Streams, um doppelte Elemente zu entfernen, und konvertieren Sie es dann in ein Array.
   Codebeispiel:

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. Verwendung von Double Loop
   Double Loop ist ein gängiger Array-Deduplizierungsalgorithmus. Durch den Vergleich benachbarter Elemente werden die doppelten Elemente auf einen angegebenen unzulässigen Wert gesetzt und dann wird der unzulässige Wert entfernt.
   Codebeispiel:

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. HashMap ist eine Hash-Tabellenstruktur in Java, die mithilfe der Put-Methode von HashMap als Schlüssel eingefügt wird.
   Codebeispiele:
   

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

Das Obige sind detaillierte Einführungen und Codebeispiele von fünf klassischen Java-Array-Deduplizierungsalgorithmen. In praktischen Anwendungen kann die Auswahl eines geeigneten Deduplizierungsalgorithmus entsprechend den spezifischen Umständen die Leistung und Lesbarkeit des Programms verbessern.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von fünf klassischen Java-Array-Deduplizierungsalgorithmen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!