Lambdas at stream, practice lang, walang theory

Kamusta kayong lahat. Sa okasyon ng kumpetisyon, nagpasya akong magsulat ng hindi isang artikulo dito, ngunit isang maikling aralin. Ito ay tungkol sa mga lambdas at stream sa Java. Kung pamilyar ka na at ginagamit mo ang mga ito, pagkatapos ay laktawan nang diretso sa dulo ng artikulo, magkakaroon ng maliit na seleksyon ng mga gawain sa JavaRush kung saan maaari kang magsanay. Kailangan mo ng java 8 at mas mataas, pagsasanay mula sa JR, magkakaroon ng ilang mga detalye at maraming mga bagay na hindi maintindihan, isang malakas na pagnanais na malaman ito. Magsimula tayo sa katotohanan na hindi ko ipapaliwanag ang kasaysayan ng paglitaw ng mga lambdas at stream, hindi ko lang alam ito sa aking sarili. Ang alam ko lang ay nagmula sila sa functional programming style, hanggang sa OOP style namin. Sa aking maikling karanasan sa pag-aaral, ipinakita ko lang kung paano at ano, may mga taong nahihirapang intindihin ang ideya, kaya tandaan mo lang kung paano sumulat, mauunawaan mo rin mamaya.

Lambdas

Kung hindi mo alam kung ano ang mga lambda, kung gayon: Ganito ang hitsura ng isang lambda:

(a, b) -> a.compareTo(b)
(переменные) -> действие

Tama na sa ngayon. Maaari mong basahin ang teorya dito: link one , link two , ngunit sa tingin ko ang pagsasanay ay mas masaya. Iminumungkahi kong lutasin mo ang sumusunod na problema: Sumulat ng calculator gamit ang paraan 1. Ang pamamaraan ay dapat tumanggap ng 2 digital na halaga at iba pa. Magiging ganito ang hitsura ng iyong code:

class Lambda{
    public static void main (String[] args) {
	}

    public static double calculate(){
       	return null;
    }
}

Kailangan mong magpasok ng 3 mga parameter sa lagda ng pamamaraan calculate, magdagdag ng 1 utos sa returnat subukan ang pagtawag sa paraang ito sa main. Ano ang dapat gawin ng pamamaraang ito?

• tiklop;
• magparami;
• hatiin;
• ibawas;
• kalkulahin ang ugat;
• itaas sa isang kapangyarihan;
• itaas sa isang kapangyarihan ang kabuuan ng mga argumento na hinati sa unang numero + 117;
• at lahat ng iba pang operasyon na maiisip mo.

Ano ang hindi dapat gamitin:

• if-else;
• charbilang tagapagpahiwatig ng operasyon;
• switch-case;
• at lahat ng bagay na pumapasok sa iyong isipan.

Ano ang maaari mong gamitin:

• Mga lambda lang, nasa kanila ang gawain.

- Ano? At lahat ng ito? - Oo, iyon lang, dahil literal na kailangan mong magdagdag ng 3 linya, kung magmumungkahi ako ng hindi bababa sa isa, ang iba ay awtomatikong isusulat. At kung gusto mo, maaari kang mag-google ng mga halimbawa at subukang maunawaan. Siyempre, susuriin mo ang iyong sarili at kung mandaraya ka, walang makakaalam, ngunit bakit? Nang malutas ang gayong simpleng problema, lahat ng aking 1.5 na estudyante ay nakakuha ng magaspang na pag-unawa kung ano ang mga lambda at kung paano gamitin ang mga ito. Ito ay lubhang kailangan para sa streaming. Kung gusto mong ipagmalaki ang resulta at malaman kung tama ang ginawa mo, ipadala ang code sa isang pribadong mensahe. Hindi na kailangang magkomento; maaari kang magdagdag ng mga kawili-wiling tip doon (ngunit sa paraang hindi masyadong mapadali ang gawain). Muli, nang malutas ang halimbawang ito, dapat ay mayroon ka nang magaspang na pag-unawa sa kung paano gamitin ang mga lambdas. Ngayon ay lumipat tayo sa mga java stream. Hindi ito ang mga stream na maaaring naisip mo, ang mambabasa. Hindi ito inputStreamat hindi ito OutputStream. Iba ito, mas kawili-wili. Ang mga stream ay pinalitan ang mga cycle, hindi ganap, ngunit pa rin. Binigyan sila ng motto na "huwag ipaliwanag kung paano ito gagawin, ipaliwanag kung ano ang gagawin." Isang maliit na halimbawa ng isang stream:

List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList.stream()
    .filter(s -> s.startsWith("c"))
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println);

Anong nangyayari dito? Magdagdag tayo ng mga komento:

myList.stream() // получить поток
    .filter(s -> s.startsWith("c")) //отфильтровать значения, оставить те, что начинаются с «с»
    .map(String::toUpperCase)  // преобразовать все значения, перевести в верхний регистр
    .sorted() // отсортировать по порядку (дефолтный порядо)
    .forEach(System.out::println); // вывести каждый элемент на экран

Ihambing sa isang regular na loop:

List<String> toSort = new ArrayList<>();
for(String s : myList){
     if(s.startsWith("c")){
         toSort.add(s.toUpperCase());
     }
}

Collections.sort(toSort);

for(String s : toSort){
     System.ouy.println(s);
}

Kapag binasa mo ang code, ang lahat ay mukhang nakakatakot, ngunit mas madali ba ito sa mga komento? Ito ay normal, hindi ko rin sila naiintindihan nang mahabang panahon. Ang susi sa pag-unawa ay pagsasanay. Samakatuwid, nagsisimula kaming magbasa ng mga artikulo ng third-party at maghanap ng mga sagot sa aming mga katanungan, maaari mo ring tanungin ang mga ito dito sa mga komento, hindi ako magbibigay ng buong sagot, ngunit ituturo ko ang direksyon. Listahan ng mga gawain mula sa JavaRush na sa tingin ko ay mahusay para sa pagsasanay ng streaming:

• 2208 - maaaring malutas sa 1 stream at 1 return, i.e. ang katawan ng pamamaraan ay magsisimula sa returnat pagkatapos ay magkakaroon ng 1 buong stream. Alisin natin ang kinakailangan StringBuilder.

• 1908 - maaari mo ring lutasin ito sa 1 stream at 1 return. Simula sa pagbabasa ng file. Hindi ko alam kung paano mag-record sa isang file sa pamamagitan ng mga stream (kung posible ito), sa ngayon ay ginagawa namin ito nang manu-mano. Yung. Nagbubukas lang kami ng 2 stream (console at pagsusulat sa isang file). Binabasa namin ang file sa pamamagitan ng mga pamamaraan na magbabalik sa amin ng alinman sa isang sheet o isang stream (google at javadoc).

• 1907 - sa teorya, maaari din itong malutas sa isang stream. Ang input sa stream ay ang pangalan ng file, ang output ay ang bilang ng mga salita sa mundo.

Iyon lang. Kung kaya ko, magsusulat ako ng isa pang simpleng kwento. Sa aking opinyon, ang pagbabasa tungkol sa isang bagay na cool na walang pagkakataon na subukan ito ay kahit papaano ay mayamot o isang bagay. At pagkatapos ng calculator at 3 puzzle, sa palagay ko ay nakikisama ka na sa mga lambda at stream, kaya basahin ang tungkol sa lahat ng mga posibilidad kung hindi mo pa nagagawa. UPD:

• 1016 - sa isang bahagyang baluktot na paraan, maaari mong lutasin ito sa 1 stream at 1 pagbabalik;

• 1821 - napakadali at sa 1 stream at 1 pagbabalik.

  Ang 2 gawaing ito ay magpapakilala sa iyo sa isa pang paraan ng streaming at isa pang kolektor.

• 1925 - maaari kang makakuha ng isang linya na may mga salita sa isang stream at pagkatapos ay isulat ito sa isang file (Hindi ko alam kung posible na magsulat sa isang file mula sa isang stream)