如何通过Java8方式将一个具有属性的列表转换为另一个列表？

这里有一份房地产开发商的名单。开发人员模式如下所示：

@Getter
@Setter
public class Developer {
    private String name;
    private int age;

    public Developer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Developer name(String name) {
        this.name = name;
        return this;
    }

    public Developer name(int age) {
        this.age = age;
        return this;
    }
}

列出具有以下属性的列表：

List<Developer> A = ImmutableList.of(new Developer("Ivan", 25), new Developer("Curry", 28));

在过去，我们会编写如下代码：

public List<ProductManager> convert() {
    List<ProductManager> pros = new ArrayList<>();
    for (Developer dev: A) {
        ProductManager manager = new ProductManager();
        manager.setName(dev.getName());
        manager.setAge(dev.getAge());
        pros.add(manager);
    }
    return pros;
}

公共列表转换（）{
List pros=new ArrayList（）；
for（开发人员开发：A）{
ProductManager=新的ProductManager（）；
manager.setName（dev.getName（））；
manager.setAge（dev.getAge（））；
增加（经理）；
}
回报专业人士；
}

我们如何使用Java 8以更优雅、更简洁的方式编写上述内容？

可能是这样的：

List<ProductManager> B = A.stream()
        .map(developer -> new ProductManager(developer.name, developer.age))
        .collect(Collectors.toList());

列表B=A.stream（）
.map（开发者->新产品经理（developer.name、developer.age））
.collect（Collectors.toList（））；

如果您可以在ProductManger中添加belwo构造函数

public ProductManager(Developer d) {
    this.name = d.getName();
    this.age = d.getAge();
}

然后使用构造函数引用进行转换

    List<Developer> developers = Arrays.asList(new Developer("abc", 25));
    List<ProductManager> managers = developers.stream().map(ProductManager::new).collect(Collectors.toList());
    System.out.println(managers);

---

您必须使用以下内容：

List<ProductManager> B = A.stream()
        .map(developer -> new ProductManager(developer.getName(), developer.getAge()))
        .collect(Collectors.toList());

列表B=A.stream（）
.map（developer->newproductmanager（developer.getName（），developer.getAge（））
.collect（Collectors.toList（））；

//对于大量属性，假设属性具有相似的名称 //其他有不同名字的智者请参考

listb=A.stream（）.map（开发者->{
ProductManager ProductManager=新的ProductManager（）；
试一试{
PropertyUtils.copyProperties（产品经理、开发人员）；
}捕获（例外情况除外）{
例如printStackTrace（）；
}
返回产品经理；
}).collect（Collectors.toList（））；
B.forEach（系统输出：：println）；

---

如果有更多属性，可能超过20个，并且构造函数 不能直接使用，如何转换

如果要设置的属性超过3-4个，则应使用生成器，如下所示：

List<Developer> A = ImmutableList.of(new Developer("Ivan", 25),
                                     new Developer("Curry", 28));

Function<Developer, ProductManager> converter = dev -> new ProductManagerBuilder()
        .setAge(dev.getAge())
        .setName(dev.getName())
        .setProperty1(dev.getProperty1())
        .setProperty2(dev.getProperty2())
        ...
        .build();

List<ProductManager> productManagers = A.stream()
                                        .map(converter)
                                        .collect(toList());

List A=ImmutableList.of（新开发人员（“Ivan”，25），
新开发商（“Curry”，28））；
Function converter=dev->new ProductManagerBuilder（）
.setAge（dev.getAge（））
.setName（dev.getName（））
.setProperty1（dev.getProperty1（））
.setProperty2（dev.getProperty2（））
...
.build（）；
列表ProductManager=A.stream（）
.map（转换器）
.collect（toList（））；

这里真正的问题是为什么

Developer

和

ProductManager

似乎不是从封装

名称和
年龄的普通超类
Person
继承的。在升级到漂亮的Java8 bells&whistles之前，您可能应该正确设计。@JimGarrison是的，我同意您的观点，我需要更多地关注基础知识。如果有更多属性，可能超过20个，并且构造函数不能直接使用，如何转换？如果
Developer
和
ProductManager
有一个公共基类
Person
，定义所有公共属性，那么在这两个类中定义一个带有
Person
参数的构造函数是没有问题的。这些构造函数只会委托给执行工作的
Person
基类的构造函数，因此只需实现一次。请注意，这是一个已建立的模式，即所有标准的
集合
类型都提供一个构造函数，该构造函数接受要从中复制的
集合
参数。如果有更多属性，可能超过20个，并且构造函数不能直接使用，如何转换？在上面的映射器函数中，而不是使用构造函数，创建一个product manager对象，设置其所有属性并返回ITI如果有更多属性，可能超过20个，并且构造函数不能直接使用，如何转换？@Ivan添加了一个带有PropertyUtils的示例，这似乎是一个简单的方法it@Ivan如果实体包含5个或20个以上的属性，则可以使用此选项轻松地将Bean转换为DTO/JSON对象。通过使用，我们可以避免bean/实体类中的getter和setter。阅读这篇文章也可以了解MapStruct。你的意思是使用构建模式吗？是的。我当时的问题是如何在内部映射中编写函数体，而不是构造函数。构建器模式的工作方式与本示例中的构造函数类似，所以我并不打算这样做，谢谢。
[ProductManager [name=abc, age=25]]

List<ProductManager> B = A.stream()
        .map(developer -> new ProductManager(developer.getName(), developer.getAge()))
        .collect(Collectors.toList());

List<ProductManager> B = A.stream().map(developer -> {
            ProductManager productManager = new ProductManager();
            try {
                PropertyUtils.copyProperties(productManager, developer);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            return productManager;
        }).collect(Collectors.toList());

        B.forEach(System.out::println);

List<Developer> A = ImmutableList.of(new Developer("Ivan", 25),
                                     new Developer("Curry", 28));

Function<Developer, ProductManager> converter = dev -> new ProductManagerBuilder()
        .setAge(dev.getAge())
        .setName(dev.getName())
        .setProperty1(dev.getProperty1())
        .setProperty2(dev.getProperty2())
        ...
        .build();

List<ProductManager> productManagers = A.stream()
                                        .map(converter)
                                        .collect(toList());