Angenommen, Sie haben ein DTO wie das folgende:
/**
*Eingabe mit mehreren Filterbedingungen.
* <p>
** Tatsächlich kann es komplizierter oder komplexer sein...
*/
@Data
class InputDto {
/**Bedingungen für Filter 1*/
private boolean conditions1;
/**Bedingung 2 für Filter verwendet*/
private boolean conditions2;
/**Bedingung 3 für Filter verwendet*/
private boolean conditions3;
/**Bedingung für Filter 4*/
private boolean conditions4;
/**Bedingung für Filter 5*/
private boolean conditions5;
// ...
}
Wenn ich diese DTO-Liste nach Bedingungen zusammenfasse, denke ich, dass sie oft wie folgt geschrieben wird.
private void count(List<InputDto> inputs) {
//Anzahl der Fälle, in denen Bedingung 1 auf die Eingabe angewendet wird
inputs.stream()
.filter(i -> i.isConditions1())
.count();
//Anzahl der Fälle, in denen Bedingung 2 auf die Eingabe angewendet wird
inputs.stream()
.filter(i -> i.isConditions2())
.count();
//Bedingung 3 für die Eingabe,Anzahl der Fälle, in denen 4 angewendet wird
inputs.stream()
.filter(i -> i.isConditions3())
.filter(i -> i.isConditions4())
.count();
//Bedingung 1 für die Eingabe, 3,Anzahl der Fälle, in denen 5 angewendet wird
inputs.stream()
.filter(i -> i.isConditions1())
.filter(i -> i.isConditions3())
.filter(i -> i.isConditions5())
.count();
}
Damit
/**
*Ausgabe mit aggregierten Ergebnissen.
*/
@Data
class OutputDto {
/**Anzahl der Fälle, auf die Bedingung 1 angewendet wurde*/
private Long count1;
/**Anzahl der Fälle, auf die Bedingung 2 angewendet wird*/
private Long count2;
/**Bedingung 3,Anzahl der Fälle, auf die 4 angewendet wurden*/
private Long count3And4;
/**Bedingung 1, 3,Anzahl der Fälle, auf die 5 angewendet wurden*/
private Long count1And3And5;
// ...
}
Wenn Sie das Ausgabe-DTO wie folgt füllen,
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();
}
Ist es so
Die Bedingung ist "boolesch", so dass ich sie immer noch lesen kann, aber ich konnte sie nicht sehen, als das DTO des Kindes herauskam: müde_gesicht:
Also fragte ich mich, ob es einfacher zu lesen wäre.
Die Stream API von Java ist praktisch, aber wenn Sie sie in eine Liste wie Lambda-Ausdrücke schreiben, kann es schwierig werden, sie zu lesen: enttäuscht_relieved:
Also dachte ich darüber nach, die Methoden zu teilen, damit ich verstehen konnte, was ich tun wollte.
Langer Filter und Aggregat(List<InputDto>Liste der Eingaben, Predicate<? super InputDto>...Viele Filter) {
//Gonyo Gonyo
Anzahl der Rücksendungen;
}
So was.
Wenn Sie "viele Filter" in Lambda-Ausdrücken schreiben, bleibt dies außerdem schwer zu erkennen, sodass dies auch eine Methode ist.
Predicate<? super InputDto>Ein bestimmter Filter() {
Eingabe zurückgeben->Filtern mit Eingängen;
}
// ...Kürzung
Auf diese Weise, wenn Sie es verwenden
Filtern und aggregieren(Liste der Eingaben,Ein bestimmter Filter(),Andere Filter());
Es fühlt sich an wie ** Einfach zu lesen und kürzer! Ich dachte **.
Die Filter- und Aggregatmethode
/**
*Wenden Sie alle mit variablen Argumenten übergebenen Filter auf die Liste der Eingaben an und geben Sie die Nummer zurück.
*
* @param inputs
* @param filters
* @Anzahl der Fälle nach Anwendung des Rückgabefilters
*/
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();
}
Ich habe es so implementiert.
Da "Stream" nicht wiederverwendet werden kann, fühlt es sich an, als würde man mit "für jede Anweisung" filtern.
Die "bestimmte Filter" -Methode
/**
* @return {@link InputDto#isConditions1()}Filtern mit
*/
private Predicate<? super InputDto> filter1() {
return i -> i.isConditions1();
}
/**
* @return {@link InputDto#isConditions2()}Filtern mit
*/
private Predicate<? super InputDto> filter2() {
return i -> i.isConditions2();
}
// ...Unterlassung
/**
* @return {@link InputDto#isConditions5()}Filtern mit
*/
private Predicate<? super InputDto> filter5() {
return i -> i.isConditions5();
}
Wir haben es auf dem Mindestniveau vorbereitet, damit es wiederverwendet werden kann.
Wenn Sie den Vorgang des Packens in die in der Einführung angezeigte Ausgabe umschreiben
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();
}
Ich fühle mich so.
Wie ist das? Einfach zu lesen: Denken :: Frage:
Dies war der Code, den ich vor langer Zeit geschrieben habe, aber ich erinnerte mich, dass andere Leute sagten, er sei nützlich.
Ich war glücklich, weil ich es mit viel Mühe geschrieben habe, aber ** Gibt es einen besseren Weg, es zu schreiben? Die Frage kam auf und ich schrieb den Artikel.
Java-Programmierer in der Welt!
Unabhängig von der "Stream API"
Ich wäre Ihnen dankbar, wenn Sie es mich wissen lassen könnten! : yum:
** Ich habe ein Codebeispiel, das gut in den Kommentarbereich passt! Bitte sehen Sie, ob Sie interessiert sind! !! ** ** **