Java array deduplication: Getting started and mastering five common methods

From entry to proficiency: Five common ways to remove duplication from Java arrays

Introduction: In Java development, array operations are one of the most common operations. Array deduplication is one of the problems often encountered. In this article, we will introduce five common ways to implement Java array deduplication to help you go from getting started to becoming proficient in array deduplication.

1. Use Set collection
The common way is to use the characteristics of Set collection to achieve array deduplication. Set collection is a collection that does not allow duplicate elements, so putting the elements of the array into the Set collection will automatically remove duplicate elements.

Code example:

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. Use loop traversal
Another common way is to use a loop to traverse the array, determine whether the elements are repeated one by one, and put the non-repeating elements into in the new array.

Code example:

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. Using Stream flow
After Java 8, the concept of streaming operations was introduced, which can easily handle collections and arrays. Duplicate elements can be removed using the distinct() method of the Stream stream.

Code example:

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. Using HashMap
Using HashMap to achieve array deduplication is also a common way. Traverse the array, put the array elements as Key into the HashMap, duplicate elements will be overwritten, and finally remove the Key from the HashMap.

Code example:

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. Using recursion
Recursion is an advanced programming technique that can be used to achieve array deduplication. Each recursion compares the first element of the array with the following elements. If they are the same, the following elements are removed until the recursion ends.

Code example:

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: Through the above five common methods, we can easily implement Java array deduplication operations. Whether we use Set collection, loop traversal, Stream flow, HashMap or recursion, it can help us better handle the needs of array deduplication. I hope this article can help you from getting started to becoming proficient in Java array deduplication.

The above is the detailed content of Java array deduplication: Getting started and mastering five common methods. For more information, please follow other related articles on the PHP Chinese website!