Strumienie Java dla początkujących: wprowadzenie do korzystania ze strumieni w Javie

Strumienie Java 8 umożliwiają programistom wyodrębnianie precyzyjnych danych z dużej kolekcji przy użyciu zestawu predefiniowanych operacji.

Przed wydaniem Javy 8 użycie terminu „strumień” w Javie było automatycznie kojarzone z I/O. Jednak Java 8 wprowadziła strumień, który można nazwać zestawem kroków obliczeniowych połączonych w coś, co jest powszechnie określane jako „potok strumienia”.

Ten artykuł wprowadzi Cię w strumienie Java 8 i zademonstruje, jak mogą być przydatne w Twoich projektach.

Co to jest strumień?

Strumień to interfejs Java, który pobiera źródło, przeprowadza zestaw operacji w celu wyodrębnienia określonych danych, a następnie dostarcza je do aplikacji do użycia. Zasadniczo pozwala wyodrębnić wyspecjalizowane dane ze zbioru danych uogólnionych.

Jak działają strumienie

Potok strumienia zawsze zaczyna się od źródła. Typ źródła zależy od typu danych, z którymi mamy do czynienia, ale dwa z bardziej popularnych to tablice i kolekcje.

Aby przekształcić kolekcję w strumień początkowy, musisz dodać strumień() funkcja do źródła. Spowoduje to umieszczenie źródła w potoku strumienia, w którym kilka różnych operacji pośrednich (takich jak filtr() oraz sortować() ) może na nim działać.

Po wykonaniu wszystkich wymaganych operacji pośrednich można wprowadzić operację terminalową (taką jak dla każdego() ), co spowoduje wygenerowanie wcześniej wyodrębnionych danych ze źródła.

Życie bez strumieni

Java 8 została wydana w 2014 roku, ale wcześniej programiści Java nadal musieli wyodrębniać specjalistyczne dane ze zbioru ogólnych danych.

jak usunąć instagram z facebooka

Załóżmy, że masz listę losowych znaków, które są połączone z losowymi liczbami, aby utworzyć unikalne wartości ciągu, ale chcesz tylko wartości zaczynające się od znaku C i chcesz uporządkować wynik w kolejności rosnącej. W ten sposób możesz wyodrębnić te dane bez strumieni.

Związane z: Co musisz wiedzieć o używaniu ciągów w Javie

Przykład filtrowania i sortowania wartości bez strumieni

  
import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.List;  
public class Main {  
public static void main(String[] args) {  
//declare and initialize the array list  
List randomValues = Arrays.asList(  
'E11', 'D12', 'A13', 'F14', 'C15', 'A16',  
'B11', 'B12', 'C13', 'B14', 'B15', 'B16',  
'F12', 'E13', 'C11', 'C14', 'A15', 'C16',  
'F11', 'C12', 'D13', 'E14', 'D15', 'D16'  
);  
//declare the array list will store needed values  
List requiredValues = new ArrayList();  
//extracting the required values and storing them in reqquiredValues  
randomValues.forEach(value -> {  
if(value.startsWith('C')) {  
requiredValues.add(value);  
}  
});  
//sort the requiredValues in ascending order  
requiredValues.sort((String value1, String value2) -> value1.compareTo(value2));  
//print each value to the console  
requiredValues.forEach((String value) -> System.out.println(value));  
}  
}

Będziesz także musiał zadeklarować i zainicjować listę tablic, niezależnie od tego, czy używasz strumieni, czy innej metody ekstrakcji. To, czego nie musiałbyś robić, jeśli używasz strumieni, to zadeklarować nową zmienną do przechowywania wymaganych wartości, ani utworzyć pozostałych pięciu plus wierszy kodu w powyższym przykładzie.

Związane z: Jak tworzyć i wykonywać operacje na tablicach w Javie

Powyższy kod generuje w konsoli następujące dane wyjściowe:

Życie ze strumieniami

W programowaniu wydajność przemawia za uzyskaniem tego samego wyniku przy znacznie mniejszej ilości kodu. To jest dokładnie to, co potok strumieniowy robi dla programisty. Więc następnym razem, gdy ktoś zapyta: dlaczego ważne jest, aby używać strumieni w swoim projekcie? Mówiąc prościej: strumienie wspierają wydajne programowanie.

Kontynuując nasz przykład powyżej, w ten sposób wprowadzenie strumieni zmienia cały program.

Filtrowanie i sortowanie wartości na przykładzie strumienia

  
import java.util.Arrays;  
import java.util.List;  
public class Main {  
public static void main(String[] args) {  
//declare and initialize the array list  
List randomValues = Arrays.asList(  
'E11', 'D12', 'A13', 'F14', 'C15', 'A16',  
'B11', 'B12', 'C13', 'B14', 'B15', 'B16',  
'F12', 'E13', 'C11', 'C14', 'A15', 'C16',  
'F11', 'C12', 'D13', 'E14', 'D15', 'D16'  
);  
//retrieves only values that start with C, sort them, and print them to the console.  
randomValues.stream().filter(value->value.startsWith('C')).sorted().forEach(System.out::println);  
}  
}

Powyższy kod pokazuje, jak potężny jest interfejs strumienia. Pobiera listę losowych wartości tablicy i przekształca ją w strumień za pomocą strumień() funkcjonować. Strumień jest następnie redukowany do listy tablicowej zawierającej wymagane wartości (czyli wszystkie wartości zaczynające się od C ), używając filtr() funkcjonować.

Jak widać w powyższym przykładzie, C wartości są losowo rozmieszczone na liście tablic. Jeśli miałbyś wydrukować strumień w tym punkcie potoku, wartość C15 zostanie wydrukowany jako pierwszy. Dlatego też sortować() funkcja została wprowadzona do potoku strumienia, aby zmienić kolejność nowej tablicy w kolejności rosnącej.

Ostatnią funkcją w potoku strumienia jest a dla każdego() funkcjonować. Jest to funkcja terminala, która służy do zatrzymywania potoku strumienia i generuje w konsoli następujące wyniki:

Operacje pośrednie w strumieniu

Istnieje obszerna lista operacji pośrednich, których można użyć w potoku strumienia.

Potok strumieniowy zawsze zaczyna się od jednego źródła i a strumień() i zawsze kończy się pojedynczą operacją terminala (chociaż jest kilka różnych do wyboru). Ale pomiędzy tymi dwiema sekcjami znajduje się lista sześciu pośrednich operacji, których możesz użyć.

W powyższym przykładzie używane są tylko dwie z tych operacji pośrednich: filtr() oraz sortować() . Wybrana operacja pośrednia będzie zależeć od zadań, które chcesz wykonać.

Jeśli którakolwiek z wartości zaczynających się od C na naszej liście tablic powyżej była pisana małymi literami i wykonaliśmy na nich te same operacje pośrednie, otrzymalibyśmy następujący wynik.

Wykonywanie operacji filtrowania i sortowania na małych wartościach Przykład

  
import java.util.Arrays;  
import java.util.List;  
public class Main {  
public static void main(String[] args) {  
//declare and initialize the array list  
List randomValues = Arrays.asList(  
'E11', 'D12', 'A13', 'F14', 'C15', 'A16',  
'B11', 'B12', 'c13', 'B14', 'B15', 'B16',  
'F12', 'E13', 'C11', 'C14', 'A15', 'c16',  
'F11', 'C12', 'D13', 'E14', 'D15', 'D16'  
);  
//retrieves only values that start with C, sort them, and print them to the console.  
randomValues.stream().filter(value->value.startsWith('C')).sorted().forEach(System.out::println);  
}  
}

Powyższy kod wygeneruje w konsoli następujące wartości:

Jedynym problemem z powyższymi danymi wyjściowymi jest to, że nie odzwierciedlają one dokładnie wszystkich C wartości z naszej listy tablic. Dobrym sposobem na naprawienie tego małego błędu jest wprowadzenie kolejnej operacji pośredniej do potoku strumienia; ta operacja jest znana jako mapa() funkcjonować.

Korzystanie z przykładu funkcji mapy

  
import java.util.Arrays;  
import java.util.List;  
public class Main {  
public static void main(String[] args) {  
//declare and initialize the array list  
List randomValues = Arrays.asList(  
'E11', 'D12', 'A13', 'F14', 'C15', 'A16',  
'B11', 'B12', 'c13', 'B14', 'B15', 'B16',  
'F12', 'E13', 'C11', 'C14', 'A15', 'c16',  
'F11', 'C12', 'D13', 'E14', 'D15', 'D16'  
);  
//transforms all lower case characters to upper case,  
//retrieves only values that start with C, sort them, and print them to the console.  
randomValues.stream().map(String::toUpperCase).filter(value->value.startsWith('C')).sorted().forEach(System.out::println);  
}  
}

ten mapa() funkcja przekształca obiekt z jednego stanu do drugiego; w naszym przykładzie powyżej przekształca wszystkie małe litery na liście tablicy na wielkie litery.

Umieszczanie mapa() funkcja tuż przed filtr() funkcja pobiera wszystkie wartości zaczynające się od C z listy tablic.

Powyższy kod daje w konsoli następujący wynik, pomyślnie reprezentujący wszystkie C wartości na liście tablic.

Pozostałe trzy operacje pośrednie, których możesz użyć w swoich aplikacjach, to:

zerkać()
limit()
pominąć()

Strumienie Java 8 ułatwiają tworzenie wydajnego kodu

Dzięki strumieniom Java 8 możesz wyodrębnić bardzo konkretne, istotne dane z dużego źródła za pomocą jednego wiersza kodu. O ile podasz inicjał strumień() funkcji i operatora terminala, możesz użyć dowolnej kombinacji operacji pośrednich, które zapewnią dopasowanie wyników do celu.

jak długo testować obciążenie procesora?

Jeśli zastanawiasz się nad wierszem kodu zawartym w naszym filtr() funkcjonować; jest znany jako „wyrażenie lambda”. Wyrażenia lambda to kolejna funkcja wprowadzona w Javie 8, która zawiera wiele przydatnych funkcji.

Udział Udział Ćwierkać E-mail Szybkie wprowadzenie do lambd Java 8

Jeśli jesteś programistą Java i chcesz dowiedzieć się więcej o lambdach Java 8, w tym artykule przyjrzymy się bliżej składni i użyciu lambda.

Czytaj dalej Powiązane tematy

Programowanie
Jawa
Poradniki kodowania

O autorze Kadeisha Kean(21 opublikowanych artykułów)

Kadeisha Kean jest programistą zajmującym się pełnymi stosami oprogramowania i pisarzem technicznym/technologicznym. Ma wyraźną umiejętność upraszczania niektórych z najbardziej złożonych koncepcji technologicznych; produkcja materiału, który może być łatwo zrozumiały dla każdego nowicjusza w dziedzinie technologii. Pasjonuje się pisaniem, tworzeniem ciekawego oprogramowania i podróżowaniem po świecie (poprzez filmy dokumentalne).

Więcej od Kadeishy Kean

Zapisz się do naszego newslettera

Dołącz do naszego newslettera, aby otrzymywać porady techniczne, recenzje, bezpłatne e-booki i ekskluzywne oferty!

Kliknij tutaj, aby zasubskrybować