Wie Sie wissen, ermöglicht ** Stream **, das in Java 8 hinzugefügt wurde, das Schreiben einer funktionalen sprachähnlichen Verarbeitung auch in Java (mehr als 3 Jahre sind seit der Veröffentlichung im Jahr 2014 zum Zeitpunkt des Schreibens des Artikels vergangen). Es ist lange her, aber ...). [^ 1]
Da es einen Mechanismus gibt, um Code präzise zu schreiben, gibt es keinen Grund, ihn nicht zu verwenden.
Hier werden wir nach und nach den Code weglassen, der den einfachen Prozess der Konvertierung von "List
Die folgenden Begriffe gelten als bereits verstanden und werden hier nicht erläutert.
Wenn Sie ein schnelles Verständnis wünschen, werden die folgenden Artikel empfohlen.
Schreiben wir zunächst mit Legacy-Code vor Java 7.
final List<String> numTextList = Arrays.asList("0", "1", null);
final List<Integer> numList = new ArrayList<>();
for(final String numText : numTextList){
if(numText == null){
continue;
}
final int num = Integer.parseInt(numText);
numList.add(num);
}
Verarbeitungseinheit: 8 Zeilen / 149 Zeichen
Die erweiterte for-Anweisung ist moderner als die reguläre for-Anweisung, aber es ist nicht cool, den Elementtyp schreiben zu müssen. Es ist auch gefährlich, dass "numList" mit einer leeren Liste initialisiert wird und während der iterativen Verarbeitung Nebenwirkungen auf externe Variablen hat.
Ab hier schreibe ich ab Java 8 modernen Code.
final List<String> numTextList = Arrays.asList("0", "1", null);
final List<Integer> numList = numTextList.stream()
.filter((String numText) -> {
return Objects.nonNull(numText);
})
.map((String numText) -> {
return Integer.parseInt(numText);
})
.collect(Collectors.toList());
Verarbeitungseinheit: 8 Zeilen / 197 Zeichen
Mit Stream können Sie jetzt direkt "numList" erstellen. Dies ist jedoch ein ziemlich redundanter Schreibstil, und es kann nicht gesagt werden, dass er die Güte von Stream am besten nutzt.
final List<String> numTextList = Arrays.asList("0", "1", null);
final List<Integer> numList = numTextList.stream()
.filter((numText) -> {
return Objects.nonNull(numText);
})
.map((numText) -> {
return Integer.parseInt(numText);
})
.collect(Collectors.toList());
Verarbeitungseinheit: 8 Zeilen / 183 Zeichen
In Lambda-Ausdrücken können Sie Typnamen weglassen, die durch Typinferenz abgeleitet werden können.
final List<String> numTextList = Arrays.asList("0", "1", null);
final List<Integer> numList = numTextList.stream()
.filter(numText -> {
return Objects.nonNull(numText);
})
.map(numText -> {
return Integer.parseInt(numText);
})
.collect(Collectors.toList());
Verarbeitungseinheit: 8 Zeilen / 179 Zeichen
In Lambda-Ausdrücken können Sie die das Argument umgebenden Klammern weglassen, wenn es ein Argument gibt.
final List<String> numTextList = Arrays.asList("0", "1", null);
final List<Integer> numList = numTextList.stream()
.filter(numText -> Objects.nonNull(numText))
.map(numText -> Integer.parseInt(numText))
.collect(Collectors.toList());
Verarbeitungseinheit: 4 Zeilen / 145 Zeichen
In Lambda-Ausdrücken können Sie die wellenförmigen Klammern und die return-Anweisung weglassen, wenn der Prozessor in eine Zeile schreiben kann. Erst als ich hierher kam, hatte ich weniger Zeichen als Java 7 und früher. Wenn Sie jeden Prozess in eine Zeile schreiben, ist der Zusammenhang der Methodenkette leicht zu verstehen.
final List<String> numTextList = Arrays.asList("0", "1", null);
final List<Integer> numList = numTextList.stream()
.filter(s -> Objects.nonNull(s))
.map(s -> Integer.parseInt(s))
.collect(Collectors.toList());
Verarbeitungseinheit: 4 Zeilen / 121 Zeichen
Lambda-Ausdrucksvariablen werden nur im laufenden Betrieb verwendet, sodass Variablennamen durch einen einzelnen Buchstaben dargestellt werden können. In diesem Fall ist es einfacher zu verstehen, ob Sie den ersten Buchstaben des Typnamens oder den ersten Buchstaben des ursprünglichen Variablennamens verwenden. Ich denke, dieses Format ist ein vertrauter Schreibstil, aber es ist immer noch optional.
final List<String> numTextList = Arrays.asList("0", "1", null);
final List<Integer> numList = numTextList.stream()
.filter(Objects::nonNull)
.map(Integer::parseInt)
.collect(Collectors.toList());
Verarbeitungseinheit: 4 Zeilen / 107 Zeichen
Wenn die Argument-Signaturen (Typen und ihre Reihenfolge) übereinstimmen, können Sie Methodenreferenzen anstelle von Lambda-Ausdrücken verwenden. Ich denke, die Vereinfachung des Codes hat den Prozessablauf klarer gemacht.
Wenn Sie es zu sehr weglassen, kann es schwierig sein, es zu verstehen.
In meinem Fall schreibe ich grundsätzlich in einen Lambda-Ausdruck, aber wenn die Methodenreferenz nützlich ist (Objects :: nonNull, Path :: toFile usw.), verwende ich sie.
Auf jeden Fall möchte ich versuchen, gut lesbaren Code zu schreiben.
[^ 1]: [Neue API und Erweiterungs-API, die Lambda-Ausdrücke und Streams in Java SE 8 verwendet](http://docs.oracle.com/javase/jp/8/docs/technotes/guides/language/lambda_api_jdk8 .html)
Recommended Posts