java中有3个List集合，将集合A和集合B中符合条件的数据整合到集合C中，不用循环嵌套能实现吗

有3个List集合，将集合A和集合B中符合条件的数据整合到集合C中，不用循环嵌套能实现吗

我尝试过的办法：

package test01;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class testclass2 {

    public static void main(String[] args) {

        // 获取原数据
        List<TestData> testData = getTestData();

        // 根据字段1去重
        List<TestData> resultData = testData.stream().filter(distinctByKey(TestData::getField1)).collect(Collectors.toList());
                 //根据字段2去重
        List<TestData> resultData1 = testData.stream().filter(distinctByKey(TestData::getField2)).collect(Collectors.toList());

        // 集合一循环
        for(TestData data: resultData1) {
            // 集合二循环
            for(TestData data1:resultData) {
                
                // 判断集合1中字段一不同，并且字段二也不同的数据
                if(!data1.getField1().equals(data.getField1())&&!data1.getField2().equals(data.getField2())) {
                
                    // 追加新数据
                    TestData data2 = new TestData();
                    data2.setField1(data1.getField1());
                    data2.setField2(data.getField2());
                    data2.setField3(data.getField3());
                    data2.setField4(data.getField4());
                    data2.setField5("");
                    
                    testData.add(data2);
                    
                }
            }
        }

        // 输出结果
        System.out.println("输出结果：");
        System.out.println(testData);
    }

    //其返回类型为 Predicate，原理就是判断一个元素能否加入到 Set 中去
    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Set<Object> seen = ConcurrentHashMap.newKeySet();
        return t -> seen.add(keyExtractor.apply(t));
    }

    // 设置数据
    public static List<TestData> getTestData() {

        TestData data1 = new TestData();
        data1.setField1("6111105010");
        data1.setField2("JA001");
        data1.setField3("JA");
        data1.setField4("名称1");
        data1.setField5("1");
        TestData data2 = new TestData();
        data2.setField1("6111105010");
        data2.setField2("JA004");
        data2.setField3("JA");
        data2.setField4("名称2");
        data2.setField5("2");
        TestData data3 = new TestData();
        data3.setField1("6111105050");
        data3.setField2("JA001");
        data3.setField3("JA");
        data3.setField4("名称3");
        data3.setField5("3");
        TestData data4 = new TestData();
        data4.setField1("6111105050");
        data4.setField2("JB001");
        data4.setField3("JB");
        data4.setField4("名称4");
        data4.setField5("4");
        TestData data5 = new TestData();
        data5.setField1("6111105010");
        data5.setField2("JC001");
        data5.setField3("JC");
        data5.setField4("");
        data5.setField5("5");
        TestData data6 = new TestData();
        data6.setField1("6111105050");
        data6.setField2("JD004");
        data6.setField3("");
        data6.setField4("");
        data6.setField5("6");

        List<TestData> listData = new ArrayList<TestData>();
        listData.add(data1);
        listData.add(data2);
        listData.add(data3);
        listData.add(data4);
        listData.add(data5);
        listData.add(data6);

        return listData;

    }

    static class TestData {

        private String field1;
        private String field2;
        private String field3;
        private String field4;
        private String field5;

        public String getField1() {
            return field1;
        }

        public void setField1(String field1) {
            this.field1 = field1;
        }

        public String getField2() {
            return field2;
        }

        public void setField2(String field2) {
            this.field2 = field2;
        }

        public String getField3() {
            return field3;
        }

        public void setField3(String field3) {
            this.field3 = field3;
        }

        public String getField4() {
            return field4;
        }

        public void setField4(String field4) {
            this.field4 = field4;
        }
        
        public String getField5() {
            return field5;
        }

        public void setField5(String field5) {
            this.field5 = field5;
        }

        @Override
        public String toString() {
            return "\nData{" + "field1=" + field1 + ", field2=" + field2 + ", field3=" + field3 + ", field4=" + field4
                    + "field5=" + field5+ "}";
        }
    }

}

用stream结合lambda表达式

在Java中,可以使用Stream API来实现集合A和集合B中符合条件的数据整合到集合C中,而无需使用循环嵌套。
具体实现如下:

java
List<Integer> listA = Arrays.asList(1, 2, 3, 4);
List<Integer> listB = Arrays.asList(3, 4, 5, 6);
List<Integer> listC = new ArrayList<>();

listA.stream()
    .filter(a -> listB.contains(a))   // 过滤listA中也包含在listB中的元素
    .forEach(listC::add);      // 添加至listC

listB.stream()
    .filter(b -> !listA.contains(b)) // 过滤listB中不包含在listA中的元素
    .forEach(listC::add);      // 添加至listC

以上代码使用Stream对listA和listB进行过滤,得到符合条件的元素,并使用forEach分别添加至listC,从而实现两个集合的数据整合,而无需使用循环嵌套。

Stream API提供了一整套Collection运算和表达的方式,使用链式调用聚合多个步骤,可以简洁高效地对集合进行过滤、映射、去重、排序、分组等操作。所以使用Stream API可以避免在Java代码中编写过多的for循环嵌套逻辑,使代码更加简洁高效。

除Stream API外,还可以使用其他技术实现,比如使用某个集合的addAll方法直接将两个集合的元素添加至第三个集合,然后在第三个集合上进行过滤等操作。但整体来说,Stream API提供的语法更加简洁,原理也更加清晰,是Java集合操作上的最佳实践。