[Java] Générez une liste restreinte à partir de plusieurs listes à l'aide de l'API Stream

Exemple de données

Préparez les données suivantes.

** Liste du personnel **

** Liste des rouleaux **

N'est-ce pas une structure que vous voyez souvent dans DB? Que faire si vous voulez une liste de Staff avec un rollType dont le propriétaire est vrai? Je pense "apportez-le de DB avec INNER JOIN", mais cette fois je suppose que la liste existe indépendamment.

La liste effectivement préparée est la suivante.

list.java

List<Staff> staffList = Arrays.asList(
        new Staff("Sato", 1), 
        new Staff("Suzuki", 2), 
        new Staff("Takahashi", 3), 
        new Staff("Tanaka", 4), 
        new Staff("Ito", 5)
);

List<Roll> rollList = Arrays.asList(
        new Roll(1, true), 
        new Roll(2, true), 
        new Roll(3, false), 
        new Roll(4, false), 
        new Roll(5, false)
);

Staff and Roll sont les classes suivantes.

SampleClass.java

private class Staff {
    private final String name;
    private final Integer rollType;

    public Staff(String name, Integer rollType) {
        this.name = name;
        this.rollType = rollType;
    }

    public String getName() {
        return this.name;
    }

    public Integer getRollType() {
        return this.rollType;
    }
}

private class Roll {
    private final Integer rollType;
    private final boolean owner;

    public Roll(Integer rollType, boolean owner) {
        this.rollType = rollType;
        this.owner = owner;
    }

    public Integer getRollType() {
        return this.rollType;
    }

    public boolean isOwner() {
        return this.owner;
    }
}

En fait chercher

Ci-dessous, nous préparerons le thème Stream et l'instruction for comme cible de comparaison.

Notation pour la déclaration

Main.java

for (Staff staff : StaffList) {
    for (Roll roll : RollList) {
        if (roll.isOwner()) {
            if (staff.getRollType() == roll.getRollType()) {
                System.out.println(staff.getName());
            }
        }
    }
}

C'est facile à comprendre.

Notation dans le flux

Main.java

staffList.stream()
        .filter( // 1.
                staff ->
                        rollList.stream()
                                .filter(roll -> roll.isOwner()) //2.
                                .anyMatch(roll -> // 3.
                                        staff.getRollType() == roll.getRollType()
                                )
        )
        .forEach(staff -> System.out.println(staff.getName()));

Pour expliquer brièvement

1. Filtrer le personnel dont la condition interne est vraie
2. Générez une liste des rôles dont le propriétaire est vrai
3. Renvoie true si le type de rouleau de Staff est dans la liste Roll

Il devient.

Les deux résultats d'exécution

Sato Suzuki

Il devient.

Comparaison du temps d'exécution

Générer une nouvelle liste qui remplit les conditions en utilisant chaque notation (pour les utilisations ajouter pour une liste vide, Stream utilise Collector), Le temps d'exécution lorsque ceci est répété 1000000 fois est le suivant.

Il y a une différence de 6 fois. Je l'ai essayé plusieurs fois, mais cette différence n'a pas diminué de manière significative (évidemment).

En plus du fait que Stream n'est pas rapide à l'origine, il semble que le fait que Stream soit généré un par un dans le filtre ait un impact important.

S'il s'agit d'une simple boucle, elle ressemble plus à un flux que l'instruction for, mais c'est une idée qu'il y a une différence de performances jusqu'à présent.

Résumé

Réaliser une pseudo INNER JOIN en utilisant Stream En imbriquant des filtres, il est possible de gérer des listes telles que des listes ... Utilisez l'instruction For discrètement du point de vue des performances

S'il existe une méthode qui permet d'accélérer la même opération, veuillez commenter.

Les références

Introduction à l'API Java Stream Comment supprimer les éléments en double de deux tableaux avec Java Stream et créer diverses classes uniques