Java - Lambda Expressions

Hai there, bakal pengembang Java! Hari ini, kita akan memulai perjalanan yang menarik ke dunia Lambda Expressions. Jangan khawatir jika Anda masih pemula dalam pemrograman - saya akan mengajarkan Anda konsep ini secara langkah demi langkah, seperti yang saya lakukan untuk ribuan murid selama tahun-tahun mengajar saya. Jadi, ambil secangkir kopi (atau teh, jika itu yang Anda sukai), dan mari kita masuk ke dalamnya!

Apa Itu Lambda Expressions?

Bayangkan Anda di sebuah pesta, dan Anda ingin memberikan lelucon kepada teman-teman Anda. Daripada menulis keseluruhan lelucon dan membagikan kertas itu, tidakkah lebih mudah untuk hanya mengatakan itu secara lisan? Itu sebenarnya apa yang dilakukan Lambda Expressions di Java - mereka menyediakan cara cepat dan ringkas untuk mengekspresikan instance dari interface single-method (functional interfaces).

Lambda Expressions diperkenalkan di Java 8 untuk membawa beberapa keuntungan dari pemrograman fungsional ke Java. Mereka membuat kode Anda lebih mudah dibaca, lebih ringkas, dan kadang-kadang lebih efisien.

Sintaks Lambda Expression

Sintaks dasar dari Lambda Expression tampak seperti ini:

(parameters) -> { body }

Itu seperti sebuah fungsi kecil tanpa nama. Mari kitauraikan ini:

• parameters: Ini adalah parameter input (jika ada)
• ->: Token panah ini digunakan untuk memisahkan parameter dari tubuh
• body: Ini berisi kode yang akan dieksekusi

Karakteristik Lambda Expression Java

1. Type inference: Java seringkali bisa menentukan jenis parameter, jadi Anda tidak selalu perlu menspesifikasikan mereka.
2. Single expression: Jika tubuh berisi hanya satu ekspresi, Anda dapat menghapus kurung kurawal.
3. Banyak parameter: Anda dapat memiliki nol, satu, atau banyak parameter.
4. Return statement: Jika tubuh memiliki satu ekspresi, pernyataan return adalah opsional.

Contoh Lambda Expression Java

mari kita lihat beberapa contoh untuk melihat bagaimana Lambda Expressions bekerja dalam praktek.

Contoh 1: Lambda Expression Sederhana

// Cara tradisional
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Hello, World!");
}
};

// Cara Lambda
Runnable lambdaRunnable = () -> System.out.println("Hello, Lambda World!");

// Menjalankan keduanya
runnable.run();
lambdaRunnable.run();

Dalam contoh ini, kita menciptakan objek Runnable. Cara tradisional memerlukan kita untuk membuat kelas anonymous inner, sedangkan cara Lambda jauh lebih ringkas. Keduanya akan mencetak pesan saat dijalankan.

Contoh 2: Lambda dengan Parameter

interface MathOperation {
int operate(int a, int b);
}

public class LambdaExample {
public static void main(String[] args) {
MathOperation addition = (a, b) -> a + b;
MathOperation subtraction = (a, b) -> a - b;

System.out.println("10 + 5 = " + addition.operate(10, 5));
System.out.println("10 - 5 = " + subtraction.operate(10, 5));
}
}

Di sini, kita mendefinisikan interface fungsional MathOperation dan menggunakan Lambda Expressions untuk mengimplementasikan operasi penjumlahan dan pengurangan. Catatlah betapa bersih dan mudah dibaca kode ini menjadi!

Skop Lambda Expression Java

Lambda Expressions memiliki skop yang sama seperti kelas inner. Mereka dapat menangkap variabel dari skop pengasingan, tetapi variabel ini harus secara efektif final (nilainya tidak berubah setelah inisialisasi).

public class ScopeExample {
public static void main(String[] args) {
int multiplier = 2;
IntUnaryOperator doubler = (n) -> n * multiplier;
System.out.println(doubler.applyAsInt(4)); // Outputs: 8

// Ini akan menyebabkan kesalahan:
// multiplier = 3;
}
}

Dalam contoh ini, multiplier secara efektif final dan dapat digunakan dalam Lambda Expression.

Menggunakan Konstanta dalam Lambda Expression

Konstanta dapat digunakan bebas dalam Lambda Expressions. Mereka adalah cara yang bagus untuk membuat Lambda Expressions Anda lebih fleksibel dan dapat digunakan kembali.

public class ConstantExample {
private static final int MAGIC_NUMBER = 42;

public static void main(String[] args) {
IntSupplier magicSupplier = () -> MAGIC_NUMBER;
System.out.println("Nomor magis adalah: " + magicSupplier.getAsInt());
}
}

Di sini, kita menggunakan konstanta MAGIC_NUMBER dalam Lambda Expression. Ini adalah hal yang sah dan tidak melanggaratur aturan skop.

Menggunakan Lambda Expression dalam Koleksi

Lambda Expressions sangat bagus saat bekerja dengan koleksi. Mereka dapat membuat kode Anda menjadi lebih mudah dibaca dan ringkas. mari kita lihat beberapa contoh:

Mensortir List

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

// Cara tradisional
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});

// Cara Lambda
names.sort((a, b) -> b.compareTo(a));

System.out.println(names); // Outputs: [David, Charlie, Bob, Alice]

Mengiterasi melalui List

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Cara tradisional
for (Integer number : numbers) {
System.out.println(number);
}

// Cara Lambda
numbers.forEach(number -> System.out.println(number));

// Atau bahkan lebih ringkas
numbers.forEach(System.out::println);

Memfilter List

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Mendapatkan bilangan genap
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());

System.out.println(evenNumbers); // Outputs: [2, 4, 6, 8, 10]

Dalam contoh terakhir ini, kita menggunakan Stream API bersamaan dengan Lambda Expression untuk menyaring bilangan genap dari daftar kita. Metode filter mengambil Predicate (sebuah fungsi yang mengembalikan boolean), yang kita sediakan menggunakan Lambda Expression.

Kesimpulan

Dan itu adalah dia, teman-teman! Kita telah melakukan perjalanan melalui negeri Lambda Expressions, dari sintaks dasar mereka ke aplikasi praktis mereka dalam koleksi. Ingat, Lambda Expressions adalah seperti rempah-rempah dalam memasak - gunakan mereka bijak, dan mereka bisa membuat kode Anda menjadi lebih menarik (dan dengan menarik, saya maksud mudah dibaca dan efisien).

Seperti halnya konsep baru, kunci untuk menguasai Lambda Expressions adalah latihan. Jadi, pergilah dan lambda-fy kode Anda! Dan ingat, meskipun Anda mengalami kesalahan di jalurnya, itu semua bagian dari proses belajar. Seperti yang saya selalu katakan kepada murid-murid saya, dalam pemrograman, kesalahan adalah kesempatan untuk tumbuh dalam sembunyi.

Terus coding, terus belajar, dan terutama, bersenang-senanglah dengan itu! Sampaijumpa lagi, ini adalah guru Java yang ramah Anda menutup. Happy coding!

Credits: Image by storyset