两个List<Integer> 数据高速去重

可以使用 HashSet 来高效地去除重复项。将两个 List<Integer> 分别转换为 HashSet<Integer>，然后将它们合并为一个 HashSet<Integer> 即可。

代码示例：

List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();

// 添加数据到 list1 和 list2

Set<Integer> set = new HashSet<>();
set.addAll(list1);
set.addAll(list2);

List<Integer> result = new ArrayList<>(set);

这里使用了 HashSet 的 addAll() 方法来合并两个集合，然后再将结果转换为 List<Integer>。由于 HashSet 不允许重复元素，所以合并后的结果也就去重了。

相关问题

java 两个List<Integer> 数据高速去重

### 回答1：
可以使用 Set 来高效去重，具体代码如下：

List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();

// 假设 list1 和 list2 已经被填充了数据

Set<Integer> set = new HashSet<>();
set.addAll(list1);
set.addAll(list2);

List<Integer> resultList = new ArrayList<>(set);

这样可以将两个 List 合并去重后，放入一个新的 List 中。如果需要在原有 List 上去重，也可以使用 Set 来实现：

List<Integer> list = new ArrayList<>();

// 假设 list 已经被填充了数据

Set<Integer> set = new HashSet<>(list);
list.clear();
list.addAll(set);

这样可以将原有 List 中的重复元素去除。

### 回答2：
要高速去重两个List<Integer>数据，可以使用HashSet来实现。

HashSet是一种基于哈希表实现的集合，可以保证其中的元素不重复。它的底层是通过哈希函数对元素进行映射，将元素存储在对应的桶中。

具体操作步骤如下：

1. 创建两个HashSet对象，分别用于存储两个List中的元素。

   HashSet<Integer> set1 = new HashSet<>();
   HashSet<Integer> set2 = new HashSet<>();

2. 遍历第一个List，将其中的元素添加到set1中。

   for (Integer num : list1) {
       set1.add(num);
   }

3. 遍历第二个List，将其中的元素添加到set2中。

   for (Integer num : list2) {
       set2.add(num);
   }

4. 调用set1的`retainAll()`方法，传入set2作为参数，可以将set1中与set2不重复的元素删除。

   set1.retainAll(set2);

5. 最后，set1中保存的就是两个List中重复的元素。可以将其转化为一个新的List，或者直接使用set1进行后续操作。

这种方法的时间复杂度为O(n)，其中n为两个List中元素个数之和。由于HashSet的底层是基于哈希表的，查找元素的速度非常快，因此可以高速去重两个List中的数据。

### 回答3：
在Java中高效地去重两个List<Integer>数据可以采用以下方法：

1. 创建一个新的HashSet<Integer>，用于存储去重后的数据。
2. 遍历第一个List<Integer>，将其中的每个元素添加到HashSet中。
3. 遍历第二个List<Integer>，对于其中的每个元素，首先检查HashSet中是否已经存在该元素，若不存在，则将其添加到HashSet中。
4. 将HashSet中的元素转存到一个新的List<Integer>中，即得到去重后的结果。

这种方法的时间复杂度为O(n)，其中n为两个List中元素的个数之和，这是因为HashSet的添加和查询操作的平均时间复杂度为O(1)。

下面是一个示例代码：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

public class ListDuplicateRemoval {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);

        List<Integer> list2 = new ArrayList<>();
        list2.add(2);
        list2.add(3);
        list2.add(4);

        List<Integer> result = removeDuplicates(list1, list2);
        System.out.println(result);
    }

    public static List<Integer> removeDuplicates(List<Integer> list1, List<Integer> list2) {
        // 创建HashSet存储去重后的数据
        HashSet<Integer> set = new HashSet<>();

        // 遍历list1，将其中的元素添加到HashSet中
        for (Integer num : list1) {
            set.add(num);
        }

        // 遍历list2，将其中不重复的元素添加到HashSet中
        for (Integer num : list2) {
            if (!set.contains(num)) {
                set.add(num);
            }
        }

        // 将HashSet中的元素转存到一个新的List中
        List<Integer> result = new ArrayList<>(set);

        return result;
    }
}

以上代码的输出结果为：[1, 2, 3, 4]

java 两个List<Integer> 删除相同数据

可以使用Java8的Stream API来解决这个问题。

首先，将两个List合并为一个List，然后使用`distinct()`方法去重，最后使用`collect()`方法将结果转换回List类型。

示例代码如下：

List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> list2 = Arrays.asList(3, 4, 5, 6, 7);

List<Integer> result = Stream.concat(list1.stream(), list2.stream())
        .distinct()
        .collect(Collectors.toList());

System.out.println(result); // [1, 2, 3, 4, 5, 6, 7]

如果需要修改原来的List，可以使用`removeIf()`方法来删除相同的元素。示例代码如下：

List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
List<Integer> list2 = Arrays.asList(3, 4, 5, 6, 7);

list1.removeIf(list2::contains);

System.out.println(list1); // [1, 2]

在这个示例中，我们使用了`removeIf()`方法和`contains()`方法来删除相同的元素。请注意，我们使用了`list2::contains`来作为`removeIf()`方法的参数，这是Java8中的方法引用，它等同于传递一个Lambda表达式。