有个List<A>,A里有List<B>,B里有List<C>，用java代码去重

可以使用Java8的Stream API和flatMap()方法来对嵌套的三层List集合进行去重，具体实现如下：

List<A> listA = new ArrayList<>();
// ... 初始化listA

List<C> uniqueListC = listA.stream()
    .flatMap(a -> a.getListB().stream())
    .flatMap(b -> b.getListC().stream())
    .distinct()
    .collect(Collectors.toList());

其中，getListB()表示从A对象中获取嵌套的List<B>集合，getListC()表示从B对象中获取嵌套的List<C>集合，distinct()表示去除重复元素，collect(Collectors.toList())表示将去重后的元素重新组合成一个List返回。

需要注意的是，如果A、B、C类没有重写equals()和hashCode()方法，去重操作可能无法正常执行。此时，需要在A、B、C类中重写equals()和hashCode()方法，以确保去重操作的正确性。

相关问题

当List<B>和list<A>以多个字段进行匹配，当只在List<B>中存在时，向List<A>中追加对应的数据。用java8写一段实现上述需求的共通方法

假设A和B都有属性id和name，可以使用流操作和Lambda表达式实现上述需求：

public static <A, B> void appendToList(List<A> listA, List<B> listB, Function<B, ?>... matchers) {
    Set<List<Object>> matchSet = listB.stream()
            .map(b -> Arrays.stream(matchers)
                    .map(matcher -> matcher.apply(b))
                    .collect(Collectors.toList()))
            .collect(Collectors.toSet());
    listA.addAll(listB.stream()
            .filter(b -> matchSet.contains(Arrays.stream(matchers)
                    .map(matcher -> matcher.apply(b))
                    .collect(Collectors.toList())))
            .map(b -> (A) b)
            .collect(Collectors.toList()));
}

该方法接受两个参数，分别是要追加数据的目标List和源List，以及一个或多个Function类型的参数，用于指定匹配字段。具体实现如下：

1. 首先，使用流操作将List<B>中的元素映射为一个个List<Object>，其中每个List<Object>表示一个匹配字段的集合；
2. 然后，将这些List<Object>放入Set中去重；
3. 接着，使用流操作过滤出源List中那些匹配字段在Set中存在的元素，并将它们强制转换为目标类型，并添加到目标List中。

使用示例：

List<A> listA = new ArrayList<>();
listA.add(new A(1, "foo"));
listA.add(new A(2, "bar"));

List<B> listB = new ArrayList<>();
listB.add(new B(1, "foo"));
listB.add(new B(3, "baz"));

appendToList(listA, listB, B::getId, B::getName);

System.out.println(listA); // [A{id=1, name='foo'}, A{id=2, name='bar'}, A{id=1, name='foo'}]

在上面的示例中，List<B>中的元素都有对应的id和name属性，因此我们使用B::getId和B::getName作为匹配字段。当List<B>中的元素与List<A>中的元素匹配时，将它们追加到List<A>中。最终，List<A>中包含了两个id为1的元素。

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;
    }
}

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