Es gibt eine Liste A mit Eigenschaftsentwickler. Entwicklerschema gefällt das:
@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;
}
}
Liste A mit Eigenschaften:
List<Developer> A = ImmutableList.of(new Developer("Ivan", 25), new Developer("Curry", 28));
Es wird verlangt, Liste A in Liste B umzuwandeln, die mit der Eigenschaft ProductManager und den Eigenschaften mit denen von Liste A identisch ist.
@Getter
@Setter
public class ProductManager {
private String name;
private int age;
public ProductManager(String name, int age) {
this.name = name;
this.age = age;
}
public ProductManager name(String name) {
this.name = name;
return this;
}
public ProductManager name(int age) {
this.age = age;
return this;
}
}
Früher haben wir Codes geschrieben wie:
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;
}
Wie können wir mit Java 8 das Obige eleganter und kürzer schreiben?
sie müssen etwas wie folgt verwenden:
List<ProductManager> B = A.stream()
.map(developer -> new ProductManager(developer.getName(), developer.getAge()))
.collect(Collectors.toList());
// für eine große Anzahl von Eigenschaften, vorausgesetzt, die Attribute haben ähnliche Namen // Andernfalls mit unterschiedlichen Namen beziehen sich auf this
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);
Wahrscheinlich so:
List<ProductManager> B = A.stream()
.map(developer -> new ProductManager(developer.name, developer.age))
.collect(Collectors.toList());
Wenn es mehr Eigenschaften gibt, vielleicht mehr als 20, und der Konstruktor Nicht direkt verwenden kann, wie konvertiert werden?
Wenn Sie mehr als 3-4 Eigenschaften festlegen möchten, sollten Sie einen Builder verwenden:
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());
Wenn Sie mit Belwo zwei Konstruktoren in ProductManger hinzufügen möchten
public ProductManager(Developer d) {
this.name = d.getName();
this.age = d.getAge();
}
dann mit Konstruktorreferenz konvertieren
List<Developer> developers = Arrays.asList(new Developer("abc", 25));
List<ProductManager> managers = developers.stream().map(ProductManager::new).collect(Collectors.toList());
System.out.println(managers);
ansonsten können Sie einen benutzerdefinierten Mapper bereitstellen
Function<Developer, ProductManager> mapper = d -> new ProductManager(d.getName(), d.getAge());
verwenden Sie diese Funktion in der Funktion map
Ausgabe
[ProductManager [name=abc, age=25]]