Le traitement Java 8 Stream peut être omis jusqu'à présent!

Comme vous le savez, ** Stream ** ajouté à Java 8 permet également d'écrire des traitements de type langage fonctionnel en Java (plus de 3 ans se sont écoulés depuis la publication de 2014 au moment de la rédaction de l'article). C'est il y a longtemps, mais ...). [^ 1] Puisqu'il existe un mécanisme pour écrire du code de manière concise, il n'y a aucune raison de ne pas l'utiliser. Ici, nous allons progressivement omettre le code qui effectue le processus simple de conversion de List <String> en List <Integer>, et montrer la différence.

introduction

Les termes suivants sont supposés être déjà compris et ne sont pas expliqués ici.

Stream
** Interface fonctionnelle **
** Type Lambda **
** Se référer à la méthode **

Si vous voulez une compréhension rapide, les articles suivants sont recommandés.

Qu'est-ce que la programmation fonctionnelle, qu'est-ce que lambda

Java 7 ou version antérieure

Tout d'abord, écrivons avec du code hérité avant Java 7.

Utiliser une instruction étendue

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);
}

Unité de traitement: 8 lignes / 149 caractères

L'instruction for étendue est plus moderne que l'instruction for classique, mais ce n'est pas cool d'avoir à écrire le type d'élément. Il est également dangereux que numList soit initialisé avec une liste vide et qu'il ait un effet secondaire sur les variables externes pendant le traitement itératif.

Java 8 ou version ultérieure

À partir de là, j'écrirai en code moderne à partir de Java 8.

Utiliser Stream

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());

Unité de traitement: 8 lignes / 197 caractères

En utilisant Stream, vous pouvez maintenant créer directement numList. Cependant, il s'agit d'un style d'écriture assez redondant, et on ne peut pas dire qu'il utilise au mieux les bienfaits de Stream.

Omettre le nom du type d'argument

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());

Unité de traitement: 8 lignes / 183 caractères

Dans les expressions lambda, vous pouvez omettre les noms de type qui peuvent être déduits par inférence de type.

Omettez les parenthèses dans la partie argument

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());

Unité de traitement: 8 lignes / 179 caractères

Dans les expressions lambda, vous pouvez omettre les parenthèses entourant l'argument lorsqu'il y a un argument.

Omettez les crochets ondulés dans la section de traitement

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());

Unité de traitement: 4 lignes / 145 caractères

Dans les expressions lambda, vous pouvez omettre les crochets ondulés et l'instruction return si le processeur peut écrire sur une seule ligne. Seulement quand je suis arrivé ici, il y avait moins de caractères que Java 7 et les versions antérieures. Si vous écrivez chaque processus sur une seule ligne, la connexion de la chaîne de méthodes est facile à comprendre.

Raccourcir le nom de la variable

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());

Unité de traitement: 4 lignes / 121 caractères

Les variables d'expression Lambda ne sont utilisées qu'à la volée, les noms de variables peuvent donc être représentés par une seule lettre. Dans ce cas, il sera plus facile à comprendre si vous utilisez la première lettre du nom de type ou la première lettre du nom de variable d'origine. Je pense que ce format est un style d'écriture familier, mais il est toujours facultatif.

Utiliser la référence de méthode

final List<String> numTextList = Arrays.asList("0", "1", null);

final List<Integer> numList = numTextList.stream()
		.filter(Objects::nonNull)
		.map(Integer::parseInt)
		.collect(Collectors.toList());

Unité de traitement: 4 lignes / 107 caractères

Si les signatures d'argument (types et leur ordre) correspondent, vous pouvez utiliser des références de méthode au lieu d'expressions lambda. Je pense que la simplification du code a rendu le processus plus clair.

en conclusion

Si vous l'omettez trop, cela peut être difficile à comprendre. Dans mon cas, j'écris essentiellement dans des expressions lambda, mais lorsque les références de méthode sont utiles (comme ʻObjects :: nonNull et Path :: toFile`), j'essaye de les utiliser. Dans tous les cas, je veux essayer d'écrire du code hautement lisible.

Lien de référence

[^ 1]: [Nouvelle API et API d'extension qui utilise des expressions et des flux lambda dans Java SE 8](http://docs.oracle.com/javase/jp/8/docs/technotes/guides/language/lambda_api_jdk8 .html)