Penjelasan ekspresi lambda

Saya punya pertanyaan tentang ekspresi lambda dan RxJava. Pertanyaan-pertanyaan ini sebagian besar menyangkut pemahaman yang tidak lengkap tentang ekspresi lambda atau RxJava. Saya akan mencoba menjelaskan ekspresi lambda sesederhana mungkin. RxJava Saya akan menjelaskan secara terpisah.

Ekspresi Lambda dan RxJava

Apa itu ekspresi lambda? Ekspresi Lambda adalah "hanya" cara baru untuk melakukan hal yang sama yang selalu bisa kita lakukan, tetapi dengan cara baru yang lebih bersih dan tidak terlalu banyak menggunakan kelas batin anonim.

Kelas dalam anonim di Jawa adalah kelas yang tidak disebutkan namanya, itu harus digunakan jika Anda perlu mengganti metode kelas atau antarmuka. Kelas dalam anonim dapat dibuat dari kelas atau antarmuka.

Sebagai contoh:

abstract class Animal { abstract void speak(); } Animal a = new Animal() { void speak() { System.out.println("Woff"); } }; 

Di Android, kami biasanya menggunakan kelas dalam anonim sebagai pendengar, misalnya, untuk tombol semacam ini:

 Button btn = findViewById(R.id.button); btn.setOnClickListener( new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } ); 

Mari kita kembali ke ekspresi lambda. Ini adalah bagian selanjutnya, yang merupakan bagian dari kode sebelumnya, yang dianggap sebagai kelas dalam anonim.

 new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } 

Ekspresi Lambda hanya dapat digunakan jika Anda perlu mengganti paling banyak satu metode. Untungnya bagi kami, View.OnClickListener hanya berisi satu. Lihatlah kode di bawah ini. Menurut Anda bagian mana yang harus kita hapus?

 new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } 

Setelah menghapus hampir semua kode, kita perlu menambahkan ->, seperti pada kode di bawah ini. Tampilan parameter input dapat digunakan di dalam fungsi dengan cara yang sama seperti sebelumnya.

 (view) -> { // Do some fancy stuff with the view parameter. } 

Dalam beberapa kasus, Anda mungkin perlu menambahkan tipe ke parameter, jika kompiler tidak dapat menebaknya, Anda dapat melakukan ini dengan menambahkannya sebelum parameter:

 (View view) -> { // Do some fancy stuff with the view parameter. } 

Anda juga dapat menggunakan kode multi-line:

 (view) -> { Intent intent = new Intent(context, AuthActivity.class); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK); view.getContext().startActivity(intent); } 

Jika Anda memiliki antarmuka dengan metode yang membutuhkan dua parameter ...

 interface MyInterface { abstract void onMethod(int a, int b); } 

... ekspresi lambda akan terlihat seperti ini:

 (a, b) -> { // Do some fancy stuff with the a and b parameter. } 

Jika metode ini memiliki tipe pengembalian ...

 interface MySecondInterface { abstract int onSecondMethod(int a, int b); } 

... ekspresi lambda akan terlihat seperti ini:

 (a, b) -> { return a + b; } 

Tapi itu tidak semua, ada beberapa kasus khusus yang membuat kode lebih kecil. Jika badan metode Anda hanya berisi satu baris kode, Anda dapat menghapus kurung kurawal {} . Jika Anda menghapus kurung kurawal, Anda juga harus menghapus titik koma, meninggalkan yang berikut:

 (a, b) -> return a + b 

Ada satu hal lagi yang bisa kita lakukan. Jika kita hanya memiliki satu baris kode, maka kompiler dapat memahami apakah bagian yang dikembalikan diperlukan atau tidak, jadi kita dapat membiarkannya seperti ini:

 (a, b) -> a + b 

Jika kami memiliki kode multi-baris, itu akan menjadi sebagai berikut:

 (a, b) -> { a+=1; return a + b; } 

Jadi apa yang sudah kita lakukan? Kami mengambil ini:

 new MySecondInterface() { @Override public int onSecondMethod(final int a, final int b) { return a + b; } }; 

dan mengubahnya menjadi ini:

 (a, b) -> a + b 

Hanya ada satu hal yang tersisa, referensi metode. Misalkan kita memiliki antarmuka, seperti sebelumnya, dan metode yang menerima antarmuka ini sebagai parameter:

 public interface Callback { public void onEvent(int event); } public void myMethod(Callback callback){ } 

Tanpa ekspresi lambda, akan terlihat seperti ini:

 myMethod(new Callback() { @Override public void onEvent(final int state) { System.out.println(state); } }); 

Menambahkan ekspresi lambda, seperti yang kami lakukan sebelumnya, kami mendapatkan yang berikut:

 myMethod(state -> System.out.println(state)); 

Tapi itu belum semuanya. Jika kode yang digunakan adalah single-line dan fungsi yang dipanggil mengambil satu parameter, kita dapat melewatkan referensi metode dalam formulir ini:

 myMethod(System.out::println); 

Parameter akan diteruskan secara otomatis, tanpa perlu kode lain! Luar biasa bukan? Saya harap Anda mempelajari sesuatu yang baru!