de Luis Santiago

Cum să începeți să lucrați cu Lambda Expressions în Java

Cum sa incepeti sa lucrati cu Lambda Expressions in Java

Înainte ca suportul pentru expresii Lambda să fie adăugat de JDK 8, aș fi folosit doar exemple în limbi precum C # și C ++.

Odată ce această caracteristică a fost adăugată la Java, am început să mă uit la ele puțin mai aproape.

Adăugarea expresiilor lambda adaugă elemente de sintaxă care măresc puterea expresivă a Java. În acest articol, vreau să mă concentrez asupra conceptelor fundamentale cu care trebuie să vă familiarizați, astfel încât să puteți începe să adăugați expresii lambda în codul dvs. astăzi.

Introducere rapidă

Expresiile Lambda profită de capacitățile de proces paralele ale mediilor multi-core, așa cum se vede cu sprijinul operațiunilor de conducte pe date în API-ul Stream.

Sunt metode anonime (metode fără nume) utilizate pentru a implementa o metodă definită de o interfață funcțională. Este important să știți ce este o interfață funcțională înainte de a vă murdări mâinile cu expresii lambda.

Interfață funcțională

O interfață funcțională este o interfață care conține o singură metodă abstractă.

Dacă aruncați o privire la definiția standardului Java Interfață rulabilă, veți observa cum se încadrează în definiția interfeței funcționale, deoarece definește doar o metodă: run().

În exemplul de cod de mai jos, metoda computeName este implicit abstract și este singura metodă definită, făcând MyName o interfață funcțională.

interface MyName{
  String computeName(String str);
}
Interfață funcțională

Operatorul săgeții

Expresiile Lambda introduc noul operator săgeată -> în Java. Împarte expresiile lambda în două părți:

(n) -> n*n

Partea din stânga specifică parametrii solicitați de expresie, care ar putea fi, de asemenea, goi dacă nu sunt necesari parametri.

Partea dreaptă este corpul lambda care specifică acțiunile expresiei lambda. Ar putea fi util să ne gândim la acest operator ca „devine”. De exemplu, „n devine n * n” sau „n devine n pătrat”.

Având în vedere conceptele de interfață funcțională și operator săgeată, puteți pune împreună o expresie lambda simplă:

interface NumericTest {
	boolean computeTest(int n); 
}

public static void main(String args[]) {
	NumericTest isEven = (n) -> (n % 2) == 0;
	NumericTest isNegative = (n) -> (n < 0);

	// Output: false
	System.out.println(isEven.computeTest(5));

	// Output: true
	System.out.println(isNegative.computeTest(-5));
}
Test numeric
interface MyGreeting {
	String processName(String str);
}

public static void main(String args[]) {
	MyGreeting morningGreeting = (str) -> "Good Morning " + str + "!";
	MyGreeting eveningGreeting = (str) -> "Good Evening " + str + "!";
  
  	// Output: Good Morning Luis! 
	System.out.println(morningGreeting.processName("Luis"));
	
	// Output: Good Evening Jessica!
	System.out.println(eveningGreeting.processName("Jessica"));	
}
Salutare Lambda

Variabilele morningGreeting și eveningGreeting, liniile 6 și 7 din eșantionul de mai sus, faceți o referință la MyGreeting interfață și definiți diferite expresii de salut.

Când scrieți o expresie lambda, este de asemenea posibil să specificați în mod explicit tipul parametrului în expresie astfel:

MyGreeting morningGreeting = (String str) -> "Good Morning " + str + "!";
MyGreeting eveningGreeting = (String str) -> "Good Evening " + str + "!";
Lambda cu Tip

Blocați expresiile Lambda

Până în prezent, am acoperit mostre de lambdas cu o singură expresie. Există un alt tip de expresie utilizat atunci când codul din partea dreaptă a operatorului săgeată conține mai multe declarații cunoscute sub numele bloc lambdas:

interface MyString {
	String myStringFunction(String str);
}

public static void main (String args[]) {
	// Block lambda to reverse string
	MyString reverseStr = (str) -> {
		String result = "";
		
		for(int i = str.length()-1; i >= 0; i--)
			result += str.charAt(i);
		
		return result;
	};

	// Output: omeD adbmaL
	System.out.println(reverseStr.myStringFunction("Lambda Demo")); 
}
Blochează Lambda

Interfețe funcționale generice

O expresie lambda nu poate fi generică. Dar interfața funcțională asociată cu o expresie lambda poate. Este posibil să scrieți o interfață generică și să gestionați diferite tipuri de returnare ca aceasta:

interface MyGeneric<T> {
	T compute(T t);
}

public static void main(String args[]){

	// String version of MyGenericInteface
	MyGeneric<String> reverse = (str) -> {
		String result = "";
		
		for(int i = str.length()-1; i >= 0; i--)
			result += str.charAt(i);
		
		return result;
	};

	// Integer version of MyGeneric
	MyGeneric<Integer> factorial = (Integer n) -> {
		int result = 1;
		
		for(int i=1; i <= n; i++)
			result = i * result;
		
		return result;
	};

	// Output: omeD adbmaL
	System.out.println(reverse.compute("Lambda Demo")); 

	// Output: 120
	System.out.println(factorial.compute(5)); 

}
Interfață funcțională generică

Expresiile Lambda ca argumente

O utilizare obișnuită a lambdas este de a le transmite ca argumente.

Ele pot fi utilizate în orice bucată de cod care oferă un tip țintă. Mi se pare interesant acest lucru, deoarece îmi permite să trec cod executabil ca argumente către metode.

Pentru a transmite expresiile lambda ca parametri, asigurați-vă că tipul de interfață funcțională este compatibil cu parametrul cerut.

interface MyString {
	String myStringFunction(String str);
}

public static String reverseStr(MyString reverse, String str){
  return reverse.myStringFunction(str);
}

public static void main (String args[]) {
	// Block lambda to reverse string
	MyString reverse = (str) -> {
		String result = "";
		
		for(int i = str.length()-1; i >= 0; i--)
			result += str.charAt(i);
		
		return result;
	};

	// Output: omeD adbmaL
	System.out.println(reverseStr(reverse, "Lambda Demo")); 
}
Expresia Lambda ca argument

Aceste concepte vă vor oferi o bază bună pentru a începe să lucrați cu expresii lambda. Aruncați o privire la codul dvs. și vedeți unde puteți crește puterea expresivă a Java.