Metody pośrednie

asDoubleStream, asLongStream, boxed, filter, flatMap, map, mapToDouble, mapToLong,
mapToObject, parallel, peek, sequential

Metody pośrednie stanowe

distinct, skip, sorted

Metody pośrednie stanowe, krótkospięciowe

limit

Metody kończące

average, collect, count, forEach, forEachOrdered, iterator, max, min, reduce, spliterator, sum,
summaryStatistics, toArray

Metody kończące krótkospięciowe

allMatch, anyMatch, findAny, findFirst, noneMatch

Metody statyczne

builder, concat, empty, generate, iterate, of, range, rangeClosed

Przykłady

allMatch

boolean allMatch(IntPredicate predicate)

Metoda sprawdza, czy wszystkie elementy strumienia spełniają dany predykat. Warunek logiczny jest sprawdzany dla tak wielu elementów dla ilu jest to niezbędne aby uzyskać wynik, co oznacza, że nie musi być sprawdzany dla wszystkich elementów. Jeśli dostarczony strumień jeest pusty metoda zwraca true, a warunek nie jest – oczywiście – sprawdzany.

Predykat powinien być nie interferujący i bezstanowy. Metoda zwraca true jeśli wszystkie elementy strumienia spełniają dany warunek:

Listing (streams3.AllMatchElem.java):
//Stara metoda
int a = 25;
Arrays.sort(dlugoscF);
System.out.println(IMath.allMatch(dlugoscF, a));

//Nowa metoda
int b = 25;
System.out.println(IntStream.of(dlugoscF).sorted()
.allMatch(value -> value >= b));

W obu przypadkach sortowanie moze przyśpieszyć znalezienie elementu.

anyMatch

boolean anyMatch(IntPredicate predicate)

Metoda sprawdza czy jakikolwiek element strumienia spełnia predykat. Warunek logiczny jest sprawdzany tak długo jak potrzeba, aby uzyskać wynik, co oznacza, że w pewnych przypadkach nie wszystkie elementy będą sprawdzane. Jeśli strumień jest pusty metoda zwraca false. Jeśli jakikolwiek element strumienia spełnia postawiony warunek – metoda zwraca true, w pozostałych przypadkach false.

Listing (streams3.AnyMatchElem.java):
//Sprawdzamy, czy istnieje jakikolwiek element mniejszy od 30		
//Stara metoda
int a = 30;
Arrays.sort(dlugoscF);
System.out.println(IMath.isAnySmallerThan(dlugoscF, a));
//Nowa metoda
int b = 30;
System.out.println(IntStream.of(dlugoscF).sorted().
   anyMatch(value -> value < b));

asDoubleStream

DoubleStream asDoubleStream()

Przekształca strumień elementów typu int w strumień elementów typu double i zwraca ten strumień:

Listing (streams3.AsDoubleStreaElem.java):
//zmieniamy tablice intów na tablicę doubli
//stara metoda
double[] ds = new double[dlugoscF.length];
for(int i = 0; i < dlugoscF.length; i++){
ds[i] = dlugoscF[i];
}
//nowa metoda
IntStream.of(dlugoscF).asDoubleStream()
	.forEach(val -> System.out.print(val + " "));

asLongStream

LongStream asLongStream()

Działa dokładnie identycznie jak metoda asDoubleStream.

average

OptionalDouble average()

Zwraca obiekt typu OptionalDouble, który opisuje średnią arytmetyczną elementów strumienia. Jeśli strumień elementów jest pusty OptionalDouble również jest pusty. Obliczanie średniej jest jedym z przypadków redukcji.

Listing (/streams3.averageElem.java):
//Średnia elementów
int[] tabl = {13, 11, 10, 2, 19, 6};
//stara metoda
double sum=0;
for(int a : tabl){
	sum+=a;
}
System.out.println(sum/tabl.length);		
//nowa metoda
System.out.println(IntStream.of(tabl).average().getAsDouble());

boxed

Stream<Integer> boxed()

Każdy element strumienia intów jest opakowywany w typ otoczkowy Integer. Zwracany jest nowy strumień zawierający elementy typu Integer.

Listing (streams3.BoxedElem.java):
//Otoczkowanie elementów typu int
int[] tabl = {13, 11, 10, 2, 19, 6};
//stara metoda
Integer[] tabl1 = new Integer[tabl.length];
for(int i = 0; i < tabl.length; i++){
	tabl1[i] = new Integer(tabl[i]);
	System.out.print(tabl1[i] + " ");
}
System.out.println();
//nowa metoda
IntStream.of(tabl).boxed().forEach(value -> 
   System.out.print(value + " "));

builder

static IntStream.Builder builder()

Zwraca budowniczego tworzacego IntStream. Budowniczy ma cykl życiowy składający się z fazy budowania, podczas której można dodawać elementy. Po wywołaniu metody build() strumień jest zbudowany. Elementów nie można już dodawać. Tworzony jest strumień dodanych elementów, które ułożone są w porządku, w jakim zostały dodane.

Listing (streams3.IntStreamBuilder.java):
IntStream.Builder b = IntStream.builder();
b.add(1);
//dodawanie elementów
IntStream stream = b.build();
stream.forEach(value -> System.out.print(value + " "));

collect

<R> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner)

Metoda przeprowadza redukcję mutatywną na elementach strumienia. Zredukowaną wartością jest kontener mutowalnych wyników, np. ArrayList. Elementy są włączane przez aktualizację stanów wyniku, a nie przez zastąpienie wyniku. Operacje collect mogą być paralelizowane bez konieczności dodatkowej synchronizacji.

Listing (streams3.CollectElem.java):
//Chcemy poznać wyniki unikalne, czyli wyniki pomiarów po usunięciu 
//wyników powtarzających się. Wyniki chcemy uzyskać w postaci ArrayListy.
//Stara metoda
Set<Integer> si = new TreeSet<>();
int i;
for(i = 0; i < dlugoscF.length; i++){
	si.add(dlugoscF[i]);
}
Integer[] array = new Integer[si.size()];
si.toArray(array);
ArrayList<Integer> al = new ArrayList<>();
al.addAll(si);
for(Integer a : si){
	System.out.print(a + ", ");
}
System.out.println();
//Nowa metoda
ArrayList<Integer> arr = 
   IntStream.of(dlugoscF).distinct().sorted()
.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
Stream.of(arr).forEach(value -> System.out.print(value));

Metoda of tworzy strumień.Metoda distinct wybiera niepowtarzające się wyniki. Metoda collect tworzy nową kolekcję zawierajcą wyłącznie niepowtarzające się wyniki.

ArrayList::new oznacza, że supplier dostarcza nowej kolekcji. arrayList::add oznacza, że akumulator używa metody add do dodawania wyników do nowej kolekcji. ArrayList::addAll oznacza, że jeśli np. tworzenie przebiega w trybie równoległym i otrzymujemy kilka cząstkowych kolekcji to kolekcje te są łączone (kombinowane) przy użyciu metody addAll.

concat

static IntStream concat(IntStream a, IntStream b)

Tworzy leniwie z dwóch strumieni jeden złączony strumień zawierający wszystkie elementy pierwszego strumienia, po których następują wszystkie elementy drugiego strumienia. Strumień wynikowy jest uporządkowany jeśli oba strumienie wejściowe są uporządkowane i równoległy jeśli którykolwiek z dwóch strumieni wejściowych jest równoległy.

Dokumentacja zaleca ostrożność w przypadku powtarzania operacji concat, gdyż może to się skończyć nawet przepełnienie stosu.

Listing (streams3.ConcatStreams.java):
//Połączenie tablic
int[] tabl1 = {13, 11, 10, 2, 19, 6};
int[] tabl2 = {7, 5, 8, 3, 9};
//stara metoda
int len1 = tabl1.length;
int len2 = tabl2.length;
int len3 = len1 + len2;
int[] tabl3 = new int[len3];
for(int i = 0; i < len3; i++){
	if(i < len1){
		tabl3[i] = tabl1[i];
	}
	else{
		tabl3[i] = tabl2[i - len1];
	}
}
for(int i = 0; i < len3; i++){
	System.out.print(tabl3[i] + " ");
}
System.out.println();
//nowa metoda
IntStream a = IntStream.of(tabl1);
IntStream b = IntStream.of(tabl2);
IntStream.concat(a, b).forEach(value -> 
   System.out.print(value + " "));

count

long count()

Zwraca liczbę elementów w strumieniu. Jest to jeden z przypadków redukcji.

Listing (streams3.CountElem.java):
//zliczenie elementów
int[] tabl = {13, 11, 10, 2, 19, 6};		
//stara metoda
System.out.println(tabl.length);
//nowa metoda
System.out.println(IntStream.of(tabl).count());

distinct

IntStream distinct()

Zwraca nowy strumień zawierający jedynie nie powtarzające się elementy.

Listing (streams3.DictinctElem.java):
//Chcemy poznać wyniki unikalne, czyli wyniki pomiarów po usunięciu 
//wyników powtarzających się

//Stara metoda
Set<Integer> si = new TreeSet<>();
for(int i = 0; i < dlugoscF.length; i++){
	si.add(dlugoscF[i]);
}
for(Integer k : si){
	System.out.print(k + " ");
}
System.out.println();
//Nowa metoda
IntStream.of(dlugoscF).distinct().sorted()
	.forEach(value -> System.out.print(value + " "));

Metoda distinct() zwraca strumień elementów nie powtarzających się. Metoda sorted() sortuje strumień o wartości najmniejszej do największej.

empty

static IntStream empty()

Zwraca pusty, sekwencyjnie zorientowany, IntStream.

Listing (streams3.EmptyStream.java):
//Tworzymy pusty strumień
//stara metoda
int[] tabl = new int[0];
for(int i = 0; i < tabl.length; i++){
	System.out.print("empty " + tabl[i]);
}
//nowa metoda
IntStream s = IntStream.empty();
s.forEach(value -> System.out.print("empty " + value));

W obu przypadkach ‘empty’ nie zostanie wydrukowane na konsoli ponieważ w ani a tablicy ani w strumieniu nie ma ani jednego elementu.

filter

IntStream filter(IntPredicate predicate)

Sprawdza czy elementy strumienia spełniają predykat. Zwraca strumień elementów, które warunek logiczny spełniają. Strumień wyjściowy może być pusty. Predykat musi być nie interferujący i bezstanowy.

Listing (streams3.FilterElem.java)
//tablica losowo wybranych intów
//Z tablicy liczb wybrać tylko liczby pierwsze i  
//wydrukować na konsoli
//Stara metoda
ArrayList<Integer> al = new ArrayList<>();
for(i = 0; i < tabl.length; i++){
	int a = tabl[i];
	if(IMath.isPrime(a)){
		al.add(a);
	}
}
int[] tabl1 = new int[al.size()];
for(i = 0; i < tabl1.length; i++){
	tabl1[i] = al.get(i);
	System.out.print(tabl1[i] + " ");
}
System.out.println();
//Nowa metoda
IntStream.of(tabl).filter(value -> 
   IMath.isPrime(value) == true)
	.forEach(value -> System.out.print(value + " "));

findAny

OptionalInt findAny()

Zwraca OptionalInt opisujący któryś z elementów strumienia. Jeśli strumień jest pusty również OptionalInt jest pusty.

Ta operacja zachowuje się nie deterministycznie, gdyż może wybrać dowolny element strumienia, co pozwala na maksymalną wydajność w operacjach równoległych. Jeśli z jakichś
powodów niezbędny jest powtarzalny wynik należy użyć metody findFirst().

Listing (streams3.FindAnyElem.java):
//Znaleźć jakikolwiek element strumienia
int[] tabl = {13, 11, 10, 2, 19, 6};
//Stara metoda
System.out.println(tabl[IMath.randomInRange(0, tabl.length - 1)]);
//Nowa metoda
System.out.println(IntStream.of(tabl).findAny().getAsInt());

Metoda findAny() znajduje pewien element strumienia. Metoda getAsInt() wskazuje, że element powinien być potraktowany jako int.

Otrzymane wyniki mogą być inne za każdym razem:

11
13

findFirst

OptionalInt findFirst()

Metoda zwraca OptionalInt opisujący pierwszy element strumienia. Jeżeli strumień jest pusty również OptionalInt jest pusty. Jeśli strumień nie jest uporządkowany, to może być zwrócony dowolny element.

Listing (streams3.FindFirstElem.java)
//Znaleźć pierwszy element strumienia
int[] tabl = {13, 11, 10, 2, 19, 6};
//Stara metoda
System.out.println(tabl[0]);
//Nowa metoda
System.out.println(IntStream.of(tabl).findFirst().getAsInt());

flatMap

IntStream flatMap(IntFunction<? extends IntStream> mapper)

Zwraca strumień elementów zawierający wyniki zastąpienia każdego elementu strumienia przez zawartośc mapowanego strumienia wytwarzanego przez zastosowanie dostarczonej funkcji mapującej do każdego elementu. Każdy strumień mapujący jest zamknięty. Jeśli mapowany strumień jest null zamiast niego użyty jest pusty strumień. Mapper musi być funkcją nie interferującą i bezstanową.

forEach

void forEach(IntConsumer action)

Wykonuje wskazaną akcję dla każdego elementu strumienia.. W przypadku orientacji równoległej strumienia ta operacja nie gwarantuje zachowania kolejności wykonania. Dla danego elementu akcja może być wykonana w jakimkolweik czasie w jakimkolwiek wątku.
Akcja powinna być nie interferująca.

Listing (streams3.ForEachElem.java):
//operacja wyszczególnienia elementów
int[] tabl = {13, 11, 10, 2, 19, 6};
//stara metoda
for(int a : tabl){
	System.out.print(a + " ");
}
System.out.println();
//nowa metoda
IntStream.of(tabl).forEach(val -> 
   System.out.print(val + " "));

forEachOrdered

void forEachOrdered(IntConsumer action)

Wykonuje wskazaną akcję na wszystkich elementach strumienia, ale zapewnia zachowania kolejności wykonywanaia jeśli strumień ma zdefiniowaną taką kolejność. Akcja powinna być nie interferująca.

Listing (streams3.ForEachOrderedElem.java):
//operacja wyszczególnienia elementów
int[] tabl = {13, 11, 10, 2, 19, 6};
//stara metoda
for(int a : tabl){
	System.out.print(a + " ");
}
System.out.println();
//nowa metoda
IntStream.of(tabl).forEachOrdered(val -> System.out.print(val + " "));

generate

static IntStream generate(IntSupplier s)

Zwraca nieskończony sekwencyjny, nieuporządkowany strumień, w którym każdy element jest generowany przez dostarczony IntSupplier. Najczęściej jest używany do generowania stałych strumieni, strumieni losowych elementów, etc.

Listing(streams3.GenerateStreamElem.java)
//Generujemy nieskończony strumień elementów od 0, 100
IntStream str = IntStream.generate(() -> IMath.randomInRange(0, 100));
str.forEach(value -> System.out.println(value));

iterate

static IntStream iterate(int seed, IntUnaryOperator f)

Zwraca nieskończony, sekwencyjny, nieuporządkowany IntStream, wytworzony przez iteracyjne zastosowanie funkcji f do początkowego elementu ziarna, wytwarzając strumień składający się z kolejno z seed, f(seed), f(f(seed)), etc.

iterator

PrimitiveIteratr.OfInt iterator()

Zwraca iterator dla elementów strumienia.

Listing (streams3.IteratorElem.java):
//Tworzymy strumien unikalnych i posortowanych wartosci		
IntStream str = IntStream.of(dlugoscF).distinct().sorted();
PrimitiveIterator.OfInt piter = str.iterator();
while(piter.hasNext()){
	System.out.print(piter.next() + " ");
}

Jak widać używa się go podobnie jak normalnego iteratora kolekcyjnego.

limit

IntStream limit(long maxSize)

Zwraca strumień zawierający elementy strumienia źródłowego obciętego tak aby zawierał nie więcej niż maxSize elementów.

Ponieważ w strumieniu zwracanym musi się znaleźć maxSize pierwszych (kolejnych) elementów strumienia więc operacja jest kosztowna, gdy wchodzi w grę strumień ukierunkowany równolegle. Jeżeli kolejność elementów nie jest istotna, dla podniesienia efektywności, należy użyć BaseStream.unordered() albo użyć strumienia generowanego przez generate(). Jeżeli kolejność jest istotna, a efektywnoć przy strumieniu ukierunkowanym równolegle jest słaba, należy przełączyć strumień w tryb sekwencyjny, np. używając metody sequential(), co powinno poprawić efektywność.

maxSize nie może być liczbą ujemną.

Listing (streams3.LimitElem.java)
//Ograniczamy liczbę elementów strumienia do pierwszych 20 elementów		
//Nowa metoda
int b = 20;
IntStream.of(dlugoscF).limit(b)
	.forEach(value -> System.out.print(value + " "));

Oczywiście starą metodą byłoby stworzenie nowej 20-elementowej tablicy i przepisanie pierwszych 20 elementów.

map

IntStream map(IntUnaryOperator mapper)

Zwraca strumień zawierający elementy będące wynikiem zastosowania funkcji mapujacej do poszczególnych elemntów strumienia. mapper musi być fukcją nie interferującą i bezstanową.

Listing (streams3.MapElem1.java):
//Każdy element mnożymy przez 3
//Stara metoda
for(i = 0; i < tabl.length; i++){
tabl[i] = tabl[i] * 3;
	System.out.print(tabl[i] + " ");
}
System.out.println();
//Nowa metoda
IntStream.of(tabl2).map(value -> value * 3)
		.forEach(value -> System.out.print(value + " "));

Możemy też zastosować metodę statyczną:

Listing (streams3.MapElem2.java):
//Na każdym elemencie wykonujemy fukcję numsum przekształcając daną 
//liczbę w liczbę numerologiczną czyli sumujemy wszystkie cyfry tak 
//dlugo az ostatnia liczba będzie mniejsza od 10
//Stara metoda
for(i = 0; i < tabl.length; i++){
	tabl[i] = IMath.numsum(tabl[i]);
	System.out.print(tabl[i] + " ");
}
System.out.println();
//Nowa metoda
IntStream.of(tabl2).map(value -> IMath.numsum(value))
	.forEach(value -> System.out.print(value + " "));

mapToDouble

DoubleStream mapToDouble(IntToDoubleFunction mapper)

Akceptuje elementy int. Zwraca DoubleStream zawierajcy elementy double powstałe przez zastosowanie mappera do elementów strumienia źródłowego. Mapper jest funkcją nie interferujcą, bezstanową.

Listing (streams3.MapToDoubleElem.java):
//Każdy element mnożymy przez 3.1
//Stara metoda
for(i = 0; i < tabl.length; i++){
	tabl2[i] = tabl[i] * 3.1;
	System.out.print(tabl[i] + " ");
}
System.out.println();
//Nowa metoda
IntStream.of(tabl).mapToDouble(value -> value * 3)
	.forEach(value -> System.out.print(value + " "));

mapToLong

LongStream mapToLong(IntToLongFunction mapper)

Akceptuje elementy typu int. Zwraca LongStream zawierający elementy long powstałe przez zastosowanie mappera do elementów strumienia źródłowego. Mapper jest funkcją nie interferujcą, bezstanową.

Listing (streams3.MapToLongElem.java):
//Każdy element mnożymy przez liczbę L
//Stara metoda
for(i = 0; i < tabl.length; i++){
	tabl2[i] = tabl[i] * 100000000000000L;
	System.out.print(tabl[i] + " ");
}
System.out.println();
//Nowa metoda
IntStream.of(tabl).mapToLong(value -> 
   value * 100000000000000L)
	.forEach(value -> System.out.print(value + " "));

mapToObj

<U> Stream<U> mapToObj(IntFunction<? extends U> mapper)

Zwraca Stream obiektów, powstałych w wyniku zastosowania podanej funkcji do elementów strumienia źródłowego. Mapper jest funkcją nie interferujcą, bezstanową.

Listing(streams3.mapToObjElem.java)
//Każdy element przekształcamy w string
//Stara metoda
for(i = 0; i < tabl.length; i++){
	tabl2[i] = String.valueOf(tabl[i]);
	System.out.print(tabl[i] + " ");
}
System.out.println();
//Nowa metoda
IntStream.of(tabl).mapToObj(value -> String.valueOf(value))
	.forEach(value -> System.out.print(value + " "));

max

OptionalInt max()

Zwraca OptionalInt opisujący największy element strumienia> OptionalInt jest pusty jeśli strumień jest pusty.

Listing (streams3.MaxElem.java)
//stara metoda
int max=Integer.MIN_VALUE;
for(int a : tabl){
	max=Math.max(a, max);
}
System.out.println(max);		
	//stara metoda 2
Arrays.sort(tabl);
System.out.println(tabl[tabl.length-1]);
//nowa metoda
System.out.println(IntStream.of(tabl).max().getAsInt());

max() jest specjalnym przypadkiem redukcji. Dlatego możno to samo wykonać tak:

System.out.println(IntStream.of(tabl).reduce(Integer::max).getAsInt());

min

OptionalInt min()

Zwraca OptionalInt opisujący najmniejszy element strumienia> OptionalInt jest pusty jeśli strumień jest pusty.

Listing (streams3.MinElem.java)
//stara metoda
int min=Integer.MAX_VALUE;
for(int a : tabl){
	min=Math.min(a, min);
}
System.out.println(min);	
//stara metoda 2
Arrays.sort(tabl);
System.out.println(tabl[0]);
//nowa metoda
System.out.println(IntStream.of(tabl).min().getAsInt());

min() jest specjalnym przypadkiem redukcji. Dlatego można to wykonać tak:

System.out.println(IntStream.of(tabl).reduce(Integer::min).getAsInt());

noneMatch

boolean noneMatch(IntPredicate predicate)

Sprawdza czy prawdą jest, że żaden element strumienia nie spełnia podanego warunku. Może, jeśli to nie jest konieczne do uzyskania wyniku, nie sprawdzać warunku dla wszystkich elementów. Jeśli strumień jest pusty metoda zwraca true, a warunek nie jest – oczywiście sprawdzany. Predykat musi być nie interferujący o bezstanowy.

Listing (streams3.NoneMatchElem.java)
//Sprawdzamy, czy każdy element nie spełnia warunku, że a==24 (czyli 
//sprawdza się czy istnieje jakikolwiek, element który spełnia ten warunek;		
		//Stara metoda
		int a = 24;
		boolean c = true;
		for(int i = 0; i < dlugoscF.length; i++){
			if(dlugoscF[i] == a){
				c = false;
				break;
			}
		}
		System.out.println(c);
		//Nowa metoda
		int b = 24;
		System.out.println(IntStream.of(dlugoscF)
				.noneMatch(value -> value == b));

W obu przypadkach otrzymujemy true, co znaczy, że żaden element nie spełnia postawionego warunku.

of

static IntStream of(int... values)

Zwraca sekwencyjnie uporządkowany strumień intów złożony z intów podanych jako tablica lub pojedynczo wyszczególnionych . Przykłady użycia podane są w niemal każdym przykładzie.

of

static IntStream of(int t)

Zwraca strumień sekwencyjny zawierający jeden, podany element typu int.

Listing (streams3.OfElem.java)
int a = 24;
IntStream s = IntStream.of(a);
s.forEach(value -> System.out.println(value));

parallel

IntStream parallel()

Zwraca równoległy odpowiednik strumienia.

Listing (streams3.ParallelElem.java)
//Tworzymy równoległy strumień elementów
IntStream.of(dlugoscF).parallel()
	.forEach(value -> System.out.print(value + " "));

peek

IntStream peek(IntConsumer action)

Zwraca strumień składający się z elementów strumienia źródłowego, na których w miarę ich pobierania do strumienia wynikowego wykonywana jest dodatkowo akcja action. W strumienaich ukierunkowanych równolegle action może być wywołana w dowolnym czasie i w dowolnym wątku na dowolnym elemencie. Akcja, jeśli zmienia jakiś wspólny stan, musi zapewnić odpowiednią synchronizację.Akcja powinna być nie interferująca.

Metody peek używa się głównie przy debugowaniu kodu:

Listing (streams3.PeekElem.java)
//bez debugowania
System.out.println(IntStream.of(dlugoscF).filter(v -> v > 49)
		.map(v -> v * 2).sum());
System.out.println();

Otrzymujemy tylko wynik końcowy:

812
//z debugowaniem
System.out.println(IntStream.of(dlugoscF).filter(v -> v > 49)
	.peek(v -> System.out.print(v + " ")).map(v -> v * 2)
	.peek(v -> System.out.println("v: " + v)).sum());

Wyrzucamy prefiltrowane elementy oraz wyniki mapowania, a następnie wynik końcowy:

51 v: 102 50 v: 100 52 v: 104 52 v: 104 50 v: 100 50 v: 100 51 v: 102 50 v: 100
812

range

static IntStream range(int startInclusive, int endExclusive)

Zwraca sekwencyjny strumień intów zaczynających się od startInclusive do endExclusive – 1) z krokiem 1.

Listing (streams3.RangeElem.java)
//Dostarczyć tablicę zawierającą kolejne liczby od 1 do 39  
//i wyświetllić je na konsoli
//Stara metoda
int[] tabl = IMath.rangeArray(1, 39);
for(int i = 0; i < tabl.length; i++){
	System.out.print(tabl[i] + " ");
}
System.out.println();
//Nowa metoda		
IntStream.range(1, 40).forEach(value -> System.out.print(value + " "));
1 2 . . . 38 39 
1 2 . . . 38 39

rangeClosed

static IntStream rangeClosed(int startInclusive, int endExclusive)

Zwraca sekwencyjny strumień intów zaczynających się od startInclusive do endExclusive – 1) z krokiem 1.

Listing (streams3.RangeClosedElem.java)
//Stara metoda jak w poprzednim przykładzie
//Nowa metoda
IntStream.rangeClosed(1, 39).forEach(value -> System.out.print(value + " "));
1 2 . . . 38 39 
1 2 . . . 38 39

reduce

OptionalInt reduce(IntBinaryOperator op)

Wykonuje operację redukcji na elementach strumieniach, sprowadzajc je do jednego elementu OptionalInt, który może być pusty. Operator op musi być funkcją asocjacyjną, nie interferującą, bezstanową.

Listing(streams3.Reduce1.java)
//Sumowanie elementów
System.out.println(IntStream.of(tabl).reduce((x, y) -> x + y)
	.getAsInt());
//albo
System.out.println(IntStream.of(tabl).reduce(Integer::sum).getAsInt());

reduce

int reduce(int identity, IntBinaryOperator op)

Wykonuje redukcję elementów strumienia, używając dosatrczonej identycznośc i assocjacyjnej funkcji akumulującej. W wyniku otrzymujemy zredukowaną wartość.

op musi być funkcją asocjacyjną, nie interferującą, bezstanową. Wartość identity musi być identycznością dla funkcji op. Dla mnożenia jest to 1, dla dodawania 0, etc.

Specjalnymi przypadkami rekucji są funkcje statystyczne: sum, min, max, count, average.

Listing (streams3.Reduce2)
//sumowanie elementów		
System.out.println(IntStream.of(tabl).reduce(0, (x, y) -> x + y));
//albo
System.out.println(IntStream.of(tabl).reduce(0, Integer::sum));
//mnożenie elementów		
System.out.println(IntStream.of(tabl).reduce(1, (x, y) -> x * y));
//wybranie elementu max		
System.out.println(IntStream.of(tabl).reduce(Integer.MIN_VALUE,
		(x, y) -> Math.max(x, y)));
//albo
System.out.println(IntStream.of(tabl).reduce(Integer.MIN_VALUE,
		Integer::max));
//wybranie elementu min
System.out.println(IntStream.of(tabl).reduce(Integer.MAX_VALUE,
		(x, y) -> Math.min(x, y)));
//albo
System.out.println(IntStream.of(tabl).reduce(Integer.MAX_VALUE,
		Integer::min));
//Suma kwadratów elementów
System.out.println(IntStream.of(tabl).reduce(0, (x, y) -> x + y * y));
//albo
System.out.println(IntStream.of(tabl).reduce(0,
		(x, y) -> x + (int)Math.pow(y, 2)));

sequential

IntStream sequential()

Zwraca odpowiadający strumień, który jest sekwencyjny. Strumień zwracany może być tym samym strumieniem, jeśli już przed zastosowaniem metody był sekwencyjny.

Listing (streams3.SequentialElem.java)
IntStream.of(dlugoscF).sequential()
	.forEach(value -> System.out.print(value + " "));
	

Ponieważ strumień tworzymy bezpośrednio z tablicy, niezależnie czy użylibyśmy sequential() czy nie to i tak opisany strumień byłby sekwencyjny.

skip

IntStream skip(long n)

Zwraca strumień intów, który poostał ze strumienia po usunięciu n pierwszych elementów. Zwrócony strumień może być pusty jeśli n jest równe lub większe od ilości elementów w strumieniu. n musi być dodatnie. Jeśli kolejność elementów (czyli to co usuwamy) nie jest istotna operację powinno się przeprowadzać na nieuporządkowanym, sekwencyjnym strumieniu. W innym przypadku można się spodziewać utraty efektywności.

Listing (streams3.SkipElem.java)
//Tworzymy sekwencyjny strumień elementów pomiajac pierwsze 130
//elementów
IntStream s = IntStream.of(dlugoscF).skip(130);
s.forEach(value -> System.out.print(value + " "));

sorted

IntStream sorted()

Zwraca strumień intów posortowany rosnąco.

Listing (streams3.SortedElem.java):
//Nowa metoda
IntStream.of(tabl).filter(value -> IMath.isPrime(value) == true)
	.sorted().forEach(value -> System.out.print(value + " "));

spliterator

Spliterator.OfInt spliterator()

Zwraca spliterator dla elemntów w strumieniu.

sum

int sum()

Zwraca sumę elementów w strumieniu. Jest to specjalny przypadek operacji redukcji.

Listing (streams3.SumElem.java):
//zsumowanie elementów
int[] tabl = {13, 11, 10, 2, 19, 6};		
//stara metoda
int sum = 0;
for(int b : tabl){
	sum += b;
}
System.out.println(sum);
//nowa metoda
System.out.println(IntStream.of(tabl).sum());

summaryStatistics

IntSummaryStatistics summaryStatistics()

Zawraca IntSummaryStattisstics opisujący zsumowane informacje na temat elementów w
strumieniu. Jest to specjalny przypadek operacji redukcji.

Listing(streams3.IntSummaryStat.java)
//statystyka
//stara metoda
int sum1 = 0;
int min1 = Integer.MAX_VALUE;
int max1 = Integer.MIN_VALUE;
for(int a : dlugoscF){
	sum1 += a;
	min1 = Math.min(min1, a);
	max1 = Math.max(max1, a);
}
int count1 = dlugoscF.length;
double average1 = sum1 / (double)count1;
System.out.println(count1 + " " + sum1 + " " + max1 + " " + min1 + " "
	+ average1);
//nowa metoda
System.out.println(IntStream.of(dlugoscF).summaryStatistics());

Otrzymujemy:

150 6069 52 25 40.46
IntSummaryStatistics{count=150, sum=6069, min=25, average=40,460000, max=52}

toArray

int[] toArray()

Zwraca tablicę zawierającą elementy strumienia.

Listing(streams3.toArrayElem.java)
//Tworzymy strumien unikalnych i posortowanych wartosci, a
//nastepnie przeksztalcamy go w tablice intow
IntStream str =IntStream.of(dlugoscF).distinct().sorted();
int[] arr = str.toArray();

Pliki do ściągnięcia

streams3.zip (klasy)

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *