An in-depth analysis of five practical methods for deduplicating Java arrays

In-depth analysis of five practical methods for Java array deduplication

In Java, processing arrays is a very common operation. Array deduplication is a problem often encountered in actual development. This article will provide an in-depth analysis of five practical methods for Java array deduplication and provide specific code examples.

1. Use HashSet to remove duplicates
HashSet is a collection in Java that has the function of automatic deduplication. We can use the characteristics of HashSet to add elements in the array to HashSet to achieve the effect of deduplication.

import java.util.HashSet;
import java.util.Arrays;

public class ArrayDuplicateRemoval {
    public static int[] removeDuplicates(int[] array){
        HashSet<Integer> set = new HashSet<>();
        for(int i=0;i<array.length;i++){
            set.add(array[i]);
        }
        int[] result = new int[set.size()];
        int index=0;
        for(Integer num:set){
            result[index++] = num;
        }
        return result;
    }
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 4, 5, 5, 6};
        int[] result = removeDuplicates(array);
        System.out.println(Arrays.toString(result));
    }
}

2. Use LinkedHashSet to remove duplication
LinkedHashSet is a subclass of HashSet. In addition to having the deduplication function, it can also maintain the insertion order. If you need to maintain the original order and remove duplicate elements, you can use LinkedHashSet.

import java.util.LinkedHashSet;
import java.util.Arrays;

public class ArrayDuplicateRemoval {
    public static int[] removeDuplicates(int[] array){
        LinkedHashSet<Integer> set = new LinkedHashSet<>();
        for(int i=0;i<array.length;i++){
            set.add(array[i]);
        }
        int[] result = new int[set.size()];
        int index=0;
        for(Integer num:set){
            result[index++] = num;
        }
        return result;
    }
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 4, 5, 5, 6};
        int[] result = removeDuplicates(array);
        System.out.println(Arrays.toString(result));
    }
}

3. Use TreeSet to remove duplicates
TreeSet is an ordered set, which naturally sorts the elements by default. Using the deduplication feature of TreeSet, you can add elements in the array to the TreeSet, and then convert the TreeSet into an array to achieve deduplication.

import java.util.TreeSet;
import java.util.Arrays;

public class ArrayDuplicateRemoval {
    public static int[] removeDuplicates(int[] array){
        TreeSet<Integer> set = new TreeSet<>();
        for(int i=0;i<array.length;i++){
            set.add(array[i]);
        }
        int[] result = new int[set.size()];
        int index=0;
        for(Integer num:set){
            result[index++] = num;
        }
        return result;
    }
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 4, 5, 5, 6};
        int[] result = removeDuplicates(array);
        System.out.println(Arrays.toString(result));
    }
}

4. Use Stream API to remove duplicates
Stream API is a new API introduced in Java 8, which provides a streaming operation method. Combined with the distinct method of Stream, you can easily remove duplicate arrays.

import java.util.Arrays;
import java.util.stream.IntStream;

public class ArrayDuplicateRemoval {
    public static int[] removeDuplicates(int[] array){
        int[] result = IntStream.of(array).distinct().toArray();
        return result;
    }
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 4, 5, 5, 6};
        int[] result = removeDuplicates(array);
        System.out.println(Arrays.toString(result));
    }
}

5. Use double loop to remove duplicates
The last method is to use double loop to traverse the array to mark and remove duplicate elements.

import java.util.Arrays;

public class ArrayDuplicateRemoval {
    public static int[] removeDuplicates(int[] array){
        int length = array.length;
        for(int i=0;i<length-1;i++){
            if(array[i]!=-1){
                for(int j=i+1;j<length;j++){
                    if(array[j]==array[i]){
                        array[j] = -1; // 标记为重复元素
                    }
                }
            }
        }
        int[] result = new int[length];
        int index = 0;
        for(int i=0;i<length;i++){
            if(array[i]!=-1){
                result[index++] = array[i];
            }
        }
        return Arrays.copyOf(result, index);
    }
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 4, 5, 5, 6};
        int[] result = removeDuplicates(array);
        System.out.println(Arrays.toString(result));
    }
}

Through the above introduction, we have explained in detail five practical methods of Java array deduplication and provided specific code examples. Depending on the actual situation and needs, you can choose a suitable method to solve the problem of array deduplication. I hope this article will be helpful to you in actual development!

The above is the detailed content of An in-depth analysis of five practical methods for deduplicating Java arrays. For more information, please follow other related articles on the PHP Chinese website!