Ekspresi Lambda dalam tindakan

Beberapa contoh mudah yang mempraktikkan konsep asas ungkapan lambda:

Contoh 1 - Perbandingan pelaksanaan tanpa dan dengan lambda

Tiada penggunaan lambda:

Antara muka MyValueSemLambda1 {
double getValue(); // Kaedah abstrak
}
kelas MyValueImpl melaksanakan MyValueSemLambda1{
nilai ganda peribadi;
// Pembina untuk memulakan atribut value
awam MyValueImpl(nilai berganda) {
this.value = nilai;
}
// Pelaksanaan kaedah getValue
@Override
public double getValue() {
kembalikan this.value;
}
}
kelas awam MyValueSemLambda {
public static void main(String[] args) {
MyValueSemLambda1 myVal = MyValueImpl(98.6); // Memberikan nilai pada atribut
System.out.println("Nilai: " myVal.getValue()); // Mencetak 98.6
}
}

Menggunakan lambda:

MyValueCompare antara muka {
gandakan getValue();
}
kelas awam MyValueComparacao {
public static void main(String[] args) {
// Ungkapan Lambda tanpa atribut, tetapi mengembalikan nilai
MyValueCompares myVal = () -> 98.6;
System.out.println("Nilai: " myVal.getValue()); // Mencetak 98.6
}
}

Contoh 2 - LambdaDemo

// Antara muka yang berfungsi.
antara muka MyValue {
gandakan getValue();
}
// Satu lagi antara muka berfungsi.
antara muka MyParamValue {
double getValue(double v);
}
kelas LambdaDemo {
public static void main(String args[])
{
MyValue myVal; // mengisytiharkan rujukan antara muka
// Di sini, ungkapan lambda hanyalah ungkapan tetap.
// Apabila ia diberikan kepada myVal, instance
dibina // kelas di mana ungkapan lambda melaksanakan
// kaedah getValue() MyValue.
myVal = () -> 98.6; Ungkapan lambda yang ringkas
// Memanggil getValue(), yang disediakan oleh
// ungkapan lambda yang diberikan sebelum ini.
System.out.println("Nilai malar: " myVal.getValue());
// Sekarang buat ungkapan lambda berparameter dan tetapkan ia
// untuk rujukan MyParamValue. Ungkapan lambda ini mengembalikan
// timbal balik hujahnya.
MyParamValue myPval = (n) -> 1.0/n; Ungkapan lambda
yang mempunyai parameter
// Panggil getValue() melalui rujukan myPval.
System.out.println("Salingan 4 ialah " myPval.getValue(4.0));
System.out.println("Salingan 8 ialah " myPval.getValue(8.0));
// Ungkapan lambda mesti serasi dengan kaedah yang ditentukan
// melalui antara muka berfungsi. Oleh itu, arahan ini tidak akan berfungsi:
// myVal = () -> "tiga"; // Ralat! String tidak serasi dengan double!
// myPval = () -> Math.random(); // Ralat! Parameter diperlukan!
}
}

Output:
Nilai malar: 98.6
Saling bagi 4 ialah 0.25
Saling bagi 8 ialah 0.125

• Ungkapan lambda mestilah serasi dengan kaedah abstrak yang anda laksanakan.

Contoh ketidakserasian:

• Nilai rentetan tidak boleh digunakan jika jenis pulangan yang dijangkakan adalah dua kali ganda.

• Kaedah yang memerlukan parameter tidak boleh digunakan tanpa menyediakannya.

• Antara muka berfungsi boleh digunakan dengan mana-mana ungkapan lambda yang serasi.

Contoh 3 - Ujian Numerik

Ujian Kebolehbahagiaan: Menyemak sama ada nombor pertama boleh dibahagikan dengan yang kedua.
Perbandingan Saiz: Menentukan sama ada nombor pertama lebih kecil daripada nombor kedua.
Perbandingan Nilai Mutlak: Mengembalikan benar jika nilai mutlak kedua-dua nombor adalah sama.

• Dalam main(), tiga ujian berbeza dibuat menggunakan ungkapan lambda.

// Antara muka berfungsi yang mengambil dua parameter int dan
// mengembalikan hasil boolean.
antara muka Ujian Numerik {
ujian boolean(int n, int m);
}
kelas LambdaDemo2 {
public static void main(String args[])
{
// Ungkapan lambda ini menentukan sama ada nombor
// ialah faktor yang lain.
NumericTest isFactor = (n, d) -> (n % d) == 0;
if(isFactor.test(10, 2))
System.out.println("2 ialah faktor 10");
if(!isFactor.test(10, 3))
System.out.println("3 bukan faktor 10");
System.out.println();
// Ungkapan lambda ini kembali benar jika
// hujah pertama lebih kecil daripada hujah kedua.
Ujian Numerik kurangDari = (n, m) -> (n if(lessThan.test(2, 10))
System.out.println("2 kurang daripada 10");
jika(!lessThan.test(10, 2))
System.out.println("10 tidak kurang daripada 2");
System.out.println();
// Ungkapan lambda ini kembali benar jika anda
// nilai mutlak argumen adalah sama.
NumericTest absEqual = (n, m) -> (n if(absEqual.test(4, -4))
System.out.println("Nilai mutlak 4 dan -4 adalah sama.");
jika(!lessThan.test(4, -5))
System.out.println("Nilai mutlak 4 dan -5 tidak sama.");
System.out.println();
}
}

Output:
2 ialah faktor 10
3 bukan faktor 10
2 adalah kurang daripada 10
10 tidak kurang daripada 2
Nilai mutlak 4 dan -4 adalah sama.
Nilai mutlak 4 dan -5 adalah tidak sama.

• Ekspresi lambda yang serasi boleh digunakan dengan antara muka berfungsi yang sama.

• Pembolehubah rujukan yang sama boleh digunakan semula untuk ungkapan lambda yang berbeza.

• Menggunakan semula pembolehubah menjadikan pembacaan lebih mudah dan menjimatkan sumber dalam kod.

• Dalam contoh antara muka yang sama digunakan untuk pelaksanaan yang berbeza:

NumericTest myTest;
myTest = (n, d) -> (n % d) == 0; //pelaksanaan 1
if(myTest.test(10, 2))
System.out.println("2 ialah faktor 10");
// ...
myTest = (n, m) -> (n if(myTest.test(2, 10))
System.out.println("2 kurang daripada 10");
//...
myTest = (n, m) -> (n if(myTest.test(4, -4))
System.out.println("Nilai mutlak 4 dan -4 adalah sama.");
// ...

Kejelasan dengan pembolehubah rujukan

Menggunakan pembolehubah rujukan yang berbeza (cth. isFactor, lessThan, absEqual) membantu anda mengenal pasti dengan jelas ungkapan lambda yang diwakili oleh setiap pembolehubah.

Spesifikasi berbilang parameter

Berbilang parameter dalam ungkapan lambda dipisahkan dengan koma dalam senarai kurungan di sebelah kiri pengendali lambda.
Contoh: (n, d) -> (n % d) == 0.

Penggunaan pelbagai jenis dalam ungkapan lambda

Tiada sekatan pada jenis parameter atau pengembalian dalam kaedah abstrak antara muka berfungsi.
Jenis data bukan primitif seperti String boleh digunakan dalam ungkapan lambda.

Contoh ujian dengan rentetan

Antara muka berfungsi boleh digunakan untuk menguji keadaan berkaitan rentetan tertentu, seperti menyemak sama ada satu rentetan terkandung dalam rentetan yang lain.

// Antara muka berfungsi yang menguji dua rentetan.
antara muka StringTest {
ujian boolean(String aStr, String bStr);
}
kelas LambdaDemo3 {
public static void main(String args[])
{
// Ungkapan lambda ini menentukan sama ada rentetan berfungsi
// sebahagian daripada yang lain.
StringTest isIn = (a, b) -> a.indexOf(b) != -1;
String str = "Ini adalah ujian";
System.out.println("Rentetan ujian: " str);
if(isIn.test(str, "is a"))
System.out.println("'adalah' ditemui.");
lain
System.out.println("'is a' not found.");
if(isIn.test(str, "xyz"))
System.out.println("'xyz' Ditemui");
lain
System.out.println("'xyz' tidak ditemui");
}
}

Output:
Rentetan ujian: Ini ialah ujian
'adalah' ditemui.
'xyz' tidak ditemui

Antara muka berfungsi StringTest

Mentakrifkan ujian kaedah abstrak (String aStr, String bStr) yang mengembalikan nilai boolean.

Pelaksanaan dengan ungkapan lambda

Ungkapan lambda (a, b) -> a.indexOf(b) != -1 menyemak sama ada rentetan (b) terkandung dalam (a) yang lain.

Taip inferens dalam parameter

Parameter a dan b disimpulkan sebagai jenis String, membenarkan penggunaan kaedah kelas String, seperti indexOf.

Atur cara menguji rentetan "Ini adalah ujian" untuk melihat sama ada ia mengandungi subrentetan "is a" dan "xyz", mencetak hasilnya dengan sewajarnya.

Atas ialah kandungan terperinci Ekspresi Lambda dalam tindakan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!