1. PingCode智库首页
  2. 百科

数组如何去重并保证顺序java

Edit1 • • 百科

数组如何去重并保证顺序java

数组去重并保持顺序的常用方法包括：使用 LinkedHashSet、使用 Stream API、使用手动遍历和 Map。其中，使用 LinkedHashSet 是一种高效且简单的方法，因为 LinkedHashSet 在插入元素时会自动去重，并且保持元素的插入顺序。

使用 LinkedHashSet

在 Java 中，LinkedHashSet 是一个非常有用的数据结构，它不仅可以确保元素的唯一性，还能够保持元素的插入顺序。以下是一个使用 LinkedHashSet 实现数组去重并保持顺序的示例：

import java.util.LinkedHashSet;


import java.util.Set;


public class ArrayDeduplication {


    public static int[] removeDuplicates(int[] input) {


        Set<Integer> set = new LinkedHashSet<>();


        for (int num : input) {


            set.add(num);


        }


        int[] result = new int[set.size()];


        int i = 0;


        for (int num : set) {


            result[i++] = num;


        }


        return result;


    }


    public static void main(String[] args) {


        int[] input = {1, 2, 3, 1, 2, 4, 5};


        int[] output = removeDuplicates(input);


        for (int num : output) {


            System.out.print(num + " ");


        }


    }


}

使用 Stream API

Java 8 引入了 Stream API，提供了一种更简洁的方式来处理集合。我们可以使用 distinct() 方法去重，并使用 collect(Collectors.toList()) 将 Stream 转换回 List。然后再将 List 转换为数组：

import java.util.Arrays;


import java.util.List;


import java.util.stream.Collectors;


public class ArrayDeduplication {


    public static int[] removeDuplicates(int[] input) {


        List<Integer> list = Arrays.stream(input)


                                   .boxed()


                                   .distinct()


                                   .collect(Collectors.toList());


        int[] result = new int[list.size()];


        for (int i = 0; i < list.size(); i++) {


            result[i] = list.get(i);


        }


        return result;


    }


    public static void main(String[] args) {


        int[] input = {1, 2, 3, 1, 2, 4, 5};


        int[] output = removeDuplicates(input);


        for (int num : output) {


            System.out.print(num + " ");


        }


    }


}

使用手动遍历和 Map

虽然 LinkedHashSet 和 Stream API 是处理去重和保持顺序的常用方法，但有时我们可能希望使用更底层的方式来实现这一功能。可以使用 HashMap 来记录每个元素是否已经出现过，从而手动实现去重功能：

import java.util.HashMap;


import java.util.Map;


public class ArrayDeduplication {


    public static int[] removeDuplicates(int[] input) {


        Map<Integer, Boolean> seen = new HashMap<>();


        int[] temp = new int[input.length];


        int index = 0;


        for (int num : input) {


            if (!seen.containsKey(num)) {


                seen.put(num, true);


                temp[index++] = num;


            }


        }


        int[] result = new int[index];


        System.arraycopy(temp, 0, result, 0, index);


        return result;


    }


    public static void main(String[] args) {


        int[] input = {1, 2, 3, 1, 2, 4, 5};


        int[] output = removeDuplicates(input);


        for (int num : output) {


            System.out.print(num + " ");


        }


    }


}

一、使用 LinkedHashSet

在 Java 中，LinkedHashSet 是一个基于哈希表和链表实现的集合，它不仅保证了元素的唯一性，还能保持插入的顺序。因此，使用 LinkedHashSet 去重并保持顺序是一个非常有效的方法。

1、基本实现

LinkedHashSet 可以自动过滤掉重复的元素，同时保留插入的顺序。以下是一个简单的代码示例：

import java.util.LinkedHashSet;


import java.util.Set;


public class ArrayDeduplication {


    public static int[] removeDuplicates(int[] input) {


        Set<Integer> set = new LinkedHashSet<>();


        for (int num : input) {


            set.add(num);


        }


        int[] result = new int[set.size()];


        int i = 0;


        for (int num : set) {


            result[i++] = num;


        }


        return result;


    }


    public static void main(String[] args) {


        int[] input = {1, 2, 3, 1, 2, 4, 5};


        int[] output = removeDuplicates(input);


        for (int num : output) {


            System.out.print(num + " ");


        }


    }


}

2、性能分析

使用 LinkedHashSet 去重并保持顺序的时间复杂度主要由以下几部分组成：

  • 插入操作的时间复杂度是 O(1)。因为 LinkedHashSet 基于哈希表实现，插入元素的时间复杂度平均为 O(1)。
  • 遍历操作的时间复杂度是 O(n)。将集合转换为数组时，需要遍历整个 LinkedHashSet。

因此，总的时间复杂度为 O(n)。

二、使用 Stream API

Java 8 引入了 Stream API，它提供了一种声明性的方法来处理集合。我们可以使用 Stream API 的 distinct() 方法来去重，并使用 collect(Collectors.toList()) 方法将结果收集为一个列表，然后再将列表转换为数组。

1、基本实现

以下是使用 Stream API 去重并保持顺序的代码示例：

import java.util.Arrays;


import java.util.List;


import java.util.stream.Collectors;


public class ArrayDeduplication {


    public static int[] removeDuplicates(int[] input) {


        List<Integer> list = Arrays.stream(input)


                                   .boxed()


                                   .distinct()


                                   .collect(Collectors.toList());


        int[] result = new int[list.size()];


        for (int i = 0; i < list.size(); i++) {


            result[i] = list.get(i);


        }


        return result;


    }


    public static void main(String[] args) {


        int[] input = {1, 2, 3, 1, 2, 4, 5};


        int[] output = removeDuplicates(input);


        for (int num : output) {


            System.out.print(num + " ");


        }


    }


}

2、性能分析

使用 Stream API 去重并保持顺序的时间复杂度主要由以下几部分组成：

  • 流的创建和装箱操作的时间复杂度是 O(n)。将数组转换为 Stream 并装箱为 Integer 对象。
  • 去重操作的时间复杂度是 O(n)。Stream API 使用一个内部集合来跟踪已经看到的元素。
  • 收集操作的时间复杂度是 O(n)。将去重后的 Stream 收集为 List，并将 List 转换为数组。

因此，总的时间复杂度为 O(n)。

三、使用手动遍历和 Map

有时，我们可能需要更底层的实现方式。可以使用 HashMap 来记录每个元素是否已经出现过，从而手动实现去重功能。

1、基本实现

以下是使用手动遍历和 HashMap 去重并保持顺序的代码示例：

import java.util.HashMap;


import java.util.Map;


public class ArrayDeduplication {


    public static int[] removeDuplicates(int[] input) {


        Map<Integer, Boolean> seen = new HashMap<>();


        int[] temp = new int[input.length];


        int index = 0;


        for (int num : input) {


            if (!seen.containsKey(num)) {


                seen.put(num, true);


                temp[index++] = num;


            }


        }


        int[] result = new int[index];


        System.arraycopy(temp, 0, result, 0, index);


        return result;


    }


    public static void main(String[] args) {


        int[] input = {1, 2, 3, 1, 2, 4, 5};


        int[] output = removeDuplicates(input);


        for (int num : output) {


            System.out.print(num + " ");


        }


    }


}

2、性能分析

使用手动遍历和 HashMap 去重并保持顺序的时间复杂度主要由以下几部分组成：

  • 遍历数组的时间复杂度是 O(n)。需要遍历整个数组来检查每个元素是否已经出现过。
  • 插入和查找操作的时间复杂度是 O(1)。因为 HashMap 的插入和查找操作平均时间复杂度为 O(1)。
  • 数组拷贝操作的时间复杂度是 O(n)。将临时数组复制到结果数组。

因此，总的时间复杂度为 O(n)。

四、总结

在 Java 中，去重并保持数组顺序的方法有很多种，包括使用 LinkedHashSet、Stream API 和手动遍历与 Map。每种方法都有其优点和适用场景：

  • LinkedHashSet：简单高效，适用于大多数场景。
  • Stream API：更声明性的方法，适用于处理集合的现代 Java 编程风格。
  • 手动遍历和 Map：更底层的实现方式，适用于需要更细粒度控制的场景。

无论使用哪种方法，关键在于理解每种方法的特点和适用场景，选择最合适的工具来解决问题。

相关问答FAQs：

1. 如何使用Java去重数组并保持原有顺序？

要去重数组并保持原有顺序，可以使用LinkedHashSet。LinkedHashSet是Java中的一种集合，它保留了插入元素的顺序，并且不允许重复元素。你可以使用以下代码实现去重并保持顺序：

int[] arr = {1, 2, 3, 3, 4, 5, 5};
LinkedHashSet<Integer> set = new LinkedHashSet<>();
for (int num : arr) {
    set.add(num);
}
int[] uniqueArr = new int[set.size()];
int index = 0;
for (int num : set) {
    uniqueArr[index++] = num;
}

2. 如何使用Java去重数组并保留第一次出现的元素？

如果你想要去重数组，但是只保留第一次出现的元素，你可以使用HashMap来实现。HashMap是一种键值对的集合，其中的键是唯一的。你可以将数组中的元素作为键，将元素的索引作为值，这样重复的元素将会被覆盖。以下是一个示例代码：

int[] arr = {1, 2, 3, 3, 4, 5, 5};
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < arr.length; i++) {
    if (!map.containsKey(arr[i])) {
        map.put(arr[i], i);
    }
}
int[] uniqueArr = new int[map.size()];
int index = 0;
for (int num : map.keySet()) {
    uniqueArr[index++] = num;
}

3. 如何使用Java去重数组并保留最后一次出现的元素？

如果你想要去重数组，并且只保留最后一次出现的元素，你可以使用LinkedHashMap来实现。LinkedHashMap是一种有序的HashMap，它保留了插入元素的顺序。你可以将数组中的元素作为键，将元素的索引作为值，这样重复的元素将会被覆盖。以下是一个示例代码：

int[] arr = {1, 2, 3, 3, 4, 5, 5};
LinkedHashMap<Integer, Integer> map = new LinkedHashMap<>();
for (int i = arr.length - 1; i >= 0; i--) {
    if (!map.containsKey(arr[i])) {
        map.put(arr[i], i);
    }
}
int[] uniqueArr = new int[map.size()];
int index = 0;
for (int num : map.keySet()) {
    uniqueArr[index++] = num;
}

原创文章，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/195059

赞 (0)
Edit1Edit1
上一篇 2024年8月13日 下午1:32
下一篇 2024年8月13日 下午1:32
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部