Jawa 8. Kabeh sing perlu

Jawa 8 Tutorial

"Jawa isih urip lan wong wiwit ngerti."

Sugeng rawuh ing introduksi kula ing Java 8. Artikel iki bakal nggawa sampeyan langkah-langkah ing kabeh fitur anyar saka Jawa 7 nganti Jawa 8. Kanthi conto kode sing cepet lan prasaja, kita bisa sinau carane nggunakake Antarmuka Default, referensi metode , lan Anotasi sing bisa diulang . Ing pungkasan artikel kita bakal kenal karo Stream API. Ora ana obrolan sing ora perlu - mung kode lan komentar! Maju!

Metode Default kanggo Antarmuka

Java 8 ngidini kita nambah cara non-abstrak (sing diimplementasikake) menyang antarmuka kanthi nambahake default. Fitur iki uga dikenal minangka Metode Ekstensi . Ing ngisor iki conto pisanan:

interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

Saliyane cara abstrak calculate, antarmuka Formulauga nemtokake cara standar sqrt. Kelas sing ngleksanakake antarmuka iki mung kudu ngleksanakake calculate. Cara standar sqrtbisa digunakake metu saka kothak.

Formula formula = new Formula() {
    @Override
    public double calculate(int a) {
        return sqrt(a * 100);
    }
};

formula.calculate(100);     // 100.0
formula.sqrt(16);           // 4.0

Antarmuka Formuladileksanakake minangka kelas anonim. Kode iki keluwih: 6 baris kanggo implementasine sqrt(a * 100). Kaya sing bakal kita deleng ing bagean sabanjure, ana cara sing luwih apik kanggo ngetrapake metode siji ing Jawa 8.

Ekspresi Lambda

Ayo diwiwiti kanthi conto prasaja ngurutake dhaptar string ing versi Jawa sadurunge:

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

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

Cara statis Collections.sortnampa dhaptar lan komparator ing urutan dhaptar sing bakal diurutake. Sampeyan bisa nggawe kelas komparator anonim lan terusake. Tinimbang nggawe kelas anonim, ing Jawa 8 sampeyan bisa nulis wangun sing luwih cendhek, ekspresi lambda.

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});

Kaya sing sampeyan ngerteni, kode kasebut luwih cendhek lan luwih gampang diwaca. Nanging iki bisa digawe luwih cendhek:

Collections.sort(names, (String a, String b) -> b.compareTo(a));

Kanggo awak kanthi siji baris, sampeyan bisa ngliwati {}tembung kasebut return. Nanging sampeyan bisa nggawe luwih cendhak:

Collections.sort(names, (a, b) -> b.compareTo(a));

Compiler Java ngerti babagan jinis argumen, supaya sampeyan uga bisa ngliwati. Ayo digali luwih jero babagan ekspresi lambda lan ngerti carane bisa digunakake.

Antarmuka Fungsional

Kepiye ekspresi lambda pas karo sistem jinis Jawa? Saben lambda cocog karo jinis sing diterangake ing antarmuka. Mulane, antarmuka fungsional kudu ngemot mung siji cara abstrak. Saben ekspresi lambda saka jinis iki bakal cocog karo metode abstrak iki. Amarga metode standar ora abstrak, sampeyan bebas nggawe metode standar ing antarmuka fungsional sing dibutuhake. Kita uga bisa nggunakake antarmuka kasepakatan minangka ekspresi lambda yen mung ana siji cara abstrak ing antarmuka iki. Kanggo nyukupi syarat kasebut, sampeyan kudu nambah @FucntionalInterfaceanotasi. Compiler ngerti babagan iki lan bakal mbuwang pengecualian yen sampeyan pengin menehi luwih saka siji cara abstrak. Tuladha:

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123

Elinga yen kode kasebut uga bakal dikompilasi yen @FunctionalInterfaceanotasi diilangi.

Metode lan Referensi Konstruktor

Conto ing ndhuwur uga bisa digawe luwih cilik kanthi nggunakake referensi metode:

Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);   // 123

Java 8 ngidini sampeyan ngirim referensi menyang metode utawa konstruktor kanthi nambahake ::. Conto ing ndhuwur nuduhake carane kita bisa ngrujuk metode statis, sanajan kita uga bisa ngrujuk metode non-statis:

class Something {
    String startsWith(String s) {
        return String.valueOf(s.charAt(0));
    }
}

Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"

Ayo ndeleng cara ::kerjane karo konstruktor. Kanggo miwiti, kita bakal nemtokake kelas conto kanthi konstruktor sing beda:

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

Sabanjure, kita bakal nemtokake antarmuka kanggo nggawe obyek anyar:

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

Tinimbang ngleksanakake pabrik nggawe, kita bakal nggabungake kabeh karo ::bantuan konstruktor:

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

Kita nggawe link menyang konstruktor liwat Person::new. Compiler Java bakal kanthi otomatis milih konstruktor sing bener sing cocog karo tandha cara PersonFactory.create. ... Diterusake. Sayange, aku ora nemokake cara kanggo nyimpen draf artikel, lan iki pancen aneh, lan wektu kanggo terjemahan wis rampung - mula aku bakal ngrampungake mengko. Kanggo kabeh sing ngerti lan ngerti Inggris - Artikel Asli . Yen sampeyan duwe saran kanggo mbenerake terjemahan, tulisake kanthi cara apa wae sing kasedhiya kanggo sampeyan. Akun Githubku