Comment faire pour convertir une liste avec les propriétés d'une autre liste de java 8?

Il y a une Liste avec Un promoteur immobilier. Développeur schéma aime:

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

Une liste avec les propriétés:

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

Il est demandé de convertir Une Liste de la Liste B, qui, avec la propriété ProductManager et les propriétés sont les mêmes que ceux de la Liste A.

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

Dans les vieux jours, nous devons écrire des codes comme:

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

Comment pourrions-nous écrire ci-dessus dans un de plus élégant et brève avec Java 8?

La vraie question ici est pourquoi Developer et ProductManager ne semblent pas hériter d'une super-classe commune Person qui encapsule la name et age. Avant de vous rendre la mise à niveau vers chouette Java8 cloches & sifflets, vous devriez probablement obtenir le droit de conception.
Oui, je suis d'accord avec vous, j'ai besoin de payer plus d'attention aux fondamentaux. Si il y a plus de propriétés, peut-être plus de 20, et le constructeur ne peut pas utiliser directement, comment les convertir ?
Si Developer et ProductManager avait une classe de base commune, Person, définissant l'ensemble des propriétés communes, il n'y a pas de problème de définition d'un constructeur avec un Person paramètre dans les deux classes. Ces constructeurs serait tout simplement déléguer au constructeur de la Person de la classe de base qui fait le travail, de sorte qu'il doit être mis en œuvre qu'une seule fois. Notez que c'est un modèle établi, c'est à dire tous les standard Collection types de fournir un constructeur acceptant un Collection argument pour la copie.

OriginalL'auteur Ivan | 2016-10-14

vous devrez utiliser quelque chose comme ci-dessous :

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

//pour le grand nombre de propriétés en supposant que les attributs ont des noms similaires
//d'autres sages avec des noms différents, reportez-vous cette

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

Si il y a plus de propriétés, peut-être plus de 20, et le constructeur ne peut pas utiliser directement, comment les convertir ?
ajout d'un échantillon avec PropertyUtils , semble être un moyen facile de le faire

OriginalL'auteur Ramachandran.A.G

Probablement, comme ceci:

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

OriginalL'auteur Slava

Si il y a plus de propriétés, peut-être plus de 20, et le constructeur
ne peut pas utiliser directement, comment les convertir ?

Si vous avez plus que 3-4 propriétés pour définir, vous devez utiliser un Constructeur, comme suit:

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());

Tu veux dire utiliser construire motif? Il est de droite. Ma question alors est de savoir comment écrire la fonction du corps dans l'intérieur de la carte, au lieu de constructeur. Le générateur de modèle fonctionne comme un constructeur dans cet exemple, il n'est pas mon intention, merci quand même.

OriginalL'auteur Mahesh

0

Si vous êtes bien à ajouter belwo constructeur dans ProductManger
```
public ProductManager(Developer d) {
    this.name = d.getName();
    this.age = d.getAge();
}
```
puis de le convertir en utilisant le constructeur de référence
```
    List<Developer> developers = Arrays.asList(new Developer("abc", 25));
    List<ProductManager> managers = developers.stream().map(ProductManager::new).collect(Collectors.toList());
    System.out.println(managers);
```
sinon, vous pouvez personnaliser le mappeur de
```
Function<Developer, ProductManager> mapper = d -> new ProductManager(d.getName(), d.getAge()); 
```
l'utiliser dans map fonction

Sortie
```
[ProductManager [name=abc, age=25]]
```
Si il y a plus de propriétés, peut-être plus de 20, et le constructeur ne peut pas utiliser directement, comment les convertir ?
Au-dessus de mapper la fonction au lieu d'utiliser le constructeur, créez un chef de produit objet de définir toutes les propriétés de la catégorie et de la retourner

OriginalL'auteur Saravana

Vous devez vous connecter pour publier un commentaire.