Cela fait longtemps depuis la sortie de Java8, mais j'utilise les expressions lambda et l'API Stream pour une raison quelconque, je vais donc le résumer à nouveau.
Les expressions Lambda sont un moyen simple d'implémenter une interface qui n'a qu'une seule méthode, appelée interface fonctionnelle.
Dans un langage fonctionnel comme lisp ou un langage avec un pointeur de fonction comme C, vous pouvez facilement passer une "fonction", mais en java vous ne pouvez pas la passer à moins que la fonction ne soit un objet. Par conséquent, il est possible de passer une fonction en préparant une interface fonctionnelle comme indiqué ci-dessous.
Func.java
package jp.foo;
public interface Func {
public double apply(double x);
}
Une interface fonctionnelle est une interface qui n'a qu'une seule méthode abstraite.
Jusqu'à java7, la méthode abstraite était remplacée comme suit.
Func g = new Func(){
@Override
public double apply(double x) {
return x * x;
}
};
En java8, la description peut être simplifiée comme suit en tirant parti du fait que l'interface fonctionnelle n'a qu'une seule méthode. C'est l'expression lambda.
Func f = x -> x * x;
Si vous écrivez un peu plus étroitement
Func f = (x) -> {return x * x;};
Généralement, il est décrit comme (argument 1, argument 2, ...) -> {Process 1; Process 2; ...}.
Bien sûr, s'il n'y a pas d'argument ou pas de retour, vous pouvez l'écrire vide comme () -> {}.
Il s'agit simplement de remplacer une seule méthode dans l'interface fonctionnelle.
L'interface fonctionnelle simplifie la description en tirant parti du fait qu'il n'y a qu'une seule méthode à remplacer.
Cette expression lambda est utile, par exemple, lors de l'utilisation d'une méthode qui prend une interface fonctionnelle comme argument (par exemple, comme indiqué ci-dessous).
FuncUser.java
package jp.foo;
public class FuncUser {
public static void samplePrintFunc(Func f) {
for(double x = 1.0; x <= 3.0; x += 1.0) {
System.out.println(f.apply(x));
}
}
}
La description simple sera la suivante.
FuncUser.samplePrintFunc(x -> x * x);
FuncUser.samplePrintFunc(x -> Math.sin(x));
Si le processus devient un peu compliqué, vous pouvez décrire plusieurs processus en les enfermant dans {// décrire plusieurs processus}.
FuncUser.samplePrintFunc(x -> { a = Math.sin(x); b = Math.cos(x); return a * b; });
S'il n'y a qu'un seul processus et que le type d'argument de l'interface de type de fonction et le type d'argument de la méthode que vous souhaitez utiliser sont identiques, vous pouvez l'omettre comme suit.
FuncUser.samplePrintFunc(Math::sin);
Les expressions lambda sont donc une grammaire puissante pour passer des fonctions.
Stream API
L'API Stream est un outil qui effectue le traitement de la collection à l'aide d'expressions lambda comme décrit ci-dessus. C'est une API conçue avec un style lambda. J'ai résumé celles que j'utilise souvent à titre d'exemple.
forEach Il semble que seul forEach puisse être utilisé sans appeler la méthode stream.
Arrays.asList(new Double[] { 1.0, 2.1, 3.2, 4.3, 5.4 }).forEach(System.out::println);
filter C'est pratique car il effectue une recherche raffinée. C'est facile car vous n'avez pas à écrire une instruction if dans chaque instruction for.
Arrays.asList(new Double[] { 1.0, 2.1, 3.2, 4.3, 5.4 }).stream().filter(x -> x > 3.0).forEach(System.out::println);
map Il est utilisé lorsque vous souhaitez créer une autre liste et définir à partir d'une liste ou d'un ensemble.
Arrays.asList(new Double[] { 1.0, 2.1, 3.2, 4.3, 5.4 }).stream().map(x -> x * x).forEach(System.out::println);
collect collect est puissant et élimine presque l'écriture pour les déclarations.
Écrire collect (fournisseur (variable en dehors de pour), accumulateur [processus à l'intérieur pour], combineur [processus pour collecter le fournisseur au moment du traitement parallèle]).
Arrays.asList(new Double[] { 1.0, 2.1, 3.2, 4.3, 5.4 }).stream().collect(HashMap::new, (map, x) -> map.put(x, x * x), (map1, map2) -> map1.forEach(map2::put)).entrySet().forEach(System.out::println);
En outre, il est pratique d'utiliser des collectionneurs. Le traitement que vous effectuez souvent est bien résumé et complet.
Arrays.asList(new Double[] { 1.0, 2.1, 3.2, 1.0, 5.4 }).stream().collect(Collectors.toSet()).forEach(System.out::println);
mapToDouble etc... Si vous utilisez le flux mapTo [valeur numérique], vous pouvez utiliser average, max et min, ce qui est utile.
Arrays.asList(new Double[] { 1.0, 2.1, 3.2, 4.3, 5.4 }).stream().mapToDouble(x -> x).average().ifPresent(System.out::println)
Trouvons l'écart type.
\sigma = \sqrt{\frac{1}{n} \sum_{i = 1}^n (x_i - \mu)^2}
La partie désirée suivante elle-même est multipliée par 2 lignes (2ème et 3ème lignes).
List<Double> sample = Arrays.asList(new Double[] { 1.0, 2.1, 3.2, 4.3, 5.4 });
double mu = sample.stream().mapToDouble(x -> x).average().getAsDouble();
double siguma = Math.sqrt(sample.stream().map(x -> Math.pow(x - mu, 2.0)).mapToDouble(x -> x).average().getAsDouble());
System.out.println(siguma);
Recommended Posts