Beispielanalyse für die Verwendung von Java-Lambda-Ausdrücken

Lambada-Einführung

Lambda-Ausdruck ist eine neue Funktion, die in Java 8 hinzugefügt wurde und das Konzept der funktionalen Programmierung in Java einführt. Was ist also funktionale Programmierung?

Funktionale Programmierung: Funktionale Programmierung ist eine mathematisch orientierte Abstraktion, die Berechnung als Ausdrucksauswertung beschreibt.

Was wir normalerweise als objektorientierte Programmierung bezeichnen, gehört zur imperativen Programmierung Der Unterschied zwischen funktionaler Programmierung und imperativer Programmierung ist:

#🎜 🎜 #

• Die funktionale Programmierung befasst sich mit der Zuordnung von Daten, und die imperative Programmierung bezieht sich auf die Schritte zur Lösung von Problemen.

• Funktionale Programmierbeziehung zwischen Beziehungstypen (algebraische Strukturen), zwingende Programmierbeziehungsschritte zur Problemlösung.

Die Essenz der funktionalen Programmierung:

Welche Funktionen in der funktionalen Programmierung beziehen sich auf Nicht? eine Funktion in Computern, aber eine Funktion in der Mathematik, eine Abbildung unabhängiger Variablen. Das heißt: Der Wert einer Funktion hängt nur vom Wert des Funktionsparameters ab und ist nicht von anderen Zuständen abhängig.

Funktionale Programmierung im engeren Sinne bedeutet Programmierung ohne Verwendung veränderlicher Variablen, Zuweisungen, Schleifen und anderer zwingender Kontrollstrukturen.

Vorteile der funktionalen Programmierung:

Die Vorteile der funktionalen Programmierung ergeben sich hauptsächlich aus der Unveränderlichkeit. Ohne veränderlichen Zustand sind Funktionen referenziell transparent und haben keine Nebenwirkungen.

Die oben genannten sind einige grundlegende Konzepte, aber wir sind möglicherweise weniger mit diesen Aspekten vertraut, daher hatte ich zunächst das Gefühl, dass funktionale Programmierung eine seltene Sache ist.

Einfaches Beispiel

Sprechen ist günstig, zeig mir den Code!

Beginnen wir mit den einfachsten Beispielen sind wahrscheinlich die Beispiele, die am häufigsten vorgestellt werden. Ha ha!

Fügen Sie der Schaltfläche einen Monitor hinzu.

Verwenden Sie zum Hinzufügen anonyme innere Klassen.

submit.addActionListener(new ActionListener() {
	@Override
	public void actionPerformed(ActionEvent e) {
		JOptionPane.showMessageDialog(null, "点击了确定按钮", "确定", JOptionPane.INFORMATION_MESSAGE);
	}
});

Nachteile dieser Methode: Es wird viel Vorlagencode verwendet und der einzige Code, der wirklich notwendig ist, ist der Code im Methodenkörper. Daher kann der in Java 8 eingeführte Lambda-Ausdruck diese Art von Code vereinfachen (natürlich gibt es Einschränkungen, nicht alle

anonyme innere Klassen können das, das wird später erwähnt.).

Code mit Lambda-Ausdrücken vereinfachen

submit.addActionListener((e)->{
		JOptionPane.showMessageDialog(null, "点击了确定按钮", "确定", JOptionPane.INFORMATION_MESSAGE);
});

Der Lambda-Ausdruck ist eine anonyme Methode, die Verhalten wie Daten übergibt.

Erklärung

Es ist ersichtlich, dass der mithilfe von Lambda-Ausdrücken vereinfachte Codeausdruck klarer wird und kein Bedarf besteht Kein Schreiben mehr mühsamer Vorlagencode.

Weitere Vereinfachung

Die Parameterklammern und die geschweiften Klammern des Codekörpers können auch weggelassen werden (

Wenn es nur gibt Ein Parameter, der Kreis kann weggelassen werden. Klammern: Wenn nur eine Codezeile vorhanden ist, können Sie die geschweiften Klammern weglassen.

ActionListener listener = e->JOptionPane.showMessageDialog(null, "点击了确定按钮", "确定", JOptionPane.INFORMATION_MESSAGE);

ZusammenfassungWenn Lambda-Ausdrücke anstelle anonymer innerer Klassen zum Erstellen von Objekten verwendet werden, ersetzt der Codeblock des Lambda-Ausdrucks den Methodenkörper, der die implementiert Bei der abstrakten Methode entspricht Lambda einer anonymen Methode.

Komponenten des Lambda-Ausdrucks

Der Lambda-Ausdruck besteht aus drei Teilen:

• Formale Parameterliste. Die formale Parameterliste ermöglicht das Weglassen formaler Parametertypen. Wenn in der Parameterliste nur ein Parameter vorhanden ist, können die Klammern in der Parameterliste weggelassen werden.

• Pfeil (->). Englischer Bindestrich und Größer-als-Zeichen.

• Codeblock. Wenn der Codeblock nur einen Satz enthält, können Sie die geschweiften Klammern weglassen. Wenn es nur eine return-Anweisung gibt, können Sie return weglassen und der Lambda-Ausdruck gibt automatisch den Wert dieser Anweisung zurück.

  return 语句，可以省略 return，lambda表达式会自动返回这条语句的值。

注：
之所以可以省略形参列表是因为 编译器 可以进行类型推断，例如：

List<Dog> dogs1 = new ArrayList<Dog>();

List<Dog> dogs2 = new ArrayList<>();

上面使用 菱形语法，可以省略尖括号里面的东西，这就是类型推断的作用。
但是类型推断也不是万能的，不是所有的都可以推断出来的，所以有时候，还是要显示的添加形参类型，例如：

先不要管这个代码的具体作用。

BinaryOperator b = (x, y)->x*y;
//上面这句代码无法通过编译，下面是报错信息：无法将 * 运算符作用于 java.lang.Object 类型。
The operator * is undefined for the argument type(s) java.lang.Object, java.lang.Object

//添加参数类型，正确的代码。
BinaryOperator<Integer> b = (x, y)->x*y;

所以，类型推断不是万能的，如果编译器无法推断，那就是我们的错误，不要过度依赖编译器。有时候，显示的添加参数类型，还是很必要的，当然了，这需要去多练习。

函数式接口

前面了解了，Lambda 表达式可以代替匿名内部类，进而达到简化代码，表达清晰的目的。那么使用 Lambda 表示式的前提是什么呢？-- 函数式接口

Lambda 表达式的类型，也被称为 目标类型 （Target Type），它必须是一个函数式接口（Functional Interface）。所谓函数式接口，指的就是：只包含一个抽象方法的接口。（可以包含多个默认方法，静态方法，但必须只有一个抽象方法）。
注：Java 8 专门提供了一个注解：@FunctionalInterface

#🎜🎜##🎜🎜#Hinweis: #🎜🎜##🎜🎜#Der Grund, warum die formale Parameterliste weggelassen werden kann, liegt darin, dass der Compiler z. B. eine Typinferenz durchführen kann Beispiel: #🎜 🎜#

ActionListener listener = e->JOptionPane.showMessageDialog(null, "点击了确定按钮", "确定", JOptionPane.INFORMATION_MESSAGE);

#🎜🎜#Die Rautensyntax wird oben verwendet und die Dinge in den spitzen Klammern können weggelassen werden. Dies ist die Rolle der #🎜🎜#Typinferenz#🎜🎜#. #🎜🎜#Aber Typinferenz ist nicht allmächtig, nicht alles kann abgeleitet werden, daher ist es manchmal immer noch notwendig, #🎜🎜#formalen Parametertyp#🎜🎜# explizit hinzuzufügen, zum Beispiel: #🎜🎜##🎜 🎜# Machen Sie sich keine Sorgen über die spezifische Funktion dieses Codes. #🎜🎜#

import java.text.ParseException;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;

public class Test {
	public static void main(String[] args) throws ParseException {
		//Lambda 表达式中的构造器引用，用于简化代码。
		Creat<Dog> c = Dog::new;
		Dog dog = c.creat("小黑", 15);
		System.out.println(dog.toString());
		
		Predicate<String> predicate = (words)->{
			return words.length() > 20;
		};
		assert predicate.test("I love you yesterday and today!") : "长度小于20";
		assert !predicate.test("God bless you!") : "长度小于20";
		System.out.println("------------------------");
		
		Consumer<Dog> consumer = System.out::println;
		consumer.accept(dog);
		System.out.println("------------------------");

		Function<Dog, String> function = (dogObj)->{
			return dogObj.getName();
		};
		System.out.println(function.apply(dog));
		System.out.println("------------------------");
		
		Supplier<Dog> supplier = ()->{
			return new Dog("大黄", 4);
		};
		System.out.println(supplier.get());
		
		//一元操作符
		UnaryOperator<Boolean> unaryOperation = (flag)->{
			return !flag;
		};
		System.out.println(unaryOperation.apply(true));
		
		BinaryOperator<Integer> binaryOperator = (x, y)->x*y;
		int result = binaryOperator.apply(999, 9999);
		System.out.println(result);
	}
}

rrree#🎜🎜##🎜🎜#Wenn der Compiler ihn nicht ableiten kann, ist das unser Fehler. Manchmal ist es dennoch notwendig, Parametertypen explizit hinzuzufügen. Dies erfordert natürlich mehr Übung. #🎜🎜##🎜🎜##🎜🎜#Funktionale Schnittstelle#🎜🎜##🎜🎜#Wie wir bereits erfahren haben, können Lambda-Ausdrücke anonyme innere Klassen ersetzen, um Code zu vereinfachen und klar auszudrücken. Was sind also die Voraussetzungen für die Verwendung von Lambda-Ausdrücken? -- #🎜🎜#Functional Interface#🎜🎜##🎜🎜##🎜🎜#Der Typ des Lambda-Ausdrucks, auch Zieltyp (Target Type) genannt, muss eine funktionale Schnittstelle (Functional Interface) sein. Die sogenannte funktionale Schnittstelle bezieht sich auf: #🎜🎜#Eine Schnittstelle, die nur eine abstrakte Methode enthält. #🎜🎜# (Kann mehrere Standardmethoden und statische Methoden enthalten, es darf jedoch nur eine abstrakte Methode vorhanden sein). #🎜🎜#Hinweis: Java 8 bietet eine spezielle Annotation: @FunctionalInterface. Wird verwendet, um eine Schnittstelle als funktionale Schnittstelle zu markieren, damit sie während der Kompilierung überprüft wird. Wenn die Schnittstelle mehrere abstrakte Methoden enthält, meldet der Compiler einen Fehler. #🎜🎜#

上面使用 Lambda 表达式来为按钮添加了监视器，可以看出来，Lambda 表达式 代替了 new ActionListener()对象。

所以 Lambda 的表达式就是被当成一个对象。

例如：

ActionListener listener = e->JOptionPane.showMessageDialog(null, "点击了确定按钮", "确定", JOptionPane.INFORMATION_MESSAGE);

从上面这个例子中可以看出来，Lambda 表达式实现的是匿名方法–因此它只能实现特定函数式接口中的唯一方法。
所以 Lambda 表达式有下面两种限制：

Lambda 表达式的目标类型必须是明确的函数式接口。 Lambda 表达式只能为函数式接口创建对象。Lambda只能实现一个方法，因此它只能为含有一个抽象方法的接口（函数式接口）创建对象。 介绍几个 Java 中重要的函数接口

从这种表可以看出来，抽象方法的名字反而不是最重要的了，重要的是参数和返回值。 因为在写 Lambda 表达式的时候，也不要使用 抽象方法名了。

上面使用几个简单的例子来说明上面接口的应用：

测试代码

import java.text.ParseException;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;

public class Test {
	public static void main(String[] args) throws ParseException {
		//Lambda 表达式中的构造器引用，用于简化代码。
		Creat<Dog> c = Dog::new;
		Dog dog = c.creat("小黑", 15);
		System.out.println(dog.toString());
		
		Predicate<String> predicate = (words)->{
			return words.length() > 20;
		};
		assert predicate.test("I love you yesterday and today!") : "长度小于20";
		assert !predicate.test("God bless you!") : "长度小于20";
		System.out.println("------------------------");
		
		Consumer<Dog> consumer = System.out::println;
		consumer.accept(dog);
		System.out.println("------------------------");

		Function<Dog, String> function = (dogObj)->{
			return dogObj.getName();
		};
		System.out.println(function.apply(dog));
		System.out.println("------------------------");
		
		Supplier<Dog> supplier = ()->{
			return new Dog("大黄", 4);
		};
		System.out.println(supplier.get());
		
		//一元操作符
		UnaryOperator<Boolean> unaryOperation = (flag)->{
			return !flag;
		};
		System.out.println(unaryOperation.apply(true));
		
		BinaryOperator<Integer> binaryOperator = (x, y)->x*y;
		int result = binaryOperator.apply(999, 9999);
		System.out.println(result);
	}
}

测试使用的实体类

public class Dog {
	private String name;
	private int age;
	
	public Dog(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Dog [name=" + name + ", age=" + age + "]";
	}
}

自定义函数式接口

@FunctionalInterface
public interface Creat<T> {
	public T creat(String name, int age);
}

运行截图就不放了，感兴趣的可以试一下。

说明
我这里直接使用 Lambda 创建了对象，然后调用了这个对象的方法（就是lambda 的代码块部分），真正使用的时候，都是直接传递 Lambda 表达式的，这种方法并不推荐，但是可以让我们很好的理解为什么？ 可以看出来，Lambda 表达式的作用，最后还是需要调用 重写的抽象方法的，只不过使用表达更加清晰，简化了代码。

例如：

		List<Dog> dogs = new ArrayList<>();
		dogs.add(new Dog("大黄", 2));
		dogs.add(new Dog("小黑", 3));
		dogs.add(new Dog("小哈",1));
		//将行为像数据一样传递，使用集合的 forEach 方法来遍历集合，
		//参数可以是一个 Lambda 表达式。
		Consumer<? super Dog> con = (e)->{
			System.out.println(e);
		};
		dogs.forEach(con);
		System.out.println("--------------------------\n");
	
		//直接传递 Lambda 表达式，更加简洁
		dogs.forEach(e->System.out.println(e));
		System.out.println("--------------------------\n");

		//使用方法引用，进一步简化（可以看我的另一篇关于方法引用的博客）
		dogs.forEach(System.out::println);
		System.out.println("--------------------------\n");

		//使用 Lambda 对集合进行定制排序，按照年龄排序（从小到大）。
		dogs.sort((e1, e2)->e1.getAge()-e2.getAge());
		dogs.forEach(System.out::println);

可以看出来，通过使用 Lambda 表达式可以，极大的简化代码，更加方便的操作集合。值得一提的是：Lambda 表达式 和 Stream 的结合，可以拥有更加丰富的操作，这也是下一步学习的方向。

运行截图：

Das obige ist der detaillierte Inhalt vonBeispielanalyse für die Verwendung von Java-Lambda-Ausdrücken. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!