Par exemple, supposons que vous ayez un DTO comme celui-ci:
/**
*Entrée avec plusieurs conditions de filtre.
* <p>
** En fait, cela peut être plus compliqué ou complexe...
*/
@Data
class InputDto {
/**Conditions utilisées pour les filtres 1*/
private boolean conditions1;
/**Condition 2 utilisée pour le filtre*/
private boolean conditions2;
/**Condition 3 utilisée pour le filtre*/
private boolean conditions3;
/**Condition utilisée pour le filtre 4*/
private boolean conditions4;
/**Condition utilisée pour le filtre 5*/
private boolean conditions5;
// ...
}
Lors de l'agrégation de cette liste DTO par condition, je pense qu'elle s'écrit souvent comme suit.
private void count(List<InputDto> inputs) {
//Nombre de cas où la condition 1 est appliquée à l'entrée
inputs.stream()
.filter(i -> i.isConditions1())
.count();
//Nombre de cas où la condition 2 est appliquée à l'entrée
inputs.stream()
.filter(i -> i.isConditions2())
.count();
//Condition 3 pour l'entrée,Nombre de cas lorsque 4 est appliqué
inputs.stream()
.filter(i -> i.isConditions3())
.filter(i -> i.isConditions4())
.count();
//Condition 1 pour l'entrée, 3,Nombre de cas lorsque 5 est appliqué
inputs.stream()
.filter(i -> i.isConditions1())
.filter(i -> i.isConditions3())
.filter(i -> i.isConditions5())
.count();
}
Alors
/**
*Sortie avec résultats agrégés.
*/
@Data
class OutputDto {
/**Nombre de cas auxquels la condition 1 a été appliquée*/
private Long count1;
/**Nombre de cas auxquels la condition 2 est appliquée*/
private Long count2;
/**Condition 3,Nombre de cas auxquels 4 a été appliqué*/
private Long count3And4;
/**Condition 1, 3,Nombre de cas auxquels 5 a été appliqué*/
private Long count1And3And5;
// ...
}
Lorsque vous remplissez le DTO de sortie comme ceci,
private void makeOutput(List<InputDto> inputs) {
OutputDto.builder()
.count1(inputs.stream()
.filter(i -> i.isConditions1())
.count())
.count2(inputs.stream()
.filter(i -> i.isConditions2())
.count())
.count3And4(inputs.stream()
.filter(i -> i.isConditions3())
.filter(i -> i.isConditions4())
.count())
.count1And3And5(inputs.stream()
.filter(i -> i.isConditions1())
.filter(i -> i.isConditions3())
.filter(i -> i.isConditions5())
.count())
.build();
}
Est-ce que c'est comme ça?
La condition est boolean donc je peux toujours la lire, mais je n'ai pas pu la voir quand le DTO de l'enfant est sorti:
Je me suis donc demandé si ce serait plus facile à lire.
L'API Stream de Java est pratique, mais si vous l'écrivez dans une liste telle que des expressions lambda, elle peut être difficile à lire.: Disappointed_relieved:
J'ai donc pensé à diviser les méthodes pour pouvoir ** comprendre ce que je voulais faire **.
Filtre long et agrégat(List<InputDto>Liste des entrées, Predicate<? super InputDto>...Beaucoup de filtres) {
//Gonyo Gonyo
Nombre de retours;
}
Comme ça.
De plus, si vous écrivez «beaucoup de filtres» dans une expression lambda, cela restera difficile à voir, c'est donc aussi une méthode.
Predicate<? super InputDto>Un certain filtre() {
entrée de retour->Filtrage avec entrées;
}
// ...réduction
De cette façon, quand vous l'utilisez
Filtrer et agréger(Liste des entrées,Un certain filtre(),Autres filtres());
C'est comme ** Facile à lire et plus court! J'ai pensé **.
La méthode «filtrer et agréger»
/**
*Appliquer tous les filtres passés avec des arguments variables à la liste des entrées et renvoyer le nombre.
*
* @param inputs
* @param filters
* @nombre de cas après application du filtre de retour
*/
private final Long filterCount(List<InputDto> inputs, Predicate<? super InputDto>... filters) {
Stream<InputDto> work = inputs.stream();
for (Predicate<? super InputDto> filter : filters) {
work = work.filter(filter);
}
return work.count();
}
Je l'ai implémenté comme ça.
Puisque Stream ne peut pas être réutilisé, cela ressemble à un filtrage avec for-each statement.
La méthode certains filtres
/**
* @return {@link InputDto#isConditions1()}Filtrer en utilisant
*/
private Predicate<? super InputDto> filter1() {
return i -> i.isConditions1();
}
/**
* @return {@link InputDto#isConditions2()}Filtrer en utilisant
*/
private Predicate<? super InputDto> filter2() {
return i -> i.isConditions2();
}
// ...Omission
/**
* @return {@link InputDto#isConditions5()}Filtrer en utilisant
*/
private Predicate<? super InputDto> filter5() {
return i -> i.isConditions5();
}
Nous l'avons préparé au niveau minimum pour qu'il puisse être réutilisé.
Si vous réécrivez le processus d'emballage dans la sortie qui apparaissait dans l'introduction
private void makeOutput(List<InputDto> inputs) {
OutputDto.builder()
.count1(filterCount(inputs, filter1()))
.count2(filterCount(inputs, filter2()))
.count3And4(filterCount(inputs, filter3(), filter4()))
.count1And3And5(filterCount(inputs, filter1(), filter3(), filter5()))
.build();
}
Je me sens comme cela.
Comment c'est? Facile à lire: réflexion :: question:
C'était le code que j'avais écrit il y a longtemps, mais je me suis souvenu que d'autres personnes disaient que c'était utile.
J'étais content parce que je l'ai écrit avec beaucoup de peine, mais ** Y a-t-il une meilleure façon de l'écrire? La question s'est posée et j'ai écrit l'article.
Les programmeurs Java dans le monde!
Indépendamment de l'API Stream
Je vous serais reconnaissant si vous pouviez me le faire savoir! : Miam:
** J'ai un exemple de code qui s'intègre parfaitement dans la section des commentaires! S'il vous plaît voir si vous êtes intéressé! !! ** **
lombok.Recommended Posts