java List<String> 去重

在 Java 中，List<String> 类型的列表去重可以采用多种方法，这里给出几种常见的做法：

1. **Set 结构**：利用 Set 的特性，因为 Set 中不允许有重复元素，所以可以把 List 转换成 Set，然后再转回 List 来实现去重。

List<String> uniqueList = new ArrayList<>(new HashSet<>(list));

2. **流 Stream API**：

List<String> uniqueList = list.stream()
                            .distinct() // 去重
                            .collect(Collectors.toList());

这会返回一个新的列表，其中包含原始列表中的唯一元素。

3. **自定义遍历**：

List<String> uniqueList = new ArrayList<>();
for (String element : list) {
    if (!uniqueList.contains(element)) {
        uniqueList.add(element);
    }
}

这个方法通过迭代检查每个元素是否已经存在于新列表中，如果不存在就添加。

相关问题

java list<string> 去重

在 Java 中，可以使用 HashSet 来去除一个 List<String> 中的重复元素。示例代码如下：

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

public class Main {
    public static void main(String[] args) {
        List<String> myList = new ArrayList<>();
        myList.add("apple");
        myList.add("orange");
        myList.add("banana");
        myList.add("apple");
        myList.add("grape");
        myList.add("banana");
        
        HashSet<String> mySet = new HashSet<>(myList);
        myList.clear();
        myList.addAll(mySet);
        
        for (String s : myList) {
            System.out.print(s + " ");
        }
        System.out.println();
    }
}

这段代码首先定义了一个 List<String>，其中包含了重复的元素。接着，将该 List<String> 中的元素转存到 HashSet<String> 中，HashSet<String> 会自动去重。最后，将去重后的元素转存回原来的 List<String> 中。最终输出的结果是不包含重复元素的 List<String>。

需要注意的是，这种方法会改变原来 List<String> 的顺序，因为 HashSet<String> 不保证元素的顺序。如果需要保持原来的顺序，可以使用 LinkedHashSet<String>。

List<List<String>> 去重

去重一个嵌套的字符串列表(List<List<String>>)可以使用以下步骤：

1. 创建一个新的空列表，用于存储去重后的结果。
2. 遍历原始列表中的每个子列表。
3. 对于每个子列表，创建一个新的集合(HashSet)用于存储唯一的字符串。
4. 遍历子列表中的每个字符串。
5. 将字符串添加到集合中，因为集合只能存储唯一值，因此重复的值将被自动去重。
6. 完成对子列表的遍历后，将集合转换为列表，并将其添加到结果列表中。
7. 返回最终的结果列表。

以下是一个示例代码，演示了如何实现上述逻辑：

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

public class Main {
    public static void main(String[] args) {
        List<List<String>> originalList = new ArrayList<>();
        originalList.add(List.of("A", "B", "C"));
        originalList.add(List.of("A", "B"));
        originalList.add(List.of("C", "D", "E"));
        originalList.add(List.of("A", "B", "C"));

        List<List<String>> uniqueList = removeDuplicates(originalList);

        // 打印去重后的结果
        for (List<String> sublist : uniqueList) {
            System.out.println(sublist);
        }
    }

    public static List<List<String>> removeDuplicates(List<List<String>> originalList) {
        List<List<String>> uniqueList = new ArrayList<>();

        for (List<String> sublist : originalList) {
            Set<String> set = new HashSet<>(sublist);
            List<String> uniqueSublist = new ArrayList<>(set);
            uniqueList.add(uniqueSublist);
        }

        return uniqueList;
    }
}

通过上述代码，你将得到去重后的结果。