Vorläufiges Erlernen der neuen Funktionen von Java 1.8

Die Java 8-Version ist die revolutionärste Version seit der Veröffentlichung von Java 5 im Jahr 2004. Java 8 bringt viele neue Funktionen in die Java-Sprache, Compiler, Klassenbibliotheken, Entwicklungstools und JVM.

In diesem Artikel werden einige neue Funktionen in Java 1.8 im Detail vorgestellt. Ich hoffe, er kann Ihnen helfen.

1. Lambda-Ausdruck

Format: (Parameter) -> {Codesegment}

Zum Beispiel: new Thread(() -> {System.out.println("hello world!")}).start (); Dies ist der Lambda-Ausdruck.

Die Implementierung von Lambda muss sich auf funktionale Schnittstellen verlassen. Wenn die Methode vor jdk1.8 die Implementierungsmethode anderer Schnittstellen ausführen muss, kann dies durch anonyme innere Klassen erreicht werden

jdk1.8 Es kann anonyme innere Klassen durch Lambda-Ausdrücke ersetzen und vereinfacht werden.

package java8;
 
public class LambdaDemo {
	
	public static void main(String[] args) {
		//JDK1.8之前使用接口,采用匿名内部类的方式
		MyInterface mi = new MyInterface() {
			@Override
			public void test() {
				System.out.println("test");
			}
		};
		
		mi.test();
		
		//JDK1.8之后，使用lambda表达式
		MyInterface lmi = () -> {
			System.out.println("test");
		};
		
		lmi.test();
	}
}
//定义一个函数式接口，只有一个抽象方法 
interface MyInterface{
	
	void test();
}

Funktionale Schnittstelle: Eine Schnittstelle mit einer und nur einer abstrakten Methode wird als funktionale Schnittstelle bezeichnet.

Gemeinsame Schnittstellen der funktionalen Schnittstellen Funktion, Prädikat, Lieferant und Verbraucher befinden sich alle im Paket java.util.function apply(T t) empfängt einen Parameter und gibt ein Objekt zurück Der Produzent des Objekts

Produzenten-Konsumenten-Modell kümmert sich nur um die Produktion von Objekten

package java8;
 
import java.util.function.Function;
 
public class LambdaDemo {
 
	public static void main(String[] args) {
		// function的使用
		// 传统模式,第一个泛型：接收的参数类型 第二个泛型，返回的参数类型
		Function<String, String> function1 = new Function<String, String>() {
			@Override
			public String apply(String t) {
				return t;
			}
		};
		// 调用apply方法，并获取返回结果
		String res1 = function1.apply("function的使用");
		System.out.println(res1);
		// lambda的使用,当参数只有一个且不写参数类型时，"()"可以省略
		Function<String, String> function2 = t -> {
			return t;
		};
		// 调用apply方法，并获取返回结果
		String res2 = function2.apply("function的使用");
		System.out.println(res2);
	}
}

Verbraucherschnittstelle: Accept(T t) empfängt einen Parameter und gibt keinen Wert zurück

Der Produzent des Produzenten-Verbraucher-Modells kümmert sich nur um den Konsum Objekte

package java8;
 
import java.util.function.*;
 
public class LambdaDemo {
 
	public static void main(String[] args) {
		// predicate的使用
		// 传统模式,泛型参数：接收的参数类型
		Predicate<Integer> predicate1 = new Predicate<Integer>() {
 
			@Override
			public boolean test(Integer t) {
				// 大于等于10就为真，否则为假
				return t >= 10;
			}
 
		};
		// 执行predicate1的方法
		System.out.println(predicate1.test(11));
		System.out.println(predicate1.test(8));
		
		
		//使用lambda表达式
		Predicate<Integer> predicate2 = new Predicate<Integer>() {
			@Override
			public boolean test(Integer t) {
				// 大于等于10就为真，否则为假
				return t >= 10;
			}
		};
		// 执行predicate1的方法
		System.out.println(predicate2.test(11));
		System.out.println(predicate2.test(8));
	}
}

(Lernvideo-Sharing:

Java-Video-Tutorial

)

Praktische Verwendung von Lambda:

package java8;
 
import java.util.function.*;
 
public class LambdaDemo {
 
	public static void main(String[] args) {
		//Supplier的使用
		// 传统模式,泛型参数：返回的参数类型
		Supplier<String> s1 = new Supplier<String>() {
 
			@Override
			public String get() {
				return new String("supplier");
			}
		};
		//调用
		System.out.println(s1.get());
		
		// 使用lambda表达式
		//当代码只有一句时，可以省略"{}",不接收参数时，"()"不能省略
		Supplier<String> s2 = () -> new String("supplier");
		System.out.println(s2.get());
	}
}

2. Methodenreferenz:

Methodenreferenz bedeutet, dass es im Lambda-Ausdruck nur einen Methodenaufruf und diese Methode gibt hat eine reale Existenz. Sie können Lambda-Ausdrücke durch Methodenreferenzen ersetzen.

Es gibt vier Arten von Methodenreferenzen

Klassenname::Statischer Methodenname

Objektname::Instanzmethodenname

Klassenname::Instanzmethodenname

Klassenname::neu

package java8;
 
import java.util.function.*;
 
public class LambdaDemo {
 
	public static void main(String[] args) {
		// Consumer的使用
		// 传统模式,泛型参数：返回的参数类型
		Consumer<String> con1 = new Consumer<String>() {
 
			@Override
			public void accept(String t) {
				System.out.println(t);
			}
		};
		con1.accept("consumer");
		
		//使用lambda表达式,同时省略"()","{}"
		Consumer<String> con2 = t -> System.out.println(t);
		con2.accept("consumer");
	}
}

3.

Stream ist in Zwischenoperationen und Beendigungsoperationen unterteilt. Die Zwischenoperation gibt weiterhin einen neuen Stream zurück, und die Beendigungsoperation gibt ein Ergebnis zurück.

Wenn eine Codezeile nur eine Zwischenoperation enthält, wird diese nicht ausgeführt. Sie wird nur ausgeführt, wenn eine Beendigungsoperation auftritt.

package java8;
 
import java.util.function.*;
 
public class LambdaDemo {
 
	public static void main(String[] args) {
		//Runnable的实现，
		new Thread(() -> {
			System.out.println(Thread.currentThread().getName() + " run");
		}).start();
		
		System.out.println(Thread.currentThread().getName() + " run");
	}
}

Verwandte Empfehlungen:

Java-Einführungs-Tutorial

Das obige ist der detaillierte Inhalt vonVorläufiges Erlernen der neuen Funktionen von Java 1.8. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!