[JAVA] Verstehe die Lambda-Formel ein wenig

Ich hatte Probleme mit dem Lambda-Stil, als ich Oracle Silver studierte, also werde ich aufschreiben, was ich verstanden habe.

Was kann der Lambda-Ausdruck tun?

Sie können die Methode wie eine Variable behandeln. Sie können eine Methode als Methodenargument übergeben. Sie können dasselbe wie eine anonyme Klasse mit einer einfacheren Beschreibung schreiben.

Konvention im Lambda-Stil

Sie müssen die abstrakte Methode der Funktionsschnittstelle überschreiben.

• Functional Interface = Eine Schnittstelle mit nur einer abstrakten Methode.

Grundlegendes Schreiben

(Typ Argumentname) -> {Prozess 1;};

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

Normal → Anonyme Klasse → Versuchen Sie, in der Reihenfolge des Lambda-Ausdrucks zu schreiben

Lambda-Ausdrücke sind ** eigentlich nur überschreibende abstrakte Methoden **. Um es zu verstehen ・ Normal überschreiben

• Mit anonymer Klasse überschreiben ・ Mit Lambda-Ausdruck überschreiben Ich werde mit drei schreiben.

Dieses Mal werden wir die abstrakte Methode accept der Funktionsschnittstelle Consumer überschreiben und implementieren.

gewöhnlich

Verbraucherschnittstelle

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

Die erste besteht darin, die Consumer-Schnittstelle normalerweise mit "implementiert" zu implementieren und die Akzeptanzmethode zu überschreiben.

Ordentliche Umsetzung

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("gewöhnlich");
	}
}

Anonyme Klasse

Als nächstes kommt die anonyme Klasse. Der Punkt ist @Override.

In anonymer Klasse implementiert

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("Anonyme Klasse");
	}
}

Lambda-Stil

Schließlich, wie die Consumer-Schnittstelle in einem Lambda-Ausdruck implementiert wird. Überschreiben der accept-Methode mit einem Lambda-Ausdruck.

Implementiert mit Lambda-Ausdruck

import java.util.function.Consumer;

public class Lambda1 {

	public static void main(String[] args) {

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

		//Abkürzungsnotation. Gleicher Vorgang wie oben.
		Consumer<String> func2 = s -> System.out.println(s);
		func.accept("Lambda-Abkürzung");
			}
}

Alles, was Sie tun, ist ** die Accept-Methode ** für alle normalen, anonymen Klassen und Lambda-Ausdrücke zu überschreiben.

1. Überschreiben Sie die Akzeptanzmethode Consumer <String> func = (s) -> {System.out.println (s);};
2. Rufen Sie die Akzeptanzmethode func.accept (" Lambda-Ausdruck ") auf;

Versuchen Sie dasselbe mit der Stream-API

Die Verwendung eines Lambda-Ausdrucks mit der Stream-API scheint am stärksten zu sein, daher werde ich es versuchen.

Die Reihenfolge ist nach wie vor wie folgt. ・ Normal implementiert ・ Als anonyme Klasse implementiert ・ Implementiert durch Lambda-Ausdruck

Verbraucherschnittstelle

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

gewöhnlich

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

		//Extrahieren Sie den Inhalt der Liste mit forEach.
		Normal n = new Normal();
		list.forEach(n);//Verbraucher im Argument von forEach<String>Übergeben Sie die Form
	}
}

Anonym

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

Lambda-Stil

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

Wenn es sich um einen Lambda-Typ handelt, ist dies eine sehr kurze Beschreibung! Es ist ziemlich einfach, weil Sie keine Geräte oder @Override schreiben müssen.

Wie forEach funktioniert

forEach verwendet einen Consumer-Typ als Argument.

forEach(Consumer<T> t)

Die accept-Methode ist in diesem Argument enthalten und wird an forEach übergeben. Und es ist ein Bild, dass die accept-Methode in forEach wiederholt ausgeführt wird. Dies ist ein praktischer Punkt für Lambda-Ausdrücke, die eine Methode als Methodenargument übergeben.

Typische Funktionsschnittstelle

Sie können die Funktionsschnittstelle selbst schreiben, aber die, die Sie am häufigsten verwenden, sind bereits verfügbar.

Consumer Es erhält nur ein Argument und hat keinen Rückgabewert. Argumenttyp: T.

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

Function Nimmt das Argument T und gibt R zurück. Argumenttyp: T. Rückgabetyp: R.

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

Predicate Nimmt das Argument T und gibt einen Booleschen Wert zurück. Argumenttyp: T. Rückgabetyp: boolean

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

Supplier Gibt T zurück, ohne Argumente zu erhalten. Rückgabetyp: T.

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

Zusammenfassung

Ich fand heraus, dass die Verwendung des Lambda-Ausdrucks die Beschreibung erheblich reduzieren kann. Es scheint, dass Sie sich daran gewöhnen können, indem Sie es als normalen → anonymen Klasse → Lambda-Typ umschreiben. Ich werde es aktiv verwenden, wenn ich Arrays und Sammlungen verwende.