STRUMIEŃ W JAVIE

Strumień został wprowadzony w Java 8 Stream API służy do przetwarzania kolekcji obiektów. Strumień w Javie to sekwencja obiektów obsługująca różne metody, które można potokować w celu uzyskania pożądanego rezultatu.

Użycie strumienia w Javie

Poniżej wymieniono zastosowania Stream w Javie:

Stream API to sposób wyrażania i przetwarzania kolekcji obiektów.
Umożliwiają nam wykonywanie operacji takich jak filtrowanie, mapowanie, redukcja i sortowanie.

Jak utworzyć strumień Java

Tworzenie strumienia Java jest jednym z najbardziej podstawowych kroków przed rozważeniem funkcjonalności strumienia Java. Poniżej znajduje się składnia deklarowania strumienia Java.

Składnia

Strumień strumień;

Tutaj T jest albo obiektem klasy, albo typem danych, w zależności od deklaracji.

Funkcje strumienia Java

Poniżej wymieniono funkcje strumieni Java:

Strumień nie jest strukturą danych; pobiera po prostu dane wejściowe z tablic kolekcji lub kanałów we/wy.
Strumienie nie modyfikują oryginalnych danych; dają rezultaty jedynie przy użyciu swoich metod.
Operacje pośrednie (takie jak mapa filtrów itp.) są leniwe i zwracają inny strumień, dzięki czemu można je połączyć.
Operacja terminalowa (np. liczba zbieranych forEach) kończy strumień i podaje wynik końcowy.

Różne operacje na strumieniach

Istnieją dwa typy operacji na strumieniach:

Operacje pośrednie
Operacje terminalowe

Operacje pośrednie

Operacje na strumieniu Java

Operacje pośrednie to typy operacji, w których wiele metod jest połączonych w rzędzie.

Charakterystyka operacji pośrednich

Metody są ze sobą powiązane.
Operacje pośrednie przekształcają strumień w inny strumień.
Umożliwia koncepcję filtrowania, w której jedna metoda filtruje dane i po przetworzeniu przekazuje je innej metodzie.

Ważne operacje pośrednie

Poniżej wymieniono kilka operacji pośrednich:

1. mapa() : Metoda map służy do zwrócenia strumienia składającego się z wyników zastosowania danej funkcji do elementów tego strumienia.

Składnia:

Strumień mapa (funkcja twórca map)

2. filtr() : Metoda filter służy do wybierania elementów zgodnie z predykatem przekazanym jako argument.

Składnia:

Strumień filtr (predykat orzec)

3. posortowane() : Metoda sorted służy do sortowania strumienia.

Składnia:

Strumień posortowane()
Strumień posortowane (Komparator komparator)

4. płaskaMapa(): Operacja flatMap w strumieniach Java służy do spłaszczania strumienia kolekcji w pojedynczy strumień elementów.

Składnia:

Strumień flatMap(funkcja > maper)

5. odrębny() : usuwa zduplikowane elementy. Zwraca strumień składający się z odrębnych elementów (zgodnie z Object.equals(Object)).

Składnia:

Strumień odrębny()

6. zerknij() : Wykonuje akcję na każdym elemencie bez modyfikowania strumienia. Zwraca strumień składający się z elementów tego strumienia, dodatkowo wykonując podaną akcję na każdym elemencie w miarę zużywania elementów z wynikowego strumienia.

Składnia:

Strumień zerknij (konsumencie działanie)

Program Java demonstrujący użycie wszystkich operacji pośrednich:

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

Wyjście

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

Wyjaśnienie:

Lista listOfLists jest tworzona jako lista zawierająca inne listy ciągów znaków.
flatMap(Lista::strumień): Spłaszcza zagnieżdżone listy w pojedynczy strumień ciągów.
filtr(y -> s.startsWith('S')) : Filtruje ciągi, aby uwzględnić tylko te, które zaczynają się od „S”.
mapa(String::toUpperCase) : Konwertuje każdy ciąg w strumieniu na wielkie litery.
odrębny() : Usuwa wszelkie zduplikowane ciągi.
posortowane() : Sortuje wynikowe ciągi alfabetycznie.
zerkać(...): Dodaje każdy przetworzony element do zestawu pośredniegoResults na potrzeby kontroli pośredniej.
zbieraj(Kolektory.toList()): Zbiera ostatecznie przetworzone ciągi znaków na listę o nazwie wynik.

Program drukuje wyniki pośrednie zapisane w zestawie pośrednieResults. Na koniec wypisuje listę wyników zawierającą w pełni przetworzone ciągi znaków po wszystkich operacjach na strumieniu.

Operacje terminalowe

Operacje terminalowe to typ operacji, które zwracają wynik. Operacje te nie są dalej przetwarzane, po prostu zwracają końcową wartość wyniku.

Ważne operacje terminalowe

1. zbieraj() : Metoda zbierania służy do zwracania wyniku operacji pośrednich wykonanych na strumieniu.

Składnia:

R zbieraj(Kolekcjoner kolektor)

2. dla każdego() : Metoda forEach służy do iteracji po każdym elemencie strumienia.

Składnia:

void forEach(Consumer działanie)

3. zmniejsz(): Metoda redukcji służy do redukcji elementów strumienia do pojedynczej wartości. Metoda redukcji przyjmuje jako parametr BinaryOperator.

Składnia:

T redukcja(T tożsamość BinaryOperator akumulator)
Fakultatywny zmniejsz(Operator binarny akumulator)

4. liczyć() : Zwraca liczbę elementów w strumieniu.

Składnia:

długie liczenie()

5. znajdźPierwszy() : Zwraca pierwszy element strumienia, jeśli jest obecny.

Składnia:

Fakultatywny findFirst()

6. wszystkoDopasuj() : Sprawdza, czy wszystkie elementy strumienia pasują do danego predykatu.

Składnia:

wartość logiczna allMatch(Predicate orzec)

7. Dowolny mecz () : Sprawdza, czy jakikolwiek element strumienia pasuje do danego predykatu.

Składnia:

Wartość logiczna Anymatch (predykat orzec)

Tutaj zmiennej przypisuje się wartość początkową 0 i dodaje się do niej i.

Notatka: Operacje pośrednie działają w oparciu o koncepcję leniwej oceny, która zapewnia, że każda metoda zwraca stałą wartość (operacja terminalowa) przed przejściem do następnej metody.

Program Java korzystający ze wszystkich operacji terminalowych:

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

Wyjście:

Wyjście

Wyjaśnienie:

Lista nazw jest tworzona z przykładowych ciągów znaków.
dla każdego: Drukuje każdą nazwę na liście.
zbierać : Filtruje nazwy zaczynające się na literę „S” i gromadzi je w nowej liście.
zmniejszyć : łączy wszystkie nazwy w jeden ciąg.
liczyć : Zlicza całkowitą liczbę nazw.
znajdźPierwszy : Znajduje i drukuje imię na liście.
cały mecz : Sprawdza, czy wszystkie nazwy zaczynają się od „S”.
pechowy : Sprawdza, czy jakakolwiek nazwa zaczyna się od „S”.

Program wypisuje każdą nazwę, nazwy zaczynające się na literę „S”, nazwy łączone, liczbę nazw, imię, czy wszystkie nazwy zaczynają się na „S” i czy którakolwiek nazwa zaczyna się na „S”.

Korzyści ze strumienia Java

Istnieją pewne korzyści, z powodu których używamy Stream w Javie, jak wspomniano poniżej:

Brak miejsca do przechowywania
Potok funkcji
Lenistwo
Może być nieskończony
Można pracować równolegle
Można je utworzyć z kolekcji tablic plików linii metod w strumieniu IntStream itp.