Revealing Five Efficient Java Array Deduplication Methods

Five efficient Java array deduplication methods revealed

During the Java development process, we often encounter situations where we need to deduplicate arrays. Deduplication is to remove duplicate elements in an array and keep only one. This article will introduce five efficient Java array deduplication methods and provide specific code examples.

Method 1: Use HashSet to remove duplicates

HashSet is an unordered, non-duplicate collection that will automatically remove duplicates when adding elements. Therefore, we can use the characteristics of HashSet to deduplicate arrays.

public static int[] removeDuplicates(int[] arr) {
    Set<Integer> set = new HashSet<>();
    for (int i = 0; i < arr.length; i++) {
        set.add(arr[i]);
    }
    int[] result = new int[set.size()];
    int index = 0;
    for (int num : set) {
        result[index++] = num;
    }
    return result;
}

Method 2: Use LinkedHashSet to maintain the order of elements and deduplicate

LinkedHashSet is an ordered non-duplicate set that sorts elements in the order in which they are inserted. By using LinkedHashSet you can remove duplicates and maintain the order of elements.

public static int[] removeDuplicates(int[] arr) {
    Set<Integer> set = new LinkedHashSet<>();
    for (int i = 0; i < arr.length; i++) {
        set.add(arr[i]);
    }
    int[] result = new int[set.size()];
    int index = 0;
    for (int num : set) {
        result[index++] = num;
    }
    return result;
}

Method 3: Use Stream API for array deduplication

Java 8 introduced the Stream API, which can convert the array into a stream through the stream() method, and then deduplicate the array through the distinct() method. Heavy.

import java.util.Arrays;
import java.util.stream.Collectors;

public static int[] removeDuplicates(int[] arr) {
    return Arrays.stream(arr).distinct().toArray();
}

Method 4: Use TreeSet for sorting and deduplication

TreeSet is an ordered non-duplicate collection that sorts elements according to their natural order. Arrays can be deduplicated and sorted by using a TreeSet.

public static int[] removeDuplicates(int[] arr) {
    Set<Integer> set = new TreeSet<>();
    for (int i = 0; i < arr.length; i++) {
        set.add(arr[i]);
    }
    int[] result = new int[set.size()];
    int index = 0;
    for (int num : set) {
        result[index++] = num;
    }
    return result;
}

Method 5: Use BitSet for deduplication

BitSet is a collection used to store bit values ​​and can also be used for deduplication. We can remove duplicate elements by setting the value of the corresponding bit to true.

public static int[] removeDuplicates(int[] arr) {
    BitSet bitSet = new BitSet();
    for (int num : arr) {
        bitSet.set(num);
    }
    int[] result = new int[bitSet.cardinality()];
    int index = 0;
    for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
        result[index++] = i;
    }
    return result;
}

The above are five efficient Java array deduplication methods. Choosing the appropriate method according to the actual situation can process the array more efficiently during the deduplication process. I hope this article will be helpful to your array deduplication problem in Java development!

The above is the detailed content of Revealing Five Efficient Java Array Deduplication Methods. For more information, please follow other related articles on the PHP Chinese website!