Java-Array-Deduplizierung: Erste Schritte und Beherrschung fünf gängiger Methoden

Vom Anfänger zum Meister: Fünf gängige Methoden zur Deduplizierung von Java-Arrays

Einführung: In der Java-Entwicklung gehören Array-Operationen zu den häufigsten Operationen. Die Array-Deduplizierung ist eines der häufig auftretenden Probleme. In diesem Artikel stellen wir fünf gängige Methoden zur Implementierung der Java-Array-Deduplizierung vor, um Ihnen den Einstieg in die Array-Deduplizierung zu erleichtern.

1. Set-Sammlung verwenden
Eine übliche Methode besteht darin, die Eigenschaften der Set-Sammlung zu nutzen, um eine Array-Deduplizierung zu erreichen. Die Set-Sammlung ist eine Sammlung, die keine doppelten Elemente zulässt. Wenn Sie also die Elemente des Arrays in die Set-Sammlung einfügen, werden doppelte Elemente automatisch entfernt.

Codebeispiel:

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. Schleifendurchquerung verwenden
Eine andere übliche Methode besteht darin, eine Schleife zu verwenden, um das Array zu durchlaufen, zu bestimmen, ob die Elemente einzeln wiederholt werden, und die sich nicht wiederholenden Elemente in ein neues Array einzufügen.

Codebeispiel:

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. Verwenden von Stream
Nach Java 8 wurde das Konzept der Streaming-Operationen eingeführt, mit denen Sammlungen und Arrays problemlos verarbeitet werden können. Doppelte Elemente können mit der Methode „distinct()“ des Stream-Streams entfernt werden.

Codebeispiel:

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. Verwenden Sie HashMap. Die Verwendung von HashMap zur Array-Deduplizierung ist ebenfalls eine gängige Methode. Durchlaufen Sie das Array, fügen Sie die Array-Elemente als Schlüssel in die HashMap ein, doppelte Elemente werden überschrieben und entfernen Sie schließlich den Schlüssel aus der HashMap.

Codebeispiel:

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. Rekursion verwenden

Rekursion ist eine fortgeschrittene Programmiertechnik, mit der eine Array-Deduplizierung erreicht werden kann. Bei jeder Rekursion wird das erste Element des Arrays mit den folgenden Elementen verglichen. Wenn sie gleich sind, werden die folgenden Elemente entfernt, bis die Rekursion endet.

Codebeispiel:

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

Fazit: Mit den oben genannten fünf gängigen Methoden können wir Java-Array-Deduplizierungsvorgänge problemlos implementieren. Unabhängig davon, ob wir Set-Sammlung, Schleifendurchquerung, Stream-Flow, HashMap oder Rekursion verwenden, können wir damit die Anforderungen der Array-Deduplizierung besser bewältigen. Ich hoffe, dass dieser Artikel Ihnen dabei helfen kann, sich mit der Java-Array-Deduplizierung vertraut zu machen.

Das obige ist der detaillierte Inhalt vonJava-Array-Deduplizierung: Erste Schritte und Beherrschung fünf gängiger Methoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!