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ę zawierającą 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 jakimkolwiek 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 wykonywania 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 interferującą, 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 interferującą, 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