SUORATOISTA JAVASSA

Stream otettiin käyttöön Java 8 Stream API:ta käytetään objektikokoelmien käsittelyyn. Java-virta on objektijono, joka tukee erilaisia menetelmiä, jotka voidaan liukuhihnalla tuottaa halutun tuloksen.

Streamin käyttö Javassa

Streamin käyttötavat Javassa on mainittu alla:

Stream API on tapa ilmaista ja käsitellä objektikokoelmia.
Anna meille mahdollisuus suorittaa toimintoja, kuten suodatuskartoituksen vähentäminen ja lajittelu.

Kuinka luoda Java Stream

Java Stream Creation on yksi perusvaiheista ennen Java Streamin toimintojen harkitsemista. Alla on syntaksi, joka on annettu Java-virran ilmoittamiselle.

Syntaksi

Striimaa virta;

Tässä T on joko luokkaobjekti tai tietotyyppi ilmoituksesta riippuen.

Java Stream -ominaisuudet

Java-streamien ominaisuudet on mainittu alla:

Virta ei ole tietorakenne; se vain ottaa syötteen kokoelmataulukoista tai I/O-kanavista.
Virrat eivät muuta alkuperäistä dataa; he tuottavat tuloksia vain käyttämällä menetelmiään.
Välioperaatiot (kuten suodatinkartta jne.) ovat laiskoja ja palauttavat toisen virran, jotta voit ketjuttaa ne yhteen.
Päätetoiminto (kuten kerätä forEach count) päättää streamin ja antaa lopullisen tuloksen.

Erilaiset toiminnot virroissa

Streamissä on kahdenlaisia toimintoja:

Keskitason toiminnot
Terminaalin toiminta

Keskitason toiminnot

Java Stream -toiminnot

Välioperaatiot ovat operaatiotyyppejä, joissa useat menetelmät on ketjutettu peräkkäin.

Keskitason toimintojen ominaisuudet

Menetelmät on ketjutettu yhteen.
Välioperaatiot muuttavat virran toiseksi virraksi.
Se mahdollistaa suodatuskonseptin, jossa yksi menetelmä suodattaa tiedot ja siirtää sen toiselle menetelmälle käsittelyn jälkeen.

Tärkeitä välioperaatioita

Alla on mainittu muutamia keskitason operaatioita:

1. kartta() : Karttamenetelmää käytetään palauttamaan virta, joka koostuu tuloksista, jotka on saatu annetun funktion soveltamisesta tämän virran elementteihin.

Syntaksi:

Striimaa kartta (toiminto kartoittaja)

2. suodatin() : Suodatusmenetelmää käytetään elementtien valitsemiseen argumenttina välitetyn Predikaatin mukaisesti.

Syntaksi:

Striimaa suodatin (predikaatti predikaatti)

3. lajiteltu() : Lajiteltu menetelmää käytetään streamin lajitteluun.

Syntaksi:

Striimaa lajiteltu()
Striimaa lajiteltu(Vertailija vertailija)

4. flatMap(): FlatMap-toimintoa Java Streamsissä käytetään tasoittamaan kokoelmavirta yhdeksi elementtivirraksi.

Syntaksi:

Striimaa flatMap (toiminto > kartoittaja)

5. different() : Poistaa päällekkäiset elementit. Se palauttaa virran, joka koostuu erillisistä elementeistä (Object.equals(Object) -asetuksen mukaan).

Syntaksi:

Striimaa erillinen()

6. kurkista() : Suorittaa toiminnon kullekin elementille muuttamatta streamia. Se palauttaa virran, joka koostuu tämän virran elementeistä ja suorittaa lisäksi kullekin elementille tarjotun toiminnon, kun elementtejä kulutetaan tuloksena olevasta virrasta.

Syntaksi:

Striimaa kurkistaa (kuluttaja toiminta)

Java-ohjelma, joka näyttää kaikkien välitoimintojen käytön:

Java

    import     java.util.Arrays  ;   import     java.util.HashSet  ;   import     java.util.List  ;   import     java.util.Set  ;   import     java.util.stream.Collectors  ;   public     class   StreamIntermediateOperationsExample     {      public     static     void     main  (  String  []     args  )     {      // List of lists of names      List   <  List   <  String  >>     listOfLists     =     Arrays  .  asList  (      Arrays  .  asList  (  'Reflection'       'Collection'       'Stream'  )      Arrays  .  asList  (  'Structure'       'State'       'Flow'  )      Arrays  .  asList  (  'Sorting'       'Mapping'       'Reduction'       'Stream'  )      );      // Create a set to hold intermediate results      Set   <  String  >     intermediateResults     =     new     HashSet   <>  ();      // Stream pipeline demonstrating various intermediate operations      List   <  String  >     result     =     listOfLists  .  stream  ()      .  flatMap  (  List  ::  stream  )         .  filter  (  s     ->     s  .  startsWith  (  'S'  ))         .  map  (  String  ::  toUpperCase  )         .  distinct  ()         .  sorted  ()         .  peek  (  s     ->     intermediateResults  .  add  (  s  ))      .  collect  (  Collectors  .  toList  ());         // Print the intermediate results      System  .  out  .  println  (  'Intermediate Results:'  );      intermediateResults  .  forEach  (  System  .  out  ::  println  );      // Print the final result      System  .  out  .  println  (  'Final Result:'  );      result  .  forEach  (  System  .  out  ::  println  );      }   }

Lähtö

Intermediate Results: STRUCTURE STREAM STATE SORTING Final Result: SORTING STATE STREAM STRUCTURE

Selitys:

listOfLists luodaan luettelona, joka sisältää muita merkkijonoluetteloita.
flatMap(Lista::stream): Tasoittaa sisäkkäiset luettelot yhdeksi merkkijonovirraksi.
suodatin(s -> s.startsWith('S')) : Suodattaa merkkijonot sisältämään vain ne, jotka alkavat S:llä.
kartta(merkkijono::toUpperCase) : Muuntaa jokaisen virran merkkijonon isoiksi kirjaimiksi.
erillinen() : Poistaa päällekkäiset merkkijonot.
lajiteltu() : Lajittelee tuloksena olevat merkkijonot aakkosjärjestykseen.
kurkistaa(...): Lisää jokaisen käsitellyn elementin välitarkastuksen intermediateResults-joukkoon.
kerätä(Collectors.toList()): Kokoaa lopulliset käsitellyt merkkijonot luetteloksi nimeltä tulos.

Ohjelma tulostaa välitulokset, jotka on tallennettu intermediateResults-joukkoon. Lopuksi se tulostaa tulosluettelon, joka sisältää täysin käsitellyt merkkijonot kaikkien stream-toimintojen jälkeen.

Terminaalin toiminta

Päätetoiminnot ovat toimintotyyppejä, jotka palauttavat tuloksen. Näitä toimintoja ei käsitellä enempää, ne vain palauttavat lopputuloksen arvon.

Tärkeitä terminaalitoimintoja

1. kerätä() : Keräysmenetelmää käytetään palauttamaan virralle suoritettujen välitoimintojen tulos.

Syntaksi:

R kerää (keräilijä keräilijä)

2. forEach() : ForEach-menetelmää käytetään iteroitaessa virran jokaisen elementin läpi.

Syntaksi:

mitätön forEach (kuluttaja toiminta)

3. vähentää(): Vähennysmenetelmää käytetään vähentämään virran elementit yhdeksi arvoksi. Vähennysmenetelmä ottaa BinaryOperatorin parametriksi.

Syntaksi:

T vähentää(T-identiteetti BinaryOperator akku)
Valinnainen vähentää (BinaryOperator akku)

4. count() : Palauttaa virran elementtien määrän.

Syntaksi:

pitkä laskenta ()

5. findFirst() : Palauttaa virran ensimmäisen elementin, jos se on olemassa.

Syntaksi:

Valinnainen löydä ensin()

6. allMatch() : Tarkistaa, vastaavatko kaikki virran elementit annettua predikaattia.

Syntaksi:

boolen allMatch(Predikaatti predikaatti)

7. Anymatch () : Tarkistaa, vastaako jokin virran osa tiettyä predikaattia.

Syntaksi:

Boolen Anymatch (predikaatti predikaatti)

Tässä ans-muuttujalle annetaan alkuarvo 0 ja siihen lisätään i.

Huomautus: Välioperaatiot suoritetaan Lazy Evaluation -konseptin perusteella, joka varmistaa, että jokainen menetelmä palauttaa kiinteän arvon (päätetoiminto) ennen siirtymistä seuraavaan menetelmään.

Java-ohjelma, joka käyttää kaikkia päätetoimintoja:

Java

    import     java.util.*  ;   import     java.util.stream.Collectors  ;   public     class   StreamTerminalOperationsExample     {      public     static     void     main  (  String  []     args  )     {      // Sample data      List   <  String  >     names     =     Arrays  .  asList  (      'Reflection'       'Collection'       'Stream'        'Structure'       'Sorting'       'State'      );      // forEach: Print each name      System  .  out  .  println  (  'forEach:'  );      names  .  stream  ().  forEach  (  System  .  out  ::  println  );      // collect: Collect names starting with 'S' into a list      List   <  String  >     sNames     =     names  .  stream  ()      .  filter  (  name     ->     name  .  startsWith  (  'S'  ))      .  collect  (  Collectors  .  toList  ());      System  .  out  .  println  (  'ncollect (names starting with 'S'):'  );      sNames  .  forEach  (  System  .  out  ::  println  );      // reduce: Concatenate all names into a single string      String     concatenatedNames     =     names  .  stream  ().  reduce  (      ''        (  partialString       element  )     ->     partialString     +     ' '     +     element      );      System  .  out  .  println  (  'nreduce (concatenated names):'  );      System  .  out  .  println  (  concatenatedNames  .  trim  ());      // count: Count the number of names      long     count     =     names  .  stream  ().  count  ();      System  .  out  .  println  (  'ncount:'  );      System  .  out  .  println  (  count  );      // findFirst: Find the first name      Optional   <  String  >     firstName     =     names  .  stream  ().  findFirst  ();      System  .  out  .  println  (  'nfindFirst:'  );      firstName  .  ifPresent  (  System  .  out  ::  println  );      // allMatch: Check if all names start with 'S'      boolean     allStartWithS     =     names  .  stream  ().  allMatch  (      name     ->     name  .  startsWith  (  'S'  )      );      System  .  out  .  println  (  'nallMatch (all start with 'S'):'  );      System  .  out  .  println  (  allStartWithS  );      // anyMatch: Check if any name starts with 'S'      boolean     anyStartWithS     =     names  .  stream  ().  anyMatch  (      name     ->     name  .  startsWith  (  'S'  )      );      System  .  out  .  println  (  'nanyMatch (any start with 'S'):'  );      System  .  out  .  println  (  anyStartWithS  );      }   }

Lähtö:

Lähtö

Selitys:

Nimiluettelo luodaan esimerkkimerkkijonoilla.
jokaiselle: Tulostaa jokaisen luettelon nimen.
kerätä : Suodattaa S-kirjaimella alkavat nimet ja kerää ne uuteen luetteloon.
vähentää : Yhdistää kaikki nimet yhdeksi merkkijonoksi.
laskea : Laskee nimien kokonaismäärän.
löydä ensin : Etsii ja tulostaa etunimen luettelosta.
allMatch : Tarkistaa, alkavatko kaikki nimet S-kirjaimella.
epäonninen : Tarkistaa, alkaako jokin nimi S-kirjaimella.

Ohjelma tulostaa jokaisen nimen S-kirjaimella alkavat nimet ketjutetut nimet nimien lukumäärän etunimen, alkavatko kaikki nimet S:llä ja alkavatko kaikki nimet S:llä.

Java Streamin edut

Meillä on joitain etuja, joiden vuoksi käytämme Streamia Javassa, kuten alla mainitaan:

Ei tallennustilaa
Toimintojen putkisto
Laiskuus
Voi olla loputon
Voidaan rinnastaa
Voidaan luoda kokoelmataulukoista Tiedostot Rivit Methods in Stream IntStream jne.