[JAVA] Comprendre un peu la formule lambda

J'ai eu du mal avec le style Lambda tout en étudiant Oracle Silver, donc je vais écrire ce que j'ai compris.

Que peut faire l'expression lambda?

Vous pouvez traiter la méthode comme une variable. Vous pouvez passer une méthode comme argument de méthode. Vous pouvez écrire la même chose qu'une classe anonyme avec une description plus simple.

Convention de style Lambda

Vous devez remplacer la méthode abstraite de l'interface fonctionnelle.

• Interface fonctionnelle = Une interface qui n'a qu'une seule méthode abstraite.

Écriture de base

(Tapez le nom de l'argument) -> {Process 1;};

(Object o) -> {System.out.println(o);};

Normal → Classe anonyme → Essayez d'écrire dans l'ordre de l'expression lambda

Les expressions Lambda ne sont ** en fait que remplaçant les méthodes abstraites **. Pour le comprendre ・ Remplacer normalement -Override avec classe anonyme ・ Remplacer avec l'expression lambda J'écrirai avec trois.

Cette fois, nous remplacerons et implémenterons la méthode abstraite accept de l'interface fonctionnelle Consumer.

d'habitude

Interface consommateur

@FunctionalInterface
public interface Consumer<T> {
   void accept(T t);
//...
}

La première consiste à implémenter normalement l'interface Consumer avec des "implements" et à remplacer la méthode accept.

Mise en œuvre ordinaire

import java.util.function.Consumer;

public class Lambda2 implements Consumer<String> {

	@Override
	public void accept(String s) {
		System.out.println(s);
	}

	public static void main(String[] args) {
		Lambda2 lam2 = new Lambda2();
		lam2.accept("d'habitude");
	}
}

Classe anonyme

Vient ensuite la classe anonyme. Le point est @Override.

Implémenté en classe anonyme

import java.util.function.Consumer;

public class lambda3 {

	public static void main(String[] args) {
		Consumer<String> func = new Consumer<String>() {
			@Override
			public void accept(String s) {
				System.out.println(s);
			}
		};
		func.accept("Classe anonyme");
	}
}

Style Lambda

Enfin, comment implémenter l'interface Consumer dans une expression lambda. Remplacement de la méthode accept par une expression lambda.

Implémenté avec une expression lambda

import java.util.function.Consumer;

public class Lambda1 {

	public static void main(String[] args) {

		Consumer<String> func = (s) -> {System.out.println(s);};
		func.accept("Style Lambda");

		//Notation d'abréviation. Même processus que ci-dessus.
		Consumer<String> func2 = s -> System.out.println(s);
		func.accept("Abréviation Lambda");
			}
}

Tout ce que vous faites est ** de remplacer la méthode accept ** pour toutes les classes normales, anonymes et expressions lambda.

1. Remplacez la méthode accept Consumer <String> func = (s) -> {System.out.println (s);};
2. Appelez la méthode accept func.accept (" expression lambda ");

Essayez la même chose avec l'API Stream

L'utilisation d'une expression lambda avec l'API Stream semble être la plus puissante, je vais donc l'essayer.

Comme précédemment, l'ordre est le suivant. ・ Mis en œuvre normalement ・ Mis en œuvre en tant que classe anonyme ・ Implémenté par expression lambda

Interface consommateur

@FunctionalInterface
public interface Consumer<T> {
   void accept(T t);
//...
}

d'habitude

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Normal implements Consumer<String>{
	@Override
	public void accept(String s) {
		System.out.println(s);
	}

	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("1");
		list.add("2");
		list.add("3");

		//Extrayez le contenu de la liste avec forEach.
		Normal n = new Normal();
		list.forEach(n);//Le consommateur dans l'argument de forEach<String>Passer le moule
	}
}

Anonyme

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Tokumei {

	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("1");
		list.add("2");
		list.add("3");

		list.forEach(new Consumer<String>() {
			@Override
			public void accept(String s) {
				System.out.println(s);
			}
		});
	}
}

Style Lambda

import java.util.ArrayList;
import java.util.List;

public class Lambda4 {

	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("1");
		list.add("2");
		list.add("3");

		list.forEach(s -> System.out.println(s));
	}
}

Le style Lambda est une très courte description! C'est assez facile car vous n'avez pas besoin d'écrire des outils ou @Override.

Comment fonctionne forEach

forEach prend un type Consumer comme argument.

forEach(Consumer<T> t)

La méthode accept est incluse dans cet argument et est passée à forEach. Et c'est une image que la méthode accept est exécutée à plusieurs reprises dans forEach. C'est un point pratique pour les expressions lambda qui passent une méthode en tant qu'argument de méthode.

Interface fonctionnelle typique

Vous pouvez écrire vous-même l'interface fonctionnelle, mais celles que vous utilisez le plus sont déjà disponibles.

Consumer Il ne reçoit qu'un argument et n'a pas de valeur de retour. Type d'argument: T

@FunctionalInterface
public interface Consumer<T> {
   void accept(T t);
//...
}

Function Prend l'argument T et renvoie R. Type d'argument: T Type de retour: R

@FunctionalInterface
public interface Function<T, R> {
   R apply(T t);
//...
}

Predicate Prend l'argument T et renvoie un booléen. Type d'argument: T Type de retour: booléen

@FunctionalInterface
public interface Predicate<T> {
   boolean test(T t);
//...
}

Supplier Renvoie T sans recevoir d'arguments. Type de retour: T

@FunctionalInterface
public interface Supplier<T> {
   T get();
//...
}

Résumé

J'ai trouvé que l'utilisation de l'expression lambda peut réduire considérablement la description. Il semble que vous puissiez vous y habituer en le réécrivant comme normal → classe anonyme → type lambda. Je vais l'utiliser activement lors de l'utilisation de tableaux et de collections.