Es gab einige Dinge, die ich über den in Java8 hinzugefügten Stream-Beendigungsprozess nicht verstanden habe, also habe ich ihn studiert.
Stream-Operationen werden in der Reihenfolge Stream-Generierung ⇒ Zwischenverarbeitung ⇒ Terminierungsverarbeitung ausgeführt. Stream-Generierung ⇒ Auch wenn nur eine Zwischenverarbeitung ausgeführt wird, hat dies keine Auswirkungen auf die ursprüngliche Liste usw. und es gibt keinen Rückgabewert. Wenn Sie etwas tun oder das Ergebnis erhalten möchten, müssen Sie den Beendigungsprozess ausführen.
Ich denke, dass ich mehr zunehmen werde, wenn ich Lust dazu habe, aber dieses Mal werde ich diejenigen auflisten, die ich angemessen aufgenommen habe.
count Es ist leicht zu verstehen, aber es zählt die Anzahl der Streams. Es wird normalerweise in Kombination mit einer Zwischenverarbeitung wie einem Filter verwendet.
count
/**
*Überprüfen Sie die Anzahl der Stream-Beendigungsverarbeitungen
*/
@Test
public void count() {
//Wie es ist
long count = IntStream.rangeClosed(1, 10).count();
System.out.println(count); // ⇒ 10
//Wird normalerweise in Kombination mit einer Zwischenverarbeitung verwendet
long count2 = IntStream.rangeClosed(1, 10).filter(i -> i > 4).count();
System.out.println(count2); // ⇒ 6
}
toArray Der Methodenname ist derselbe, aber Stream wird in das Array-Format konvertiert und zurückgegeben. Für toArray werden zwei Muster mit und ohne Argumente vorbereitet. Wenn sie ohne Argumente ausgeführt werden, werden sie als Array von Objekten zurückgegeben. Wenn ein Argument vorhanden ist, muss das Argument eine "Generator" -Funktion angeben, die ein Array mit einer als Argument übergebenen Ganzzahl zurückgibt.
toArray
/**
*Überprüfen Sie die Stream-Beendigung zum Array
*/
@Test
public void toArray() {
List<String> testList = new ArrayList<String> (Arrays.asList("ABC1", "ABD2", "DBC3", "CBC4"));
//Da es kein Argument gibt, wird es als Array von Object zurückgegeben
Object[] streamToArray= testList.stream().toArray();
System.out.println(Arrays.toString(streamToArray)); // ⇒ [ABC1, ABD2, DBC3, CBC4]
//Wenn Sie die Generatorfunktion angeben, die ein Array von Strings zurückgibt, wird der Wert im zurückgegebenen Array festgelegt und zurückgegeben.
String[] streamToArrayFunc = testList.stream().toArray(String[]::new);
System.out.println(Arrays.toString(streamToArrayFunc)); // ⇒ [ABC1, ABD2, DBC3, CBC4]
// String[]::neu ist "i"-> new String[i]Ist eine Abkürzung.
String[] streamToArrayFunc2 = testList.stream().toArray(i -> new String[i]);
System.out.println(Arrays.toString(streamToArrayFunc2)); // ⇒ [ABC1, ABD2, DBC3, CBC4]
//Die Rückgabe eines Arrays mit einer anderen Größe als der angegebenen Größe führt natürlich zu einem Fehler.
try {
String[] streamToArrayFunc3 = testList.stream().toArray(i -> new String[i - 1]);
} catch (IllegalStateException e) {
System.out.println(e.getClass().getName()); // ⇒ java.lang.IllegalStateException
}
}
max, min Extrahieren Sie die Maximal- und Minimalwerte aus dem Stream. Geben Sie Composer für das Argument an. Sie können die zu vergleichende Funktion wie in der Vergangenheit mit compareTo angeben. Es wird jedoch empfohlen, die Funktion in Comparator wie Java8 zu verwenden, da sie leichter zu verstehen ist. Im folgenden Beispiel wird eine Funktion namens compareInt für den Comparator verwendet. Diese Funktion verwendet jedes Element als Argument, gibt einen numerischen Wert zurück und berechnet den Mindestwert basierend auf dem zurückgegebenen Wert.
MaxMin
/**
*Stream-Terminierungsverarbeitung max,Überprüfen Sie min
*/
@Test
public void maxMin() {
List<String> testList = new ArrayList<String> (Arrays.asList("ABC1", "ABD2", "DBC3", "CBC4"));
Optional<String> streamMax = testList.stream().max((str1, str2) -> str1.substring(3, 4).compareTo(str2.substring(3,4)));
System.out.println(streamMax); ⇒ Optional[CBC4]
Optional<String> streamMin = testList.stream().min(Comparator.comparingInt(str -> Integer.parseInt(str.substring(3, 4))));
System.out.println(streamMin); ⇒ Optional[ABC1]
}
reduce Führt eine Reduktionsoperation für jedes Element von Stream durch und gibt das Ergebnis zurück. Der zurückzugebende Wert ist vom gleichen Typ wie das Stream-Element. Was ist eine Reduktionsoperation? Ich denke, es gibt viele Leute, die das sagen. Tatsächlich war ich das gleiche. Einfach ausgedrückt, nimmt eine Reduktionsoperation eine Reihe von Werten an, z. B. ein Array, und gibt ein einzelnes Zusammenfassungsergebnis zurück. Dies ist die Anzahl, das Maximum usw., die bisher herausgekommen sind. Darüber hinaus können die folgenden Operationen in Java auch als Reduktionsoperationen bezeichnet werden.
int sum = 0;
for (int i : new int[]{1, 5, 8}) {
sum += i;
}
Abhängig von der Art des Arguments gibt es drei Arten der Reduzierung.
Stichprobe
List<String> testList = new ArrayList<String> (Arrays.asList("ABC1", "ABD2", "DBC3", "CBC4"));
Optional<String> reduceValue1 = testList.stream().reduce((result, element) -> {
//Ergebnis ist die Summe bisher
//Element ist der aktuelle Wert
return String.join("/", result, element);
});
System.out.println(reduceValue1); // ⇒ Optional[ABC1/ABD2/DBC3/CBC4]
Wenn Sie BinaryOperator als Argument haben, legen Sie eine Funktion fest, die zwei Werte als Argumente hat. Der Wert, den diese Funktion zuletzt zurückgegeben hat, wird als erstes Argument eingegeben. Das zweite Argument ist der Wert des Stream-Elements. In diesem Fall ist Ergebnis = ABC1, Element = ABD2 zum ersten Mal, Ergebnis = ABC1 / ABD2, Element = DBC3 zum zweiten Mal.
Stichprobe
String reduceValue2 = testList.stream().reduce("FIRST", (result, element) -> {
//Ergebnis ist die Summe bisher
//Element ist der aktuelle Wert
return String.join("/", str1, str2);
});
System.out.println(reduceValue2); // ⇒ FIRST/ABC1/ABD2/DBC3/CBC4
Es ist fast das gleiche wie bei einem Parameter, aber hier können Sie den Anfangswert im ersten Argument festlegen. Der im zweiten Argument angegebene Akkumulator verarbeitet den im ersten Argument angegebenen Wert. Ich denke, der Grund, warum der Rückgabewert nicht optimal ist, ist, dass der im ersten Argument angegebene Wert zurückgegeben wird, selbst wenn die Liste leer ist.
Stichprobe
String reduceValue3 = testList.parallelStream().reduce("FIRST", (result, element) -> {
//Ergebnis ist die Summe bisher
//Element ist der aktuelle Wert
return String.join("/", result, element);
}, (result1, result2) -> {
//Ergebnis1 ist die Summe bisher
//Ergebnis2 ist der aktuelle Wert
return String.join("/", result1, result2);
});
System.out.println(reduceValue3); // ⇒ FIRST/ABC1-FIRST/ABD2-FIRST/DBC3-FIRST/CBC4
Wenn drei Parameter vorhanden sind, sind das erste und das zweite Argument dieselben wie bei zwei Parametern. Nur das dritte Argument ist unterschiedlich. Das dritte Argument ist eine Funktion, die nur bei paralleler Ausführung aufgerufen wird. Das Ergebnis des zweiten Arguments wird kombiniert und zurückgegeben.
collect Führt eine variable Reduktionsoperation für jedes Element des Streams durch. Die Reduktionsoperation ist wie unter Reduzieren erläutert. Was ist also variabel? Normale Reduktionsvorgänge geben einen einzelnen Wert zurück. String oder int. Eine Variablenreduktionsoperation besteht darin, Werte in einem sogenannten Variablencontainer (Collection, StringBuilder usw.) zu speichern und zurückzugeben. Der Unterschied zwischen der Rückgabe mit einem einzelnen Wert, der Rückgabe mit einem variablen Container und der Rückgabe ist der Unterschied zwischen einer Reduktionsoperation und einer variablen Reduktionsoperation.
Kehren Sie zur Beschreibung der Erfassungsfunktion zurück. Es gibt zwei Arten von Sammelfunktionen: Die eine besteht darin, Collector als Argument zu verwenden, und die andere darin, drei Arten zu verwenden: Lieferant, Akkumulator und Kombinierer. Erstens, wenn Sie einen Sammler nehmen.
collect
/**
*Überprüfen Sie, ob der Stream-Beendigungsprozess Collector sammelt
*/
@Test
public void collect1() {
List<String> testList = new ArrayList<String> (Arrays.asList("ABC1", "ABD2", "DBC3", "CBC4"));
//Stream in eine Liste konvertieren.
List<String> list = testList.stream().map(s -> s.substring(0, 2)).collect(Collectors.toList());
System.out.println(list); // ⇒ [AB, AB, DB, CB]
//Map wird mit dem Wert zurückgegeben, der von der von groupingBy als Schlüssel angegebenen Funktion zurückgegeben wird.
Map<String, List<String>> groupingMap = testList.stream().collect(Collectors.groupingBy(s -> s.substring(0,1)));
System.out.println(groupingMap); // ⇒ {A=[ABC1, ABD2], C=[CBC4], D=[DBC3]}
}
Eine variable Reduzierung kann auf diese Weise leicht erreicht werden. Sammler haben viele nützliche Funktionen. Wenn ich Zeit habe, möchte ich dies auch vorstellen.
Als nächstes drei Argumente: Lieferant, Akkumulator und Kombinierer.
collect
/**
*Überprüfen Sie das Sammeln des Stream-Beendigungsprozesses
*/
@Test
public void collect2() {
List<String> testList = new ArrayList<String> (Arrays.asList("ABC1", "ABD2", "DBC3", "CBC4"));
Map<String, List<String>> groupingMap2 = testList.stream().collect(HashMap<String, List<String>>::new, (map, s) -> {
String key = s.substring(0, 1);
List<String> innerList = map.getOrDefault(key, new ArrayList<String>());
innerList.add(s);
map.put(key, innerList);
}, (map1, map2) -> {});
System.out.println(groupingMap2); // ⇒ {A=[ABC1, ABD2], C=[CBC4], D=[DBC3]}
Map<String, List<String>> groupingMap3 = testList.parallelStream().collect(HashMap<String, List<String>>::new, (map, s) -> {
String key = s.substring(0, 1);
List<String> innerList = map.getOrDefault(key, new ArrayList<String>());
innerList.add(s);
map.put(key, innerList);
}, (map1, map2) -> {});
System.out.println(groupingMap3); // ⇒ {A=[ABC1]}Der Wert kann sich ändern.
Map<String, List<String>> groupingMap4 = testList.parallelStream().collect(HashMap<String, List<String>>::new, (map, s) -> {
String key = s.substring(0, 1);
List<String> innerList = map.getOrDefault(key, new ArrayList<String>());
innerList.add(s);
map.put(key, innerList);
}, (map1, map2) -> {
map2.forEach((key, list) -> {
List<String> innerList = map1.getOrDefault(key, new ArrayList<String>());
innerList.addAll(list);
map1.put(key, innerList);
});
});
System.out.println(groupingMap4); // ⇒ {A=[ABC1, ABD2], C=[CBC4], D=[DBC3]}
}
Mit groupingBy wird derselbe Wert wie im vorherigen Beispiel zurückgegeben. Jedes Argument hat die folgende Bedeutung. Supplier： Definieren Sie eine Funktion, die einen variablen Container zurückgibt, der von der Collect-Funktion zurückgegeben werden soll. accumulator： Der vom Lieferanten zurückgegebene Container wird als erstes Argument übergeben, und jedes Element von Stream wird als zweites Argument übergeben. Legen Sie den Wert für den von dieser Funktion zurückgegebenen Container fest. combiner： Wenn Sie keine Parallelverarbeitung durchführen, müssen Sie nichts einstellen. Definiert den Prozess zum Kombinieren der vom zweiten Argument zurückgegebenen Werte, wenn eine parallele Verarbeitung durchgeführt wird.
Dies ist das Ende der Erläuterung der Beendigungsverarbeitung. Schwer zu reduzieren und zu sammeln. Zum Sammeln bevorzuge ich Collector, weil es einfacher ist. Bitte lassen Sie mich wissen, wenn es Fehler gibt.
Recommended Posts