Coffee break #163. Apakah perbezaan antara lambda dan rujukan kaedah. 5 Cara Menggabungkan String Null dalam Java

Apakah perbezaan antara lambda dan rujukan kaedah

Sumber: Reddit IntelliJ IDEA mencadangkan menggantikan ungkapan lambda dengan rujukan kaedah. Apakah perbezaan antara mereka? Ternyata terdapat perbezaan halus antara ungkapan lambda dan rujukan kaedah. Sebagai contoh, bandingkan: myInstance::getStuff dan () ->myInstance.getStuff() . Secara umum, kedua-dua pilihan adalah bersamaan antara satu sama lain. Tetapi jika myInstance adalah batal, dan lambda menghasilkan penunjuk nol apabila menilai lambda, maka rujukan kaedah akan dijana serta-merta apabila cuba mengakses rujukan. Dan apa? Secara umum, ini penting jika kod yang menilai ungkapan lambda berada di dalam tangkapan cuba dengan penuding nol. Sebagai contoh, saya mempunyai fungsi mightBeNull(Fungsi Pembekal<T>) yang melakukan sesuatu seperti ini:

try {
    doStuff(function.get().getSomeMore().getSomeMore());
} catch (NullPointerException e) {
    doOtherStuff();
}

Jika memanggil mightBeNull(() -> myNullVariable.getStuff()) akan berfungsi tanpa membuang pengecualian, maka "setara": mightBeNull(myNullVariable::getStuff) akan membuang NullPointerException serta-merta apabila fungsi dipanggil. Itu bezanya. Catatan. Menurut Stackoverflow, jika anda menggantikan lambda dengan rujukan kaedah, kod bait kelas akan menjadi lebih padat, yang bermaksud kelas akan dimuatkan dengan lebih cepat ke dalam JVM. Walau bagaimanapun, untuk mengalami keuntungan sedemikian, beribu-ribu lambda yang tidak dioptimumkan diperlukan. Walau bagaimanapun, dalam projek besar, jumlah sedemikian boleh dikumpul dengan mudah. Jika tidak, pilihan antara lambda dan rujukan kaedah adalah soal rasa dan kebolehbacaan kod. Contohnya, jika lambda mempunyai beberapa baris, maka kebolehbacaan dikurangkan dan kod hanya akan mendapat manfaat jika lambda diletakkan dalam kaedah yang berasingan dan rujukan kepadanya digunakan.

5 Cara Menggabungkan String Null dalam Java

Sumber: Gitconnected Selepas membaca siaran ini, anda akan mempelajari lebih banyak cara untuk bekerja dengan rentetan dalam Java. Java menyediakan banyak cara untuk menggabungkan rentetan, tetapi kadangkala apabila kita tidak memberi perhatian kepada rentetan null, kita boleh berakhir dengan null, yang jelas bukan yang kita mahu. Jadi gunakan kaedah saya yang disyorkan untuk mengelakkan nilai nol apabila menggabungkan String.

Analisis Masalah

Jika kita ingin menggabungkan tatasusunan rentetan, kita hanya boleh menggunakan operator +. Walau bagaimanapun, kami mungkin menghadapi nilai nol semasa melakukan ini .

String[] values = {"https", "://", "gist.", "github", ".com", null};
String result = "";

for (String value : values) {
    result = result + value;
}

Menggabungkan semua elemen ini membawa kita kepada hasil ini: Walaupun kami menemui masalah, nilai nol yang terhasil juga digabungkan sebagai rentetan, yang jelas bukan apa yang kami harapkan. Dan walaupun kita sedang mengusahakan Java 8 atau lebih tinggi, menggunakan kaedah String.join() statik untuk menyertai rentetan, kita masih akan berakhir dengan nilai nol .

String[] values = {"https", "://", "gist.", "github", ".com", null};
String result = String.join("", values);

Hasilnya adalah sama: Jadi bagaimana untuk menyelesaikan masalah ini? Terdapat beberapa penyelesaian. Untuk memudahkan untuk menunjukkan kod kemudian, kami mengekstrak kaedah yang boleh melepasi rentetan dan mengembalikan rentetan bukan nol.

public String nullToString(String value) {
    return value == null ? "" : value;
}

1. String.concat()

String.concat() ialah kaedah yang disertakan dengan kelas String . Ia sangat mudah untuk penggabungan rentetan.

for (String value : values) {
    result = result.concat(getNonNullString(value));
}

Oleh kerana kaedah nullToString() dipanggil, tidak ada nilai null sebagai hasilnya .

2.StringBuilder

Kelas StringBuilder menyediakan banyak kaedah yang berguna dan mudah untuk membina rentetan. Yang paling biasa digunakan antaranya ialah kaedah append() , yang menggunakan append() untuk menggabungkan rentetan dan digabungkan dengan kaedah nullToString() untuk mengelakkan nilai nol .

String[] values = {"https", "://", "gist.", "github", ".com", null};
StringBuilder result = new StringBuilder();

for (String value : values) {
    result = result.append(nullToString(value));
}

Hasilnya, anda boleh mendapatkan hasil berikut:

3. Kelas StringJoiner (Java 8+)

Kelas StringJoiner menyediakan fungsi yang lebih berkuasa untuk menyambung rentetan. Ia bukan sahaja boleh menentukan pembatas semasa penggabungan, tetapi juga menentukan awalan dan akhiran. Apabila menggabungkan rentetan, kita boleh menggunakan kaedah add() . Kaedah nullToString() juga akan digunakan di sini untuk mengelakkan nilai nol .

String[] values = {"https", "://", "gist.", "github", ".com", null};
StringJoiner result = new StringJoiner("");

for (String value : values) {
    result = result.add(nullToString(value));
}

4. Streams.filter (Java 8+)

API Strim ialah kelas operasi aliran berkuasa yang diperkenalkan dalam Java 8 yang boleh melakukan penapisan standard, padanan, traversal, kumpulan, statistik dan operasi lain.

• Penapis operasi penapis boleh menerima fungsi Predikat .
• Antara muka fungsi Predikat adalah sama seperti antara muka Fungsi yang diperkenalkan sebelum ini.
• Ini ialah antara muka yang berfungsi.
• Ia boleh mengambil parameter generik <T> dan nilai pulangan ialah jenis Boolean.
• Predikat sering digunakan untuk data penapis .

Jadi kita boleh mentakrifkan Predikat untuk menyemak rentetan nol dan menyerahkannya kepada kaedah penapis() daripada API Strim. Selain itu, anda boleh menggunakan kaedah Collectors.joining() untuk menyertai rentetan bukan nol yang tinggal.

String[] values = {"https", "://", "gist.", "github", ".com", null};

String result = Arrays.stream(values)
    .filter(Objects::nonNull)
    .collect(Collectors.joining());

5. Gunakan operator +

Menggunakan operator + juga boleh menyelesaikan masalah, tetapi ia tidak disyorkan. Kami tahu bahawa String ialah objek yang tidak boleh diubah. Menggunakan tanda + selalunya mencipta objek rentetan, dan setiap kali rentetan baharu dicipta dalam ingatan, jadi penggunaan prestasi menggunakan tanda + untuk menggabungkan rentetan adalah sangat tinggi.

Kesimpulan

Artikel ini membentangkan beberapa kaedah untuk menggabungkan rentetan dan mengendalikan NULL, di mana kaedah yang berbeza mungkin sesuai untuk senario yang berbeza. Analisis menunjukkan bahawa prestasi StringBuilder adalah yang terbaik. Tetapi dalam keadaan sebenar, anda perlu menggabungkan senario tertentu dan kemudian memilih kaedah dengan kehilangan prestasi paling sedikit.