Saya tidak akan menulis bagian sintaksis, mari kita ajukan pertanyaan praktis untuk melihat kenyamanan apa yang dapat dibawa oleh fitur -fitur baru Java8 ini kepada kami.
Ngomong -ngomong, beberapa pemrograman generik digunakan, semuanya adalah menyederhanakan kode
Pemandangan:
Kelas data yang mencatat informasi karyawan
Karyawan kelas publik {nama string publik; Usia int publik; seks arang publik; waktu string publik; gaji int int;}Kami memiliki kolom jenis data ini
Daftar <eployee> data = arrays.aslist (E1, E2, E3 ......)
Ada kebutuhan sekarang: Karyawan Grup dengan surat awal nama mereka (dengan asumsi mereka semua nama bahasa Inggris):
Maka hasil yang ingin kami dapatkan harus menjadi hubungan pemetaan seperti Map：char -> List<Employee>
peta statis public <karakter, daftar <eployee>> groupbyfirstchar (daftar <eployee> data) {peta <karakter, daftar <sploudeee>> hasil = hashmap baru <> (); untuk (karyawan e: data) {karakter c = e.name.charat (0); Daftar <eployee> l = result.get (c); if (l == null) {l = ArrayList baru <> (); result.put (c, l); } l.add (e); } return hasil;}Kode ini tidak rumit dan dapat segera selesai. Bos melihat bahwa Anda sangat efisien, jadi dia mengatakan bahwa Anda akan membaginya menjadi kelompok -kelompok sesuai dengan gaji Anda, bagi mereka yang di bawah 5.000, 5.000 ~ 10.000 ... dll.
Itu tidak akan terlalu sulit, cukup ubah kunci dan memprosesnya sedikit logis
peta statis public <string, daftar <eployee>> groupBySalary (daftar <eployee> data) {peta <string, daftar <sploudeee>> result = hashmap baru <> (); untuk (karyawan e: data) {string key = terpisah (e.salary); Daftar <eployee> l = result.get (key); if (l == null) {l = ArrayList baru <> (); result.put (tombol, l); } l.add (e); } return hasil; <br>} string statis pribadi terpisah (int gaji) {if (gaji <= 5000) {return "kurang dari 5000"; } if (gaji <= 10000) {return "5000 ~ 10000"; } if (gaji <= 20000) {return "10000 ~ 20000"; } return "di atas 20000"}Kemudian bos berkata lagi, mari kita membagi karyawan menjadi kelompok -kelompok sesuai dengan tahun kerja mereka. . .
Saya tidak akan menulis kode di sini. Jika Anda membandingkannya, Anda akan menemukan bahwa tidak peduli bagaimana Anda mengelompokkannya, satu -satunya perubahan adalah cara untuk memilih nilai kunci.
Surat pertama nama karyawan digunakan sebagai kunci untuk pertama kalinya:
Karyawan E -> e.name.charat (0)
Kali kedua saya mengubah gaji karyawan menjadi string sebagai kunci sesuai dengan metode separatat:
Karyawan E -> terpisah (E.Salary): String
Dan sebagainya
Karyawan E -> getYear (E.Time): String
Bahkan, pertama kali Anda juga dapat menulis huruf pertama menjadi satu metode.
Karyawan E -> getFirstchar (e.name): karakter
Agar terlihat lebih cantik, kita dapat mengatakan bahwa parameter dari tiga metode diatur ke karyawan. Badan Metode tidak ditulis. Hanya parameter dan nilai pengembalian yang tercantum di sini.
Karyawan E -> getFirstchar (E): Karaktermployee E -> terpisah (e): StringEmployee E -> getYear (E): String
Sisi kiri -> adalah parameter, sisi kanan: adalah nilai pengembalian, dan sisi kanan -> adalah tanda tangan dari metode ini
Kemudian kita secara alami akan berpikir untuk mengekstraksi bagian yang diubah sebagai parameter dan bagian lain yang tidak berubah sebagai badan metode, sehingga kita dapat menghilangkan kode duplikat. Jelas, bagian yang diubah adalah metode yang tercantum di atas, yang mengubah karyawan menjadi kunci, tetapi kita tahu bahwa Java tidak dapat melewati metode sebagai parameter. Namun, ini bukan masalah bagi pemrogram dengan sedikit pengalaman. Kita dapat menggunakan antarmuka untuk mencapai tujuan kita, dan pada saat yang sama kita akan menghadapi masalah lain. Nilai pengembalian dari tiga metode di atas berbeda, jadi kita perlu menggunakan obat generik:
public static <k> peta <K, daftar <eployee>> groupBykey (daftar <eployee> data, getkey <k> getkey) {peta <k, daftar <eployee>> hasil = hashmap baru <> (); untuk (karyawan e: data) {k key = getKey.getKey (e); Daftar <eployee> l = result.get (key); if (l == null) {l = ArrayList baru <> (); result.put (tombol, l); } l.add (e); } return hasil;} antarmuka getKey <k> {k getkey (karyawan e);}Maka persyaratan pertama di atas dapat direalisasikan dengan cara ini
Peta <karakter, daftar <eployee>> result = groupBykey (data, GetKey baru <caracter> () {@Override Public Character GetKey (karyawan E) {e.name.charat (0);}});Persyaratan kedua
Peta <String, Daftar <eployee>> hasil = groupBykey (daftar, GetKey baru <string> () {@Override Public String getKey (karyawan e) {terpisah (e.salary);}});Dapat ditemukan bahwa kita hanya perlu mengubah parameter generik dan implementasi kelas internal anonim. Satu -satunya masalah adalah tidak terlalu realistis, dan banyak kode rutin terutama tercermin dalam kelas internal anonim.
Bahkan, kami hanya peduli dengan parameter dan mengembalikan nilai kelas dalam anonim ini, dan sisanya hanyalah persyaratan sintaksis.
Java8 kebetulan memberi kita cara yang baik untuk menghindari rutinitas yang rumit: ekspresi lambda, implementasi di atas dapat ditulis sebagai
Peta <karakter, daftar <eployee>> resultByFirstchar = groupBykey (daftar, e -> e.name.charat (0)); peta <string, daftar <eployee>> resultBysalary = groupBykey (daftar, e -> terpisah (e.salary));
Ekspresi Lambda hanya menunjukkan apa yang kita pedulikan, parameter, dan nilai pengembalian. Pada saat yang sama, karena jenis inferensi, jenis parameter dapat dihilangkan. Sintaks spesifik tidak akan diperkenalkan di sini. Banyak informasi dapat ditemukan di internet
tambahan:
Jika Anda memiliki pemahaman obat generik yang baik, metode GroupBykey dapat diabstraksi lebih lanjut:
Public Static <K, E> MAP <K, Daftar <E>> GroupBy (Daftar <? Memperluas data E>, Fungsi <? Super E ,? Memperluas K> Fun) {Map <K, Daftar <E> Hasil = HashMap baru <> (); untuk (e e: data) {k k = fun.apply (e); <br> Daftar <E> l = result.get (k); if (l == null) {l = ArrayList baru <> (); result.put (k, l); } l.add (e); } return hasil; <br>}Kami juga telah mengekstraksi kelas karyawan, dan manfaatnya jelas
Antarmuka fungsi adalah antarmuka yang baru ditambahkan ke Java8:
@FunctionInterfacepublic Interface Function <t, r> {r apply (t t);}Masukkan tipe T untuk kembali ke tipe R. Kombinasi generik dan pemrograman fungsional sangat bagus. Meskipun fitur baru Java8 telah dikritik oleh berbagai jenis keluhan, selalu baik untuk membawa manfaat, yang memberi kita lebih banyak pilihan.
Jika Anda punya waktu, saya akan memperkenalkan aliran, alat hebat lainnya untuk java8
Di atas adalah penerapan ekspresi Lambda di Java 8 dan beberapa pengetahuan terkait generik yang diperkenalkan kepada Anda oleh editor. Saya harap ini akan membantu Anda. Jika Anda memiliki pertanyaan, silakan tinggalkan saya pesan dan editor akan membalas Anda tepat waktu. Terima kasih banyak atas dukungan Anda ke situs web Wulin.com!