Inferens jenis pembolehubah tempatan dalam Java 10: Cara menggunakan kata kunci var dalam ungkapan lambda

Inferens jenis pembolehubah tempatan dalam Java 10: Cara menggunakan kata kunci var dalam ungkapan lambda

Petikan:
Java 10 memperkenalkan ciri baharu inferens jenis pembolehubah tempatan, yang membolehkan kami menggunakan kata kunci var semasa mengisytiharkan pembolehubah tempatan untuk membuat kesimpulan jenisnya. Walaupun ciri ini mungkin tidak diperlukan dalam kebanyakan kes, dalam beberapa kes ia boleh meningkatkan kebolehbacaan dan kesederhanaan kod. Artikel ini akan menumpukan pada cara menggunakan kata kunci var dalam ungkapan lambda untuk melaksanakan inferens jenis pembolehubah setempat.

Apakah inferens jenis pembolehubah tempatan?
Dalam versi Java yang lebih awal, kami perlu menyatakan secara eksplisit jenis pembolehubah tempatan semasa mengisytiharkannya. Contohnya:

String name = "John";
int age = 25;

Walau bagaimanapun, bermula dari Java 10, kita boleh menggunakan kata kunci var untuk membenarkan pengkompil secara automatik membuat kesimpulan jenis pembolehubah berdasarkan ungkapan di sebelah kanan tanpa perlu menyatakannya secara eksplisit. Contohnya:

var name = "John";
var age = 25;

Dalam contoh ini, pengkompil akan membuat kesimpulan bahawa jenis nama ialah String dan jenis umur adalah int berdasarkan ungkapan di sebelah kanan.

Faedah menggunakan kata kunci var dalam ungkapan lambda:
Apabila menggunakan ungkapan lambda, kami biasanya mencipta contoh antara muka berfungsi untuk dihantar ke kaedah lain. Menggunakan kata kunci var menjimatkan masalah untuk menentukan jenis parameter semasa membuat tika ungkapan lambda. Dengan cara ini, kita boleh lebih menumpukan pada logik ungkapan lambda tanpa memberi terlalu banyak perhatian kepada pengisytiharan jenis parameter.

Kod sampel:
Andaikan kita mempunyai kelas yang dipanggil Person, yang mengandungi dua atribut: nama dan umur:

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Sekarang, kita mahu mengisih berdasarkan atribut nama objek Orang. Sebelum Java 10, kami perlu menentukan jenis generik Comparator secara manual:

List<Person> persons = // 初始化Person对象列表

Collections.sort(persons, new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
});

Dalam contoh ini, kami mencipta kelas dalaman tanpa nama untuk melaksanakan antara muka Comparator dan mengatasi kaedah perbandingan di dalamnya. Walau bagaimanapun, kata kunci var dalam Java 10 menjadikan kod lebih bersih:

List<Person> persons = // 初始化Person对象列表

Collections.sort(persons, (var p1, var p2) -> {
    return p1.getName().compareTo(p2.getName());
});

Dalam contoh ini, kami menggunakan kata kunci var untuk membuat kesimpulan jenis p1 dan p2 tanpa perlu mengisytiharkan jenisnya secara eksplisit sebagai Orang.

Kesimpulan:
Inferens jenis pembolehubah tempatan Java 10 ialah ciri berkuasa yang membolehkan kami menulis kod yang lebih bersih dan lebih mudah dibaca. Menggunakan kata kunci var dalam ungkapan lambda membolehkan kita menumpukan pada pelaksanaan logik tanpa perlu memberi terlalu banyak perhatian kepada pengisytiharan jenis parameter. Sudah tentu, walaupun ciri ini boleh menjadi sangat berguna dalam beberapa situasi, kami masih perlu menggunakannya dengan berhati-hati untuk memastikan kebolehselenggaraan dan kebolehbacaan kod.

Bahan rujukan:

• Dokumentasi rasmi Oracle: https://docs.oracle.com/en/java/javase/10/language/local-variable-type-inference.html
• Tutorial ungkapan Lambda Java: https : //www.javatpoint.com/java-lambda-expressions

Atas ialah kandungan terperinci Inferens jenis pembolehubah tempatan dalam Java 10: Cara menggunakan kata kunci var dalam ungkapan lambda. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!