现在有两个 List集合 a<Test>list b<Test>list 他们的类型都是一样的 怎么用循环或者用stream 循环把 b集合中的 m01 m02 属性 set到 a集合中的 m01 m02 属性

您可以使用循环或者Stream操作实现这一需求。下面是两种实现方式：

使用循环：

for (int i = 0; i < aList.size(); i++) {
    aList.get(i).setM01(bList.get(i).getM01());
    aList.get(i).setM02(bList.get(i).getM02());
}

使用Stream：

IntStream.range(0, aList.size())
         .forEach(i -> {
             aList.get(i).setM01(bList.get(i).getM01());
             aList.get(i).setM02(bList.get(i).getM02());
         });

以上代码均假设 `Test` 类中有 `m01` 和 `m02` 两个属性，并且 `aList` 和 `bList` 的元素个数相同。

相关问题

将List<B>与List<A>进行match，当List<B>中存在List<A>中没有的数据时，向List<A>中根据条件追加。用java8写一个共通方法

假设A和B类的定义如下：

public class A {
    private int id;
    private String name;
    // getter/setter 省略
}

public class B {
    private int id;
    private String name;
    private String description;
    // getter/setter 省略
}

共通方法的实现如下：

public static <T extends A, U extends B> void matchAndAppend(List<T> listA, List<U> listB, BiPredicate<T, U> predicate, Function<U, T> mapper) {
    Set<Integer> idSetA = listA.stream().map(A::getId).collect(Collectors.toSet());
    listB.stream()
        .filter(b -> !idSetA.contains(b.getId()))
        .map(mapper)
        .filter(a -> listB.stream().anyMatch(b -> predicate.test(a, b)))
        .forEach(listA::add);
}

方法的参数说明：

- `listA`：待追加数据的列表；
- `listB`：原始数据的列表；
- `predicate`：用于匹配A和B对象是否匹配的谓词；
- `mapper`：将B对象转换为A对象的映射函数。

方法的实现步骤如下：

- 首先，将A列表中所有元素的id提取出来，放入一个Set中，以便后面判断B对象是否存在于A列表；
- 然后，过滤出B列表中不存在于A列表中的元素，并将其转换为A对象；
- 接着，对转换后的A对象进行过滤，只留下符合条件的对象，即存在于B列表中；
- 最后，将符合条件的A对象添加到A列表中。

示例代码如下：

List<A> listA = new ArrayList<>();
List<B> listB = new ArrayList<>();
listB.add(new B(1, "A", "B"));
listB.add(new B(2, "B", "C"));
listB.add(new B(3, "C", "D"));
matchAndAppend(listA, listB, (a, b) -> Objects.equals(a.getName(), b.getName()), b -> new A(b.getId(), b.getName()));
System.out.println(listA); // 输出：[A{id=1, name='A'}, A{id=2, name='B'}, A{id=3, name='C'}]

在上面的示例代码中，我们将B转换为A时，只保留了id和name两个属性，其它属性被丢弃了。如果需要保留其它属性，可以在A类中添加对应的属性，并在mapper函数中进行转换。

当List<A>和List<B>以多个字段进行match，将match成功的List<A>和List<B>分别出力。用java8写一个共通方法

可以使用Java 8的Stream API和lambda表达式来实现这个共通方法。假设List<A>和List<B>都有以下字段：

class A {
    private int id;
    private String name;
    // ...
}

class B {
    private int id;
    private String description;
    // ...
}

那么可以定义如下方法来进行匹配：

public static <T, U> Map<T, U> match(List<T> list1, List<U> list2,
        BiPredicate<T, U> matcher) {
    return list1.stream()
            .flatMap(a -> list2.stream()
                    .filter(b -> matcher.test(a, b))
                    .map(b -> new AbstractMap.SimpleEntry<>(a, b)))
            .collect(Collectors.toMap(
                    AbstractMap.SimpleEntry::getKey,
                    AbstractMap.SimpleEntry::getValue));
}

其中，BiPredicate是一个函数接口，用于判断两个对象是否匹配。例如：

BiPredicate<A, B> matcher = (a, b) -> a.getId() == b.getId()
        && a.getName().equals(b.getDescription());

然后，可以调用match方法来进行匹配：

List<A> list1 = Arrays.asList(new A(1, "foo"), new A(2, "bar"));
List<B> list2 = Arrays.asList(new B(1, "description of foo"),
        new B(3, "description of baz"));

Map<A, B> matched = match(list1, list2, matcher);

matched.forEach((a, b) -> System.out.println(a + " -> " + b));

输出结果为：

A{id=1, name='foo'} -> B{id=1, description='description of foo'}