Java 8. Lahat ng kailangan mo

Tutorial sa Java 8

"Buhay pa ang Java at nagsisimula na itong maunawaan ng mga tao."

Maligayang pagdating sa aking pagpapakilala sa Java 8. Dadalhin ka ng artikulong ito nang sunud-sunod sa lahat ng mga bagong feature mula sa Java 7 hanggang Java 8. Sa mabilis at simpleng mga halimbawa ng code, matututunan natin kung paano gumamit ng Mga Default na Interface, Mga sanggunian ng Paraan , at Mga nauulit na anotasyon . Sa dulo ng artikulo ay makikilala natin ang Stream API. Walang hindi kinakailangang satsat - code at komento lang! Pasulong!

Mga Default na Paraan para sa Mga Interface

Pinapayagan kami ng Java 8 na magdagdag ng mga di-abstract na pamamaraan (na ipinapatupad) sa mga interface sa pamamagitan ng pagdaragdag ng default. Ang feature na ito ay kilala rin bilang Extention Methods . Nasa ibaba ang unang halimbawa:

interface Formula {
    double calculate(int a);

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

Bilang karagdagan sa abstract na paraan calculate, ang interface Formulaay tumutukoy din sa isang default na paraan sqrt. Ang mga klase na nagpapatupad ng interface na ito ay kailangan lamang ipatupad ang calculate. Ang default na paraan sqrtay maaaring gamitin sa labas ng kahon.

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

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

Ang interface Formulaay ipinatupad bilang isang hindi kilalang klase. Ang code ay kalabisan: 6 na linya para sa pagpapatupad sqrt(a * 100). Tulad ng makikita natin sa susunod na seksyon, mayroong isang mas magandang paraan upang ipatupad ang isang solong pamamaraan sa Java 8.

Mga expression ng Lambda

Magsimula tayo sa isang simpleng halimbawa ng pag-uuri ng isang listahan ng mga string sa mga nakaraang bersyon ng Java:

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);
    }
});

Ang static na paraan Collections.sortay tumatanggap ng isang listahan at isang comparator sa pagkakasunud-sunod kung saan ang listahan ay dapat ayusin. Maaari kang lumikha ng anonymous na klase ng comparator anumang oras at ipasa ito. Sa halip na lumikha ng isang hindi kilalang klase, sa Java 8 maaari kang magsulat ng isang mas maikling form, isang lambda expression.

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

Tulad ng nakikita mo ang code ay mas maikli at mas madaling basahin. Ngunit ito ay maaaring gawing mas maikli:

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

Para sa isang katawan na may isang linya, maaari mong laktawan {}ang salita return. Ngunit maaari mo itong gawing mas maikli:

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

Alam ng Java compiler ang tungkol sa mga uri ng argumento, kaya maaari mo ring laktawan ang mga ito. Maghukay tayo ng mas malalim sa mga expression ng lambda at unawain kung paano ito magagamit.

Mga Functional na Interface

Paano magkasya ang mga expression ng lambda sa sistema ng uri ng Java? Ang bawat lambda ay tumutugma sa isang uri na inilarawan sa interface. Samakatuwid, ang isang functional na interface ay dapat maglaman lamang ng isang abstract na pamamaraan. Ang bawat lambda expression ng ganitong uri ay tumutugma sa abstract na pamamaraang ito. Dahil ang mga default na pamamaraan ay hindi abstract, malaya kang lumikha ng mga default na pamamaraan sa mga functional na interface kung kinakailangan. Maaari rin kaming gumamit ng mga arbitrary na interface bilang mga expression ng lambda kung mayroon lamang isang abstract na pamamaraan sa interface na ito. Upang matugunan ang mga kinakailangang ito, kailangan mong magdagdag @FucntionalInterfaceng anotasyon. Alam ng compiler ang tungkol dito at magtapon ng exception kung gusto mong magbigay ng higit sa isang abstract na paraan. Halimbawa:

@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

Tandaan na mag-compile din ang code kung @FunctionalInterfaceaalisin ang anotasyon.

Paraan at Mga Sanggunian ng Tagabuo

Ang halimbawa sa itaas ay maaari ding gawing mas maliit sa pamamagitan ng paggamit ng mga sanggunian ng pamamaraan:

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

Binibigyang-daan ka ng Java 8 na magpasa ng mga sanggunian sa isang paraan o tagabuo sa pamamagitan ng pagdaragdag ng ::. Ang halimbawa sa itaas ay nagpapakita kung paano tayo maaaring sumangguni sa isang static na pamamaraan, bagama't maaari rin tayong sumangguni sa mga non-static na pamamaraan:

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"

Tingnan natin kung paano ::ito gumagana sa mga konstruktor. Upang magsimula, tutukuyin namin ang isang halimbawang klase na may iba't ibang mga konstruktor:

class Person {
    String firstName;
    String lastName;

    Person() {}

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

Susunod, tutukuyin namin ang isang interface para sa paglikha ng mga bagong bagay:

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

Sa halip na magpatupad ng factory ng paggawa, isasama namin ang lahat ng ito sa ::tulong ng constructor:

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

Gumawa kami ng link sa constructor sa pamamagitan ng Person::new. Awtomatikong pipiliin ng Java compiler ang tamang tagabuo na tumutugma sa lagda ng pamamaraan PersonFactory.create. ... Itutuloy. Sa kasamaang palad, hindi ako nakahanap ng paraan upang mag-save ng draft ng artikulo, at ito ay talagang kakaiba, at ang oras para sa pagsasalin ay tapos na - kaya tatapusin ko ito sa ibang pagkakataon. Para sa lahat na nakakaalam at nakakaintindi ng English- Orihinal na Artikulo . Kung mayroon kang mga mungkahi para sa pagwawasto sa pagsasalin, sumulat sa anumang paraan na magagamit mo. Aking Github account