Hindi simpleng simpleng daloy

Sa bawat bagong bersyon ng Java ito ay nagiging mas mayaman at mas mayaman. Bagama't ang karamihan sa kayamanan ay nasa mga naunang bersyon, ang wika ay patuloy na bumuti sa parehong pamamaraan at pagpapatupad. Ang mga koleksyon sa Java ay walang pagbubukod. Ang pangunahing balangkas ng mga koleksyon ay lumitaw sa J2SE 1.2 at patuloy na umunlad, na sumasailalim sa mga pagbabagong mas nakalulugod kaysa nakakadismaya. Sa paglabas ng JDK 5, naging mas maginhawa, mas mabilis, at mas madaling gamitin ang mga koleksyon. Ito ay humantong sa ang katunayan na ang mga programmer ay nagsimulang pagsamantalahan ang mga ito nang mas intensively. Ang ilang mga pattern ay binuo para sa pagtatrabaho sa kanila, na walang anumang pagdududa na epektibo. Ngunit sa JDK 8, ang mga koleksyon ay muling bumuti, at sila ay naging mas mahusay salamat sa mga thread. Malinaw, dahil sa ang katunayan na ang koleksyon ay maaaring katawanin sa anyo ng mga stream, ang pamamaraan para sa pakikipagtulungan sa kanila ay magbabago din. Samakatuwid, gusto kong ipakita kung paano nagiging mas simple ang pamilyar at naiintindihan na mga solusyon sa mga koleksyon.

• Halimbawa 1. Hindi ito maaaring maging mas simple
• Halimbawa 2. Maghanap ng kahit na mga halaga sa listahan at ipakita ang mga ito sa console
• Halimbawa 3. Bilangin natin kung ilang salita sa listahan ang may 5 character
• Halimbawa 4. Maglimbag ng mga natatanging salita
• Halimbawa 5. Mahabang salita
• Halimbawa 6. Mga salitang may mga numero
• Halimbawa 7. Pagpili ng mga numero

Halimbawa 1. Hindi ito maaaring maging mas simple

Siyempre, magsimula tayo sa pinakasimpleng bagay, tingnan natin ang lahat ng mga elemento ng koleksyon at ipakita ang lahat ng mga elemento.

// создадим и заполним список
   List<Integer> list = new ArrayList<>();
   Collections.addAll(list, 1, 5, 6, 11, 3, 15, 7, 8);
   // а теперь
   // быстрый for по всем elementм, только для коллекций
   for (Integer i:list){
       System.out.println(i);
   }
   //но мы уже живем в JDK 8
   //а значит нужно так
   list.stream().forEach(System.out::println);

Tulad ng napansin mo, mayroong isang bagong syntax na, sa aking opinyon bilang isang newbie sa Java, ay mas simple. Kaya, kung ano ang nakikita sa bagong syntax:

берем_список(list).превращаем_в_поток(stream).перебираем_все_элементы(forEach)(тут_интуитивно_понятно)

System.out::println— isang link sa isang static na paraan na naglalabas ng string sa console Sa halip na isang link sa isang static na paraan, maaari kang gumamit ng bahagyang naiiba, hindi gaanong malinaw na entry:

list.stream().forEach(i -> System.out.println(i));

Gumagamit ang entry na ito ng mga expression ng lambda. At oo, upang matutunan kung paano magtrabaho sa mga stream, kakailanganin mong matutunan ang mga expression ng lambda - ang mga ito ay kahanga-hanga. Dagdag pa, hindi ko ipapakita kung paano magtrabaho sa mga koleksyon gamit lamang ang mga stream, umaasa sa katotohanan na naging pamilyar ka sa mga tradisyonal na pamamaraan sa panahon ng kurso.

Halimbawa 2. Maghanap ng kahit na mga halaga sa listahan at ipakita ang mga ito sa console

list.stream().filter(i -> i%2==0).forEach(System.out::println);

Ang buong problema ay nalutas sa isang linya. Sana ay masiyahan ka sa pagtatrabaho sa isang linya. Gamit ang pamamaraan, filterna-filter namin ang stream at output kung ano ang natitira sa console. Ang filter ay isang napakalakas na bagay na makakatulong sa mga hindi inaasahang pagkakataon. Maging malikhain tayo at baguhin ang mga kondisyon ng problema. Halimbawa, kailangan nating bilangin kung gaano karaming mga even na numero ang nasa listahan:

long count = list.stream().filter(i -> i%2==0).count();

At muli sa isang linya. Kahit papaano parang simple lang ang lahat. Sa filter, gumamit kami ng lambda expression, kaya naglalagay lang ng even na mga numero sa bagong stream, at pagkatapos ay inilapat sa bagong stream count, na binibilang kung ilang elemento ang nasa bagong stream.

Halimbawa 3. Bilangin natin kung ilang salita sa listahan ang may 5 character

Naglaro na tayo ng mga integer, ngayon ay maglaro tayo ng mga salita.

List<String> list = new ArrayList<>();
Collections.addAll(list, "разые", "слова", "интересные", "And", "Not", "Very");

System.out.println(list.stream().filter(w -> w.length() == 5).count());

Ginamit namin muli ang filter. Sa filter, gamit ang isang lambda expression, isang bagong stream ang ipinakita, at pagkatapos, naiintindihan ko, countkinakalkula ko kung gaano karaming mga elemento ang nasa bagong stream.

Halimbawa 4. Maglimbag ng mga natatanging salita

Isang pamilyar na gawain kapag nagbasa kami ng maraming iba't ibang salita sa isang koleksyon mula sa isang file, at ngayon kailangan lang namin ng mga kakaiba.

List<String> list = new ArrayList<>();
Collections.addAll(list, "Vasya", "Таня", "Olya", "Vasya", "Olya", "Сергей");

list.stream().distinct().forEach(System.out::println);

Ang pangunahing aksyon ay ginawa sa stream gamit ang distinct. Susunod, iminumungkahi kong tingnan ang ilan sa aming mga gawain mula sa kurso gamit ang mga thread

Halimbawa 5. Mahabang salita

Sa ika-9 na antas ng Java Core, sa lecture 11 mayroong isang kawili-wiling problema, dito kailangan mong magsulat ng mga salita na pinaghihiwalay ng mga kuwit sa File2, ang haba nito ay mahigpit na higit sa 6. Anuman ang uri ng hardin na iyong binabakod, Iminumungkahi ko ang sumusunod na solusyon:

1. Mula sa source file nabasa namin ang lahat ng mga salita sa listahan.

2. Pagkatapos ay isinasagawa namin ang sumusunod na linya

   Optional<String> rezult = list.stream()
   				.filter(w->w.length()>6)
   				.reduce((w1,w2)->w1+", "+w2);

3. result.get()sumulat sa isang file.

Narito ang isang kawili-wiling solusyon gamit ang mga thread. Na-filter ang filter, at gamit ang reduce at regular na expression, nabuo ang kinakailangang string.

Halimbawa 6. Mga salitang may mga numero

Isulat ang lahat ng salita na naglalaman ng mga numero, halimbawa, a1 o abc3d, na pinaghihiwalay ng puwang sa File2. Ito rin ay isang kundisyon mula sa aming libro ng problema, tulad ng nahulaan mo, ang solusyon ay simple.

Optional<String> rezult = list.stream()
				.filter(w->w.matches(".*?\\d+.*?"))
				.reduce((w1,w2)->w1+" "+w2);

Na-filter namin ang stream gamit ang isang regular na expression, at pagkatapos ay bawasan at isang lambda expression. Napakaraming pagkakatulad sa nakaraang gawain.

Halimbawa 7. Pagpili ng mga numero

Ang buong gawain ay parang ganito:

• Basahin ang 2 pangalan ng file mula sa console.
• I-output sa pangalawang file ang lahat ng mga numero na nasa unang file.
• Ang mga numero ay pinaghihiwalay ng mga puwang.
• Isara ang mga stream.

Para sa pangunahing gawain, na kung saan ay ang pagsusulat ng mga numero sa isang string na pinaghihiwalay ng mga puwang, para sa karagdagang pagsusulat sa isang file, iminumungkahi kong gumamit ng isang stream, ito ay magiging ganito:

Optional<String> rezult = list.stream().filter(w->w.matches("\\d+"))
				.reduce((w1,w2)->w1+" "+w2);
System.out.println(rezult.get());

Gamit ang mga thread, ang problema ay nalutas sa isang napaka-simpleng paraan. Ngunit, narito at masdan, ihambing ang solusyon na ito sa dalawang naunang solusyon sa iyong sarili. Sa pagtatapos ng artikulo, nais kong aminin sa iyo: guys, nagdaya ako nang pumili ako ng mga halimbawa. Ang katotohanan ay pinili ko ang pinakasimpleng mga halimbawa upang maipakita sa iyo ang isang hindi pamilyar na paksa gamit ang mga pamilyar na problema. Siyempre, ang mga thread ay ginagamit para sa parehong simple at mas kumplikadong mga gawain. Ngunit tulad ng idiniin ni Horstman sa kanyang aklat, "Ang mga daloy ng data ay gumagana sa prinsipyo ng "ano, hindi kung paano gawin."," na nangangahulugang maraming mga dating kumplikadong gawain ang maaaring maging mas simple. I don't know about you, but I liked the flows, sana hindi ko kayo pinanghinaan ng loob na pag-aralan ang mga ito. At hayaan mo akong ipaliwanag ang isa pang bagay:

1. Hindi ako nagtakdang turuan ang mambabasa kung paano gumamit ng mga stream sa mga koleksyon; hindi ako ganoong karanasan sa isang guro. Nais kong ipakita sa iyo na ang mga thread ay simple at napaka-interesante! Sa pangkalahatan, ito ay isang pangangailangan.
2. Kung mas naiintindihan ko ang mga daloy, mas nakikita ko ang mga problema kung saan nilulutas nila ang lahat ng mga problema mula sa libro ng kurso, na nangangahulugan na ang mga daloy ay hindi naimbento nang walang kabuluhan.
3. Ang mga stream ay hindi lamang madaling gamitin, ngunit mayroon din silang mahalagang bentahe - kapag nagtatrabaho sa malaking halaga ng data, ang mga stream ay kadalasang mas produktibo.

PS . Binibiro ko ang LAHAT NG PROBLEMA. Inirerekomenda: Propesyonal na Java library. Volume 2 Mga advanced na tool sa programming. Kay Horstmann. Mayroon akong ikasampung edisyon.