Skip to content

A
alx_mszczonow_1
Commit b2089700 by Patryk Czarnik
Options

Gotowe przykłady streamów

parent 240b65a1
Showing with 2075 additions and 1 deletions
src/main/java/emps/ObslugaCSV.java
......@@ -5,7 +5,7 @@ import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
class ObslugaCSV {
public class ObslugaCSV {
public static List<Employee> wczytaj() {
return wczytaj("pliki/emps.csv");
......
src/main/java/pcz/p31_streamy/a_poczatek/A_TypowyPrzyklad.java 0 → 100644
package pcz.p31_streamy.a_poczatek;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class A_TypowyPrzyklad {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println(lista);
System.out.println();
lista.stream()
.filter(s -> s.contains("a"))
.map(s -> s.toUpperCase())
.forEach(s -> System.out.println(s));
// To odpowiada takiej pętli:
for(String s1 : lista) {
if(s1.contains("a")) {
String s2 = s1.toUpperCase();
System.out.println(s2);
}
}
}
}
src/main/java/pcz/p31_streamy/b_dzialanie/Strumienie1.java 0 → 100644
package pcz.p31_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class Strumienie1 {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
Stream<String> str1 = lista.stream();
System.out.println(str1);
// Strumień nie jest kolekcją, nie zawiera danych. Jest on tylko sposobem dostępu do danych.
str1.forEach(s -> System.out.print(s + ", "));
System.out.println();
System.out.println();
// Jednego strumienia nie można używać wielokrotnie
// forEach jest "operacją terminującą" i zamyka strumień
//EXN str1.forEach(s -> System.out.print(s + "; "));
// Jest też forEach bezpośrednio na liście (na każdym Iterable)
lista.forEach(s -> System.out.print(s + "; "));
System.out.println();
// Zobaczmy po kolei jakiego typu wyniki wychodzą:
Stream<String> str2a = Arrays.stream(tablica);
Stream<String> str2b = str2a.filter(s -> s.length() > 3);
Stream<String> str2c = str2b.map(s -> s.toUpperCase());
// Stream<Integer> str2d = str2c.map(s -> s.length());
// albo - w praktyce lepiej:
IntStream str2e = str2c.mapToInt(s -> s.length());
// Strumienie liczb oferują dodatkowe operacje.
int suma = str2e.sum();
System.out.println(suma);
System.out.println();
// Zazwyczaj nie tworzy się zmiennych pośrednich, tylko zapisuje jednym ciągiem ("pipeline"):
suma = Arrays.stream(tablica)
.filter(s -> s.length() > 3)
.map(s -> s.toUpperCase())
.mapToInt(s -> s.length())
.sum();
System.out.println(suma);
}
}
src/main/java/pcz/p31_streamy/b_dzialanie/Strumienie2_JakToDziala.java 0 → 100644
package pcz.p31_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
// Operacje wypisują co robią na ekran, abyśmy mogli sprawdzić kolejność ich wykonania.
public class Strumienie2_JakToDziala {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
// Chociaż wskazuję operacje sprawdź i mapuj w momencie definiowania strumienia
// to one jeszcze się nie wykonują.
Stream<String> strumien = lista.stream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s));
System.out.println("Strumień utworzony: " + strumien);
lista.add("Dodatkowy");
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/main/java/pcz/p31_streamy/b_dzialanie/Strumienie2a.java 0 → 100644
package pcz.p31_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2a {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.stream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s))
.limit(5);
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/main/java/pcz/p31_streamy/b_dzialanie/Strumienie2b.java 0 → 100644
package pcz.p31_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2b {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.stream()
.limit(5)
.filter(s -> sprawdz(s))
.map(s -> mapuj(s));
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/main/java/pcz/p31_streamy/b_dzialanie/Strumienie2c.java 0 → 100644
package pcz.p31_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2c {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.parallelStream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s));
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
// forEach nie ma obowiązku zachowania kolejności i w przypadku parallelStream nie zachowuje
System.out.println("KONIEC");
}
}
src/main/java/pcz/p31_streamy/b_dzialanie/Strumienie2d.java 0 → 100644
package pcz.p31_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2d {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.parallelStream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s));
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
// forEachOrdered gwarantuje wykonanie operacji (tylko tej ostatniej) w takiej kolejności, w jakiej elementy są umieszczone w strumieniu
strumien.forEachOrdered(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/main/java/pcz/p31_streamy/b_dzialanie/Strumienie2e.java 0 → 100644
package pcz.p31_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2e {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.parallelStream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s))
.limit(5);
// tutaj wciąż te same 5 elementów jest wyświetlanych na końcu
// tak dzieje się dlatego, że strumień jest uporządkowany (ORDERED), bo pochodzi z listy
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/main/java/pcz/p31_streamy/b_dzialanie/Strumienie2f.java 0 → 100644
package pcz.p31_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2f {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.parallelStream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s))
.limit(5);
// tutaj wciąż te same 5 elementów jest wyświetlanych na końcu - a ich kolejność będzie zachowana
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEachOrdered(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/main/java/pcz/p31_streamy/b_dzialanie/Strumienie2g.java 0 → 100644
package pcz.p31_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2g {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.parallelStream()
.unordered()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s))
.limit(5);
// unordered - zapomnij o kolejności; to może zwiekszyć wydajność, ale wyniki tego przykładu
// (gdzie mamy limit) są niedetrministyczne
// teraz zmienia się zestaw elementów wyświetlanym na końcu forEachem
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
// strumien.forEach(s -> System.out.println(" * " + s));
strumien.forEachOrdered(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/main/java/pcz/p31_streamy/b_dzialanie/Strumienie3_Peek.java 0 → 100644
package pcz.p31_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie3_Peek {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.stream()
.peek(s -> System.out.println("\n F : " + s))
.filter(s -> s.length() > 3)
.peek(s -> System.out.println(" M : " + s))
.map(String::toUpperCase)
.peek(s -> System.out.println(" # : " + s));
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
System.out.println();
Stream<String> str2a = lista.stream();
Stream<String> str2b = str2a.peek(s -> System.out.println(" % " + s));
// peek nie wpływa na zawartość ani "widzianą z zewnątrz logikę" strumienia,
// ale powoduje, że w momencie ewaluacji strumienia na każdym elemencie będzie wykonan podana operacja
str2b.limit(5).forEach(s -> {});
}
}
src/main/java/pcz/p31_streamy/c_przeglad_operacji/C01_Generowanie.java 0 → 100644
package pcz.p31_streamy.c_przeglad_operacji;
import java.time.LocalTime;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
public class C01_Generowanie {
static int licznikStatyczny = 0;
public static void main(String[] args) {
Stream<String> str0 = Stream.empty();
str0.forEach(s -> System.out.print(s + ", "));
System.out.println();
Stream<String> str1 = Stream.of("Ala", "Ola", "Ela");
str1.forEach(s -> System.out.print(s + ", "));
System.out.println();
String[] tablica = {"Ala", "Ola", "Ula"};
Stream<String> str2 = Stream.of(tablica);
str2.forEach(s -> System.out.print(s + "; "));
System.out.println();
Stream.Builder<String> builder = Stream.builder();
Stream<String> str3 = builder.add("Ula").add("Ala").add("Ola").build();
str3.forEach(s -> System.out.print(s + ", "));
System.out.println();
System.out.println();
// Kolejny element strumienia generowany "bezkontekstowo" (bez żanego parametru)
Stream<LocalTime> czasy = Stream.generate(() -> LocalTime.now());
// to się zapętla:
// czasy.forEach(lt -> System.out.println(lt));
czasy.limit(20).forEach(lt -> System.out.println(lt));
//EXN przy probie kolejnego uzycia
// czasy.limit(30).forEach(lt -> System.out.println(lt));
System.out.println();
int licznikLokalny = 0;
// w wyrażeniu lambda nie wolno modyfikować zmiennych lokalnych ani używać zmieniających się zmiennych lokalnych
// int suma0 = IntStream.generate(() -> ++licznikLokalny).limit(10).sum();
int suma = IntStream.generate(() -> ++licznikStatyczny)
.filter(x -> x%2 == 1)
.limit(8)
.sum();
System.out.println(suma);
// Kolejny element generowany na podstawie poprzedniego
Stream<String> str4 = Stream.iterate("$", s -> s + "*");
// też nieskończony
str4.limit(10).forEach(System.out::println);
System.out.println();
// Przykład sensownych operacji na strumieniach nieskończonych:
IntStream parzyste = IntStream.iterate(0, x -> x+2);
IntStream nieparzyste = parzyste.map(x -> x+1);
int suma2 = nieparzyste.limit(9).sum();
System.out.println(suma2);
System.out.println();
IntStream.iterate(1, x -> x+2).limit(10).forEach(System.out::println);
System.out.println();
LongStream.iterate(1, x -> 2*x).limit(65).forEach(System.out::println);
System.out.println();
Stream<String> str11 = Stream.of("Ala", "Ola", "Ela");
Stream<String> str12 = Stream.of("Adam", "Ludwik", "Ksawery");
Stream<String> razem = Stream.concat(str11, str12);
razem.forEach(s -> System.out.print(s + ", "));
System.out.println();
}
}
src/main/java/pcz/p31_streamy/c_przeglad_operacji/C02_ZRoznychKlas.java 0 → 100644
package pcz.p31_streamy.c_przeglad_operacji;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.Collator;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.Stream;
public class C02_ZRoznychKlas {
public static void main(String[] args) {
Random random = new Random();
// nieskończony strumień losowych intów
random.ints();
random.ints().limit(100).forEach(System.out::println);
// przykład: utwórz tablicę 100 losowych int-ów:
int[] liczbyLosowe = random.ints().limit(100).toArray();
System.out.println(Arrays.toString(liczbyLosowe));
System.out.println();
//random.doubles();
int suma = random.ints(100, 0, 1000).sum();
System.out.println(suma);
System.out.println();
try {
// operacja "imperatywna":
// List<String> wczytaneLinie = Files.readAllLines(path);
// dostęp strumieniowy
// strumienie też można zamykać; ten należy zamykać
try(Stream<String> lines = Files.lines(Paths.get("pan-tadeusz.txt"))) {
lines.filter(s -> s.contains("Tadeusz"))
.sorted(Collator.getInstance())
.forEachOrdered(System.out::println);
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println();
Path dir = Paths.get("src");
try {
Files.list(dir)
.forEach(f -> System.out.println(f + " " + Files.isRegularFile(f)));
} catch (IOException e) {
e.printStackTrace();
}
}
}
src/main/java/pcz/p31_streamy/c_przeglad_operacji/C11_FilterMap.java 0 → 100644
package pcz.p31_streamy.c_przeglad_operacji;
import java.util.stream.Stream;
public class C11_FilterMap {
public static void main(String[] args) {
String[] imiona = {"Ala", "Ola", "Basia", "Kasia", "Ela", "Ula", "Agnieszka", "Magdalena", "Anna", "Hanna", "Joanna", "Ala", "Agata", "Genowefa", "Grażyna", "Karolina", "Julia", "Zuzanna"};
Stream.of(imiona)
.filter(s -> s.length() >= 5)
.forEach(System.out::println);
System.out.println();
Stream.of(imiona)
.map(String::toUpperCase)
.forEach(System.out::println);
System.out.println();
Stream.of(imiona)
.filter(s -> s.startsWith("A"))
.map(String::length) // Stream<String> -> Stream<Integer>
.forEach(System.out::println);
Stream.of(imiona)
.filter(s -> s.startsWith("A"))
.mapToInt(String::length) // Stream<String> -> IntStream
.forEach(System.out::println);
}
}
src/main/java/pcz/p31_streamy/c_przeglad_operacji/C12_FlatMap.java 0 → 100644
package pcz.p31_streamy.c_przeglad_operacji;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class C12_FlatMap {
static List<Integer> generuj(int ilosc) {
List<Integer> lista = new ArrayList<>();
for(int i = 1; i <= ilosc; i++) {
lista.add(i);
}
return lista;
}
static Stream<Integer> generujStrumien(int ilosc) {
List<Integer> lista = new ArrayList<>();
for(int i = 1; i <= ilosc; i++) {
lista.add(i);
}
return lista.stream();
}
static IntStream generujStrumienIntow(int ilosc) {
List<Integer> lista = new ArrayList<>();
for(int i = 1; i <= ilosc; i++) {
lista.add(i);
}
return lista.stream().mapToInt(Integer::intValue);
}
public static void main(String[] args) {
System.out.println(generuj(1));
System.out.println(generuj(3));
System.out.println(generuj(5));
System.out.println();
System.out.println("Elementy strumienia wejściowego:");
Stream.of(1, 3, 5)
.forEach(x -> System.out.print(x + " | "));
System.out.println();
System.out.println();
System.out.println("Zwykłe mapowanie:");
Stream.of(1, 3, 5)
.map(C12_FlatMap::generuj)
.forEach(x -> System.out.print(x + " | "));
System.out.println();
Stream.of(1, 3, 5)
.map(x -> C12_FlatMap.generuj(x).stream())
.forEach(x -> System.out.print(x + " | "));
System.out.println();
System.out.println();
System.out.println("Płaskie mapowanie:");
Stream.of(1, 3, 5)
.flatMap(x -> C12_FlatMap.generuj(x).stream())
.forEach(x -> System.out.print(x + " | "));
System.out.println();
System.out.println();
Stream.of(1, 3, 5)
.flatMap(C12_FlatMap::generujStrumien)
.forEach(x -> System.out.print(x + " | "));
System.out.println();
System.out.println();
int suma = Stream.of(1, 3, 5)
.flatMapToInt(C12_FlatMap::generujStrumienIntow)
.sum();
System.out.println(suma);
}
}
src/main/java/pcz/p31_streamy/c_przeglad_operacji/C13_RozneOperacje.java 0 → 100644
package pcz.p31_streamy.c_przeglad_operacji;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class C13_RozneOperacje {
public static void main(String[] args) {
String[] imiona = {"Ala", "Ola", "Basia", "Kasia", "Ela", "Ula", "Agnieszka", "Magdalena", "Anna", "Hanna", "Joanna", "Ala", "Agata", "Genowefa", "Grażyna", "Karolina", "Julia", "Zuzanna"};
// ** operacje terminujące ** //
// forEach - dla każdego elementu wykonaj akcję
Stream.of(imiona).forEach(s -> System.out.println(s));
// forEachOrdered - dla każdego elementu wykonaj akcję zachowując kolejność (istotne dla parallelStream)
Stream.of(imiona).forEachOrdered(s -> System.out.println(s));
System.out.println("\n--------------------------------\n");
// count() - liczba elementów strumienia (też wymaga pobrania elementów !)
long n = Stream.of(imiona).count();
System.out.println("count: " + n);
// toArray - tworzy nową tablicę i wstawia tam elementy
Object[] array1 = Stream.of(imiona)
.map(String::toLowerCase)
.toArray();
System.out.println(array1 + " , length="+array1.length);
System.out.println(Arrays.toString(array1));
System.out.println();
// inna wersja: podajemy funkcję tworzącą tablice; korzyść: dostajemy String[] a nie Object[]
String[] array2 = Stream.of(imiona)
.sorted()
.toArray(String[]::new);
System.out.println(array2 + " , length="+array2.length);
System.out.println(Arrays.toString(array2));
System.out.println("\n--------------------------------\n");
// reduce - redukcja w sposób właściwy dla klas niemutowalnych
Optional<String> wynik01 = Stream.of(imiona)
.reduce(String::concat);
System.out.println("wynik01: " + wynik01);
String wynik02 = Stream.of(imiona)
.reduce("", String::concat);
System.out.println("wynik02: " + wynik02);
String wynik03 = Stream.of(imiona)
.reduce("|", String::concat);
System.out.println("wynik03: " + wynik03);
String wynik04 = Stream.of(imiona)
.parallel()
.reduce("|", String::concat);
System.out.println("wynik04: " + wynik04);
// Takie użycie concat jest niewydaje i tego nie naśladujcie
// wersja, w której typ wyniku może być inny niż typ elementów
// tu przykład sumowania długości napisów
Integer wynik05 = Stream.of(imiona)
.reduce(0, (x, s) -> x+s.length(), (x,y)->x+y);
System.out.println("wynik05: " + wynik05);
System.out.println();
// collect - redukcja w sposób właściwy dla klas mutowalnych
StringBuilder wynik06 = Stream.of(imiona).collect(
StringBuilder::new, // supplier - tworzy początkową "pusta" wartość
StringBuilder::append, // accumulator - aktualizuje wartość na podstawie elementu strumienia
StringBuilder::append); // combiner - łączy częściowe wyniki (które mogą się pojawić gdy mamy parallelStream)
System.out.println("wynik06: " + wynik06);
List<String> lista = Stream.of(imiona)
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(lista);
System.out.println("\n--------------------------------\n");
// findFirst i findAny - wybór jednego elementu
// findAny zwraca "jakikolwiek" - ale to nie znaczy "losowy"
// po prostu implementacja zwróci ten, do którego ma najszybszy dostęp
Optional<String> wynik07 = Stream.of(imiona).findFirst();
Optional<String> wynik08 = Stream.of(imiona).findAny();
Optional<String> wynik09 = Stream.of(imiona).parallel().findAny(); // niedeterministyczne, czasami była Ala a czasami Ula
// jest szansa na zobaczenie innego imienia niż Ala :)
System.out.println("findFirst : " + wynik07);
System.out.println("findAny : " + wynik08);
System.out.println("findAny par: " + wynik09);
System.out.println();
// kwantyfikatory logiczne - zwracają true albo false
// działają w sposób leniwy - przestają pobierać kolejne elementy strumienia jeśli wynik jest rozstrzygnięty
boolean bool1 = Stream.of(imiona).allMatch(s -> s.endsWith("a"));
System.out.println("bool1 = " + bool1);
boolean bool2 = Stream.of(imiona).allMatch(s -> s.startsWith("K"));
System.out.println("bool2 = " + bool2);
boolean bool3 = Stream.of(imiona).anyMatch(s -> s.startsWith("K"));
System.out.println("bool3 = " + bool3);
boolean bool4 = Stream.of(imiona).noneMatch(s -> s.startsWith("K"));
System.out.println("bool4 = " + bool4);
}
}
src/main/java/pcz/p31_streamy/c_przeglad_operacji/C14_MinMax.java 0 → 100644
package pcz.p31_streamy.c_przeglad_operacji;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import emps.Employee;
import emps.ObslugaCSV;
public class C14_MinMax {
public static void main(String[] args) {
List<Employee> lista = ObslugaCSV.wczytaj();
Optional<Employee> min = lista.stream().min(Comparator.comparing(Employee::getSalary));
Optional<Employee> max = lista.stream().max(Comparator.comparing(Employee::getSalary));
System.out.println("min: " + min);
System.out.println("max: " + max);
System.out.println();
if(min.isPresent()) {
System.out.println("Znaleziono minimum:");
Employee emp = min.get();
System.out.println(emp.getFirstName() + " " + emp.getLastName() + " zarabia " + emp.getSalary());
} else {
System.out.println("nie ma minimum");
}
if(max.isPresent()) {
System.out.println("Znaleziono maximum:");
Employee emp = max.get();
System.out.println(emp.getFirstName() + " " + emp.getLastName() + " zarabia " + emp.getSalary());
} else {
System.out.println("nie ma maximum");
}
System.out.println();
String [] stanowiska = {"Programmer", "Shipping Clerk", "Brygadier"};
for (String stanowisko : stanowiska) {
String tekst = lista.stream()
.filter(emp -> Objects.equals(emp.getJobTitle(), stanowisko))
.max(Comparator.comparing(Employee::getSalary))
.map(emp -> emp.getFirstName() + " " + emp.getLastName() + " zarabia " + emp.getSalary())
.orElse("nie ma takiego gościa");
// powyższe map dotyczy Optional, a nie Stream
System.out.println("Najbogatszy " + stanowisko + ": " + tekst);
}
}
}
src/main/java/pcz/p31_streamy/c_przeglad_operacji/C21_DistinctSorted.java 0 → 100644
package pcz.p31_streamy.c_przeglad_operacji;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class C21_DistinctSorted {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa", "Ola",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
// distinct i sorted to są opearacje "stateful intermediate"
// one są wykonywane dopiero gdy na strumieniu jest odpalona operacja terminalna
// ale mogą wymagać zebrania większej ilości danych (nawet wszystkich) przed przepuszczeniem elementów do dalszych etapów przetwarzania
// Wynika z tego, że nie powinny być stosowane do strumieni nieskończonych.
String napis = lista.stream()
.distinct()
.map(String::toUpperCase)
.sorted()
.collect(Collectors.joining(", "));
System.out.println(napis);
}
}
src/main/java/pcz/p31_streamy/c_przeglad_operacji/C22_DistinctSorted.java 0 → 100644
package pcz.p31_streamy.c_przeglad_operacji;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class C22_DistinctSorted {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Ala", "Magdalena", "Ola", "Joanna", "Anna", "Teresa", "Ola",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
// distinct i sorted to są opearacje "stateful intermediate"
// one są wykonywane dopiero gdy na strumieniu jest odpalona operacja terminalna
// ale mogą wymagać zebrania większej ilości danych (nawet wszystkich) przed przepuszczeniem elementów do dalszych etapów przetwarzania
// Wynika z tego, że nie powinny być stosowane do strumieni nieskończonych.
String napis = lista.stream()
.map(String::toUpperCase)
.peek(s -> System.out.println("start " + s))
.distinct()
.peek(s -> System.out.println("za distinct " + s))
.sorted()
.peek(s -> System.out.println("za sorted " + s))
.collect(Collectors.joining(", "));
System.out.println();
System.out.println(napis);
}
}
src/main/java/pcz/p31_streamy/c_przeglad_operacji/C23_DistinctSorted.java 0 → 100644
package pcz.p31_streamy.c_przeglad_operacji;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class C23_DistinctSorted {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Ala", "Magdalena", "Ola", "Joanna", "Anna", "Teresa", "Ola",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
// distinct i sorted to są opearacje "stateful intermediate"
// one są wykonywane dopiero gdy na strumieniu jest odpalona operacja terminalna
// ale mogą wymagać zebrania większej ilości danych (nawet wszystkich) przed przepuszczeniem elementów do dalszych etapów przetwarzania
// Wynika z tego, że nie powinny być stosowane do strumieni nieskończonych.
String napis = lista.parallelStream()
.map(String::toUpperCase)
.peek(s -> System.out.println("start " + s))
.distinct()
.peek(s -> System.out.println("za distinct " + s))
.sorted()
.peek(s -> System.out.println("za sorted " + s))
.collect(Collectors.joining(", "));
System.out.println();
System.out.println(napis);
}
}
src/main/java/pcz/p31_streamy/c_przeglad_operacji/C31_TypyProste.java 0 → 100644
package pcz.p31_streamy.c_przeglad_operacji;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
public class C31_TypyProste {
public static void main(String[] args) {
DoubleStream losowe = DoubleStream.generate(Math::random);
losowe.limit(100).forEach(x -> System.out.print(x + ", "));
System.out.println();
Random random = new Random();
double sumaLosowych1 = random.doubles().limit(10).sum();
System.out.println(sumaLosowych1);
random.ints(10, 100, 200).forEach(x -> System.out.print(x + ", "));
System.out.println();
LongStream potegi = LongStream.iterate(1, x -> x*2);
potegi.limit(65).forEach(x -> System.out.println(x));
System.out.println();
IntStream.range(0, 10).forEach(x -> System.out.print(x + ", "));
System.out.println();
IntStream.rangeClosed(0, 10).forEach(x -> System.out.print(x + ", "));
IntStream str_int = IntStream.rangeClosed(0, 10);
// tłumaczenie między strumieniem intów a strumieniem Integerów:
Stream<Integer> str_Integer = str_int.boxed();
IntStream str_int2 = str_Integer.mapToInt(Integer::intValue);
// IntStream str_int3 = str_Integer.mapToInt(x -> x);
List<Integer> liczby = IntStream.range(0, 100)
.map(i -> i*i)
.boxed() // zmienia IntStream na Stream<Integer>
.collect(Collectors.toList());
System.out.println(liczby);
}
}
src/main/java/pcz/p31_streamy/d_redukcje_i_grupowanie/Collect_i_Reduce.java 0 → 100644
package pcz.p31_streamy.d_redukcje_i_grupowanie;
import java.util.stream.Stream;
/* collect i reduce to dwa schematy służące do agregacji danych strumienia,
* czyli "zbierania danych" tak, aby na podstawie całego zestawu danych uzyskać pojedynczy wynik.
*
* collect i Collectory - schemat agregacji wykorzystujący klasy mutowalne,
* jako krok operacji podaje się metodę typu void
*
* reduce - schemat agregacji wykorzystujący klasy niemutowalne lub wartości liczbowe
* jako krok operacji podaje się metodę zwracającą wynik
*/
public class Collect_i_Reduce {
public static void main(String[] args) {
String[] imiona = {"Ala", "Ola", "Ela"};
{
StringBuilder wynik = Stream.of(imiona).collect(
StringBuilder::new, // supplier - tworzy początkową "pustą" wartość
StringBuilder::append, // accumulator - aktualizuje wartość na podstawie elementu strumienia
StringBuilder::append); // combiner - łączy częściowe wyniki (które mogą się pojawić gdy mamy parallelStream)
System.out.println("1: " +wynik);
}
// w przypadku strumienia sekwencyjnego można to przetłumaczyć na taką pętlę:
{
StringBuilder wynik = new StringBuilder();
for (String s : imiona) {
wynik.append(s); // tylko wywołanie, wynik tej metody nie jest brany pod uwagę, może być void
}
System.out.println("2: " + wynik);
}
// #################
// Klasa, o którą się opieramy, musi być mutowalna, a operacja (w tym przypadku append)
// musi zmieniać obiekt, na którym jest wołana
// To nie zadziała:
{
String wynik = Stream.of(imiona).collect(
String::new,
String::concat, // concat nie zmienia Strina, na którym jest wołany - więc nie będzie efektu
String::concat);
System.out.println("3: " + wynik);
}
// Dla klas niemutowalnych (i typów prostych) właściwym schematem jest reduce:
{
String wynik = Stream.of(imiona).reduce(
"",
String::concat);
System.out.println("4: " + wynik);
}
// to tłumaczy się na taką pętlę:
{
String wynik = "";
for (String s : imiona) {
wynik = wynik.concat(s); // przypisanie / podmiana wyniku !!!
}
System.out.println("5: " + wynik);
}
// Gdyby "combiner" częściowych wyników różnił się od "accumulatora" pojedynczych wartości,
// podajemy go jako trzeci parametr
{
String wynik = Stream.of(imiona).reduce(
"",
String::concat,
String::concat);
System.out.println("6: " + wynik);
}
// Tu jest taka sytuacja, bo na wejściu mamy strumień Stringów,
// a wynikiem jest int
// pierwsza funkcja jest typu (int, String) -> int
// a druga jest typu (int, int) -> int
{
int wynik = Stream.of(imiona).reduce(
0,
(suma, str) -> suma + str.length(),
Math::addExact);
System.out.println("7: " + wynik);
}
// te ostatnie funkcje ("combiner") są używane tylko gdy parallelStream
}
}
src/main/java/pcz/p31_streamy/d_redukcje_i_grupowanie/CollectorLaczacyNapisy.java 0 → 100644
package pcz.p31_streamy.d_redukcje_i_grupowanie;
import java.util.Collections;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
/* Przykład własnej definicji Collectora.
* Tylko, aby pokazać, jak one działają.
* Collector o funkcjonalności łączenia napisów istnieje: Collectors.joining();
*/
public class CollectorLaczacyNapisy implements Collector<String, StringBuilder, String> {
@Override
public Supplier<StringBuilder> supplier() {
// nie tak: return new StringBullder();
return StringBuilder::new;
}
@Override
public BiConsumer<StringBuilder, String> accumulator() {
return StringBuilder::append; // append(String)
}
@Override
public BinaryOperator<StringBuilder> combiner() {
return StringBuilder::append; // append(StringBuilder)
}
@Override
public Function<StringBuilder, String> finisher() {
return StringBuilder::toString;
}
@Override
public Set<Characteristics> characteristics() {
return Collections.emptySet();
}
}
src/main/java/pcz/p31_streamy/d_redukcje_i_grupowanie/Collector_Test.java 0 → 100644
package pcz.p31_streamy.d_redukcje_i_grupowanie;
import java.util.stream.Collector;
import java.util.stream.Collector.Characteristics;
import java.util.stream.Stream;
public class Collector_Test {
public static void main(String[] args) {
String[] imiona = {"Ala", "Ola", "Ela"};
CollectorLaczacyNapisy collector1 = new CollectorLaczacyNapisy();
String wynik1 = Stream.of(imiona).collect(collector1);
System.out.println(wynik1);
// Ale to samo można zrobić bezpośrednio w kodzie:
// Najpierw wersja, że akumulator staje się wynikiem - nie ma funkcji finisher
Collector<String, StringBuilder, StringBuilder> collector2 =
Collector.of(StringBuilder::new, StringBuilder::append, StringBuilder::append);
StringBuilder wynik2 = Stream.of(imiona).collect(collector2);
System.out.println(wynik2);
// Dodaję finisher równy StringBuilder.toString - ostateczny wynik typu String
Collector<String, StringBuilder, String> collector3 =
Collector.of(StringBuilder::new, StringBuilder::append, StringBuilder::append, StringBuilder::toString);
String wynik3 = Stream.of(imiona).collect(collector3);
System.out.println(wynik3);
}
}
src/main/java/pcz/p31_streamy/d_redukcje_i_grupowanie/Kolektory1.java 0 → 100644
package pcz.p31_streamy.d_redukcje_i_grupowanie;
import java.util.Collection;
import java.util.Comparator;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import emps.Employee;
import emps.ObslugaCSV;
public class Kolektory1 {
public static void main(String[] args) {
//List<Employee> emps = Collections.emptyList();
List<Employee> emps = ObslugaCSV.wczytaj();
// collectory obliczające standardowe funkcje agregujące
Long ilu = emps.stream().collect(Collectors.counting());
Integer suma = emps.stream().collect(Collectors.summingInt(Employee::getSalary));
Double avg = emps.stream().collect(Collectors.averagingInt(Employee::getSalary));
// dla pustego zbioru danych wychodzi 0.0
System.out.println(ilu + ", " + suma + ", " + avg);
// Porównuje pracowników wg pensji
Comparator<Employee> komp = Comparator.comparingInt(Employee::getSalary);
Optional<Employee> min = emps.stream().collect(Collectors.minBy(komp));
Optional<Employee> max = emps.stream().collect(Collectors.maxBy(komp));
System.out.println(min);
System.out.println(max);
// przykład wyciągaia wartości z Optionala
String str1 = min
.map(emp -> emp.getFirstName()
+ " " + emp.getLastName()
+ " / " + emp.getSalary())
.orElse("nie ma takiego gościa");
System.out.println(str1);
System.out.println();
// Oblicza wszystkie 5 standardowe funkcje agregujące
IntSummaryStatistics statystyki = emps.stream().collect(Collectors.summarizingInt(Employee::getSalary));
System.out.println(statystyki);
System.out.println(statystyki.getAverage());
System.out.println();
// Zestaw kolektorów zbierających dane do kolekcji:
List<String> list1 = emps.stream()
.map(Employee::getFirstName)
.sorted()
.distinct()
.collect(Collectors.toList());
System.out.println(list1);
Set<String> set1 = emps.stream()
.map(Employee::getCity)
.collect(Collectors.toSet());
System.out.println(set1);
Collection<String> kolekcja = emps.stream()
.map(Employee::getCity)
.collect(Collectors.toCollection(TreeSet::new));
System.out.println(kolekcja);
System.out.println();
// Tworząc słownik podajemy skąd się biorą klucze, skąd się biorą wartości
// i ewentualnie jak aktualizować już wpisane wartości
Map<String, Integer> grupy = emps.stream()
.collect(Collectors.toMap(Employee::getCity,
Employee::getSalary,
Math::addExact));
grupy.forEach((k,v) -> System.out.printf("%20s -> %10s\n", k, v));
System.out.println();
String txt1 = emps.stream()
.map(Employee::getDepartmentName)
.distinct()
.collect(Collectors.joining());
System.out.println(txt1);
String txt2 = emps.stream()
.map(Employee::getDepartmentName)
.distinct()
.collect(Collectors.joining(", "));
System.out.println(txt2);
String txt3 = emps.stream()
.map(Employee::getDepartmentName)
.distinct()
.collect(Collectors.joining(", ", "<", ">"));
System.out.println(txt3);
}
}
src/main/java/pcz/p31_streamy/d_redukcje_i_grupowanie/Kolektory2.java 0 → 100644
package pcz.p31_streamy.d_redukcje_i_grupowanie;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;
import emps.Employee;
import emps.ObslugaCSV;
public class Kolektory2 {
public static void main(String[] args) {
//List<Employee> emps = Collections.emptyList();
List<Employee> emps = ObslugaCSV.wczytaj();
// grouping by - zbiera elementy w grupy
Map<String, List<Employee>> grupy1 = emps.stream()
.collect(Collectors.groupingBy(Employee::getJobTitle));
grupy1.forEach((k,v) -> {
System.out.println(k);
v.forEach(emp -> {
System.out.printf(" %-12s %-12s %10s\n", emp.getFirstName(), emp.getLastName(), emp.getSalary());
});
});
System.out.println();
// Podajemy dodatkowy kolektor mówiący co robić z każdą grupą
Map<String, Integer> grupy2 = emps.stream()
.collect(Collectors.groupingBy(
Employee::getJobTitle,
Collectors.summingInt(Employee::getSalary)));
grupy2.forEach((k,v) -> {
System.out.printf("%-32s %12s\n", k, v);
});
System.out.println();
// Możemy też podać fabrykę map jako środkowy parametr
Map<String, Integer> grupy3 = emps.stream()
.collect(Collectors.groupingBy(
Employee::getJobTitle,
TreeMap::new,
Collectors.summingInt(Employee::getSalary)));
grupy3.forEach((k,v) -> {
System.out.printf("%-32s %12s\n", k, v);
});
System.out.println();
System.out.println("================");
Map<Boolean, List<Employee>> partycje1 = emps.stream()
.collect(Collectors.partitioningBy(emp -> emp.getSalary() >= 10000));
System.out.println("Bogaci:");
partycje1.get(true)
.forEach(emp -> System.out.println(" " + emp.getLastName()));
System.out.println("\nBiedni:");
partycje1.get(false)
.forEach(emp -> System.out.println(" "+ emp.getLastName()));
System.out.println();
Map<Boolean, Long> partycje2 = emps.stream()
.collect(Collectors.partitioningBy(
emp -> emp.getSalary() >= 10000,
Collectors.counting()));
System.out.println("Bogatych " + partycje2.get(true));
System.out.println("Biednych " + partycje2.get(false));
}
}
src/main/java/pcz/p31_streamy/d_redukcje_i_grupowanie/Silnia_Reduce.java 0 → 100644
package pcz.p31_streamy.d_redukcje_i_grupowanie;
import java.math.BigInteger;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
public class Silnia_Reduce {
static long silniaFun(int n) {
return LongStream.rangeClosed(2, n)
.reduce(1L, (a, i) -> a * i);
}
static long silniaKlasyczna(int n) {
// działa jak taka pętla:
long a = 1L;
for(int i = 2; i <= n; i++) {
a = a * i;
}
return a;
}
static long silniaFun2(int n) {
return LongStream.rangeClosed(2, n)
.reduce(1, Math::multiplyExact);
}
static BigInteger silniaFunBig(int n) {
return IntStream.rangeClosed(2, n)
.mapToObj(BigInteger::valueOf)
.reduce(BigInteger.ONE, BigInteger::multiply);
}
public static void main(String[] args) {
System.out.println(silniaFun(5));
System.out.println(silniaFun2(5));
try {
System.out.println(silniaFun2(21));
} catch (Exception e) {
System.out.println("overflow");
}
System.out.println(silniaFunBig(5));
System.out.println(silniaFunBig(100));
}
}
src/main/java/pcz/p32_parallel_stream/a/SprawdzanieIleWatkow1.java 0 → 100644
package pcz.p32_parallel_stream.a;
import java.util.Arrays;
import java.util.function.IntUnaryOperator;
import java.util.stream.IntStream;
public class SprawdzanieIleWatkow1 {
public static void main(String[] args) {
IntUnaryOperator operacja = x -> {
System.out.println(Thread.currentThread().getId());
return 2*x;
};
int[] tab = new int[100];
Arrays.fill(tab, 33);
System.out.println("Sekwencyjnie:");
int suma1 = IntStream.of(tab).map(operacja).sum();
System.out.println("suma1 = " + suma1);
System.out.println();
System.out.println("Parallel:");
int suma2 = IntStream.of(tab).parallel().map(operacja).sum();
System.out.println("suma2 = " + suma2);
}
}
src/main/java/pcz/p32_parallel_stream/a/SprawdzanieIleWatkow2.java 0 → 100644
package pcz.p32_parallel_stream.a;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.function.IntUnaryOperator;
import java.util.stream.IntStream;
public class SprawdzanieIleWatkow2 {
public static void main(String[] args) {
AtomicIntegerArray array = new AtomicIntegerArray(50);
IntUnaryOperator operacja = x -> {
int id = (int)Thread.currentThread().getId();
array.incrementAndGet(id);
return 2*x;
};
int[] tab = new int[1_000_000];
Arrays.fill(tab, 33);
System.out.println("Tablica wątków na początku:");
System.out.println(array);
int suma2 = IntStream.of(tab).parallel().map(operacja).sum();
System.out.println("suma2 = " + suma2);
System.out.println();
System.out.println("Tablica wątków na końcu:");
System.out.println(array);
int ileWatkow = 0;
for (int i = 0; i < array.length(); i++) {
if(array.get(i) > 0) {
ileWatkow++;
System.out.printf("wątek nr %3d - %8d razy\n", i, array.get(i));
}
}
System.out.println();
System.out.println("W sumie pracowało " + ileWatkow + " wątków.");
System.out.println("Ilość procesorów: " +
Runtime.getRuntime().availableProcessors());
}
}
src/main/java/pcz/p32_parallel_stream/a/SumArray.java 0 → 100644
package pcz.p32_parallel_stream.a;
import java.util.Random;
import java.util.function.LongSupplier;
import java.util.stream.LongStream;
public class SumArray {
static final int N = 120_000_000;
static final int MAX = 1000;
static final int POWTORZENIA = 40;
static long[] tab;
public static void main(String[] args) {
System.out.println("Generuje dane");
tab = new long[N];
wylosuj();
System.out.println("pętla");
testuj(SumArray::petla);
System.out.println("stream");
testuj(SumArray::sekw);
System.out.println("parallel stream");
testuj(SumArray::parallel);
System.out.println();
System.out.println("pętla");
testuj(POWTORZENIA, SumArray::petla);
System.out.println("stream");
testuj(POWTORZENIA, SumArray::sekw);
System.out.println("parallel stream");
testuj(POWTORZENIA, SumArray::parallel);
}
private static void testuj(LongSupplier metoda) {
long start = System.currentTimeMillis();
long wynik = metoda.getAsLong();
long end = System.currentTimeMillis();
System.out.printf("czas: %6d, wynik: %15d\n", end - start, wynik);
}
private static void testuj(int n, LongSupplier metoda) {
long start = System.currentTimeMillis();
long wynik = 0L;
for(int i = 1; i <= n; i++) {
wynik += metoda.getAsLong();
}
long end = System.currentTimeMillis();
System.out.printf("czas: %6d, wynik: %15d\n", end - start, wynik);
}
private static void wylosuj() {
Random r = new Random();
for (int i = 0; i < tab.length; i++) {
tab[i] = r.nextInt(MAX);
}
}
private static long petla() {
long suma = 0L;
for (int i = 0; i < tab.length; i++) {
suma += tab[i];
}
return suma;
}
private static long sekw() {
return LongStream.of(tab).sum();
}
private static long parallel() {
return LongStream.of(tab).parallel().sum();
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/ArrayListSplit.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.ArrayList;
import java.util.List;
import java.util.Spliterator;
import java.util.function.Consumer;
public class ArrayListSplit {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("aaa");
lista.add("bbb");
lista.add("ccc");
lista.add("ddd");
lista.add("eee");
lista.add("fff");
lista.add("ggg");
lista.add("hhh");
lista.add("iii");
lista.add("jjj");
System.out.println(lista);
Consumer<String> akcja = s -> System.out.println("* " + s);
System.out.println("Pętla tryAdvance:");
Spliterator<String> spliterator1 = lista.spliterator();
while(spliterator1.tryAdvance(akcja));
System.out.println();
System.out.println("forEachRemaining:");
Spliterator<String> spliterator2 = lista.spliterator();
spliterator2.forEachRemaining(akcja);
System.out.println();
System.out.println("trySplit 2 poziomy:");
Spliterator<String> spliterator3 = lista.spliterator();
System.out.println("estimate size: " + spliterator3.estimateSize());
Spliterator<String> spliterator3a = spliterator3.trySplit();
System.out.println("Oryginalny:");
spliterator3.forEachRemaining(akcja);
System.out.println("wynik pierwszego split:");
spliterator3a.forEachRemaining(akcja);
System.out.println();
System.out.println("trySplit 3 poziomy:");
Spliterator<String> spliterator4 = lista.spliterator();
System.out.println("estimate size: " + spliterator4.estimateSize());
Spliterator<String> spliterator4a = spliterator4.trySplit();
Spliterator<String> spliterator4b = spliterator4.trySplit();
System.out.println("Oryginalny:");
spliterator4.forEachRemaining(akcja);
System.out.println("wynik pierwszego split:");
spliterator4a.forEachRemaining(akcja);
System.out.println("wynik drugiego split:");
spliterator4b.forEachRemaining(akcja);
System.out.println();
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/LinkedListSplit.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Spliterator;
import java.util.function.Consumer;
// Morał: LinkedList nie dzieli się na fragmenty, więc operacje nie będą zrównoleglane
public class LinkedListSplit {
public static void main(String[] args) {
List<String> lista = new LinkedList<>();
lista.add("aaa");
lista.add("bbb");
lista.add("ccc");
lista.add("ddd");
lista.add("eee");
lista.add("fff");
lista.add("ggg");
lista.add("hhh");
lista.add("iii");
lista.add("jjj");
System.out.println(lista);
Consumer<String> akcja = s -> System.out.println("* " + s);
System.out.println("Pętla tryAdvance:");
Spliterator<String> spliterator1 = lista.spliterator();
while(spliterator1.tryAdvance(akcja));
System.out.println();
System.out.println("forEachRemaining:");
Spliterator<String> spliterator2 = lista.spliterator();
spliterator2.forEachRemaining(akcja);
System.out.println();
System.out.println("trySplit 2 poziomy:");
Spliterator<String> spliterator3 = lista.spliterator();
System.out.println("estimate size: " + spliterator3.estimateSize());
Spliterator<String> spliterator3a = spliterator3.trySplit();
System.out.println("Oryginalny:");
spliterator3.forEachRemaining(akcja);
System.out.println("wynik pierwszego split:");
spliterator3a.forEachRemaining(akcja);
System.out.println();
System.out.println("trySplit 3 poziomy:");
Spliterator<String> spliterator4 = lista.spliterator();
System.out.println("estimate size: " + spliterator4.estimateSize());
Spliterator<String> spliterator4a = spliterator4.trySplit();
Spliterator<String> spliterator4b = spliterator4.trySplit();
System.out.println("4a " + spliterator4a);
System.out.println("4b " + spliterator4b); // null
System.out.println("Oryginalny:");
spliterator4.forEachRemaining(akcja);
System.out.println("wynik pierwszego split:");
spliterator4a.forEachRemaining(akcja);
// NPE
// System.out.println("wynik drugiego split:");
// spliterator4b.forEachRemaining(akcja);
System.out.println();
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/MierzenieCzasu.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.function.LongSupplier;
public class MierzenieCzasu {
public static void uruchom(LongSupplier metoda) {
long start = System.nanoTime();
long wynik = metoda.getAsLong();
long end = System.nanoTime();
System.out.printf("czas: %12d , wynik = %d\n", (end - start) / 1000, wynik);
}
public static void uruchom(int n, LongSupplier metoda) {
long start = System.currentTimeMillis();
long wynik = 0L;
for(int i = 1; i <= n; i++) {
wynik += metoda.getAsLong();
}
long end = System.currentTimeMillis();
System.out.printf("czas: %6d, wynik: %15d\n", end - start, wynik);
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/SpliteratorLiczbyNieparzyste.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.Spliterator;
import java.util.function.Consumer;
public class SpliteratorLiczbyNieparzyste implements Spliterator<Integer> {
private int max;
private int min;
// domyślnie 100 liczb
public SpliteratorLiczbyNieparzyste() {
this(100);
}
public SpliteratorLiczbyNieparzyste(int ile) {
this(0, ile);
}
private SpliteratorLiczbyNieparzyste(int min, int max) {
this.min = min;
this.max = max;
}
private int next() {
return 1 + 2 * min++;
}
private boolean hasNext() {
return min < max;
}
@Override
public boolean tryAdvance(Consumer<? super Integer> action) {
if(hasNext()) {
action.accept(this.next());
return true;
} else {
return false;
}
}
@Override
public SpliteratorLiczbyNieparzyste trySplit() {
int middle = (max + min) / 2;
SpliteratorLiczbyNieparzyste nowy = new SpliteratorLiczbyNieparzyste(min, middle);
min = middle;
return nowy;
}
@Override
public long estimateSize() {
return max - min;
}
@Override
public int characteristics() {
return ORDERED | DISTINCT | SIZED | SUBSIZED | NONNULL;
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/SpliteratorPowolny.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.Spliterator;
import java.util.function.Consumer;
public class SpliteratorPowolny implements Spliterator<Integer> {
private int max;
private int min;
private int niepotrzebne;
private final int SPOWOLNIENIE = 10000;
// domyślnie 100 liczb
public SpliteratorPowolny() {
this(100);
}
public SpliteratorPowolny(int ile) {
this(0, ile);
}
private SpliteratorPowolny(int min, int max) {
this.min = min;
this.max = max;
}
private int next() {
for(int i=0; i<SPOWOLNIENIE; i++) {
niepotrzebne++;
}
return 1 + 2 * min++;
}
private boolean hasNext() {
return min < max;
}
@Override
public boolean tryAdvance(Consumer<? super Integer> action) {
action.accept(this.next());
return hasNext();
}
@Override
public SpliteratorPowolny trySplit() {
int middle = (max + min) / 2;
SpliteratorPowolny nowy = new SpliteratorPowolny(min, middle);
min = middle;
return nowy;
}
@Override
public long estimateSize() {
return max - min;
}
@Override
public int characteristics() {
return ORDERED | DISTINCT | SIZED | SUBSIZED | NONNULL;
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/SpliteratorPrimitive.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.Spliterator;
import java.util.function.IntConsumer;
public class SpliteratorPrimitive implements Spliterator.OfInt {
private int max;
private int min;
// domyślnie 100 liczb
public SpliteratorPrimitive() {
this(100);
}
public SpliteratorPrimitive(int ile) {
this(0, ile);
}
private SpliteratorPrimitive(int min, int max) {
this.min = min;
this.max = max;
}
private int next() {
return 1 + 2 * min++;
}
private boolean hasNext() {
return min < max;
}
@Override
public boolean tryAdvance(IntConsumer action) {
action.accept(this.next());
return hasNext();
}
@Override
public SpliteratorPrimitive trySplit() {
int middle = (max + min) / 2;
SpliteratorPrimitive nowy = new SpliteratorPrimitive(min, middle);
min = middle;
return nowy;
}
@Override
public long estimateSize() {
return max - min;
}
@Override
public int characteristics() {
return ORDERED | DISTINCT | SIZED | SUBSIZED | NONNULL;
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/Test1.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public class Test1 {
// Stream<Integer> bez spowalniania. Niepotrzebny narzut na boxing
public static void main(String[] args) {
SpliteratorLiczbyNieparzyste spl1 = new SpliteratorLiczbyNieparzyste(10000000);
Stream<Integer> str1 = StreamSupport.stream(spl1, false);
MierzenieCzasu.uruchom(() -> str1.mapToInt(x->x).sum());
SpliteratorLiczbyNieparzyste spl2 = new SpliteratorLiczbyNieparzyste(10000000);
Stream<Integer> str2 = StreamSupport.stream(spl2, true);
MierzenieCzasu.uruchom(() -> str2.mapToInt(x->x).sum());
System.out.println();
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/Test2.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.Spliterator;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public class Test2 {
// Spliterator sztucznie spowolniony, Stream<Integer>, widać zysk z parallel
public static void main(String[] args) {
Spliterator<Integer> spl1 = new SpliteratorPowolny(10000000);
Stream<Integer> str1 = StreamSupport.stream(spl1, false);
MierzenieCzasu.uruchom(() -> str1.mapToLong(x->x).sum());
Spliterator<Integer> spl2 = new SpliteratorPowolny(10000000);
Stream<Integer> str2 = StreamSupport.stream(spl2, true);
MierzenieCzasu.uruchom(() -> str2.mapToLong(x->x).sum());
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/Test3.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;
public class Test3 {
public static void main(String[] args) {
// IntStream bez żadnego boxingnu - działa najszybciej
SpliteratorPrimitive spl1 = new SpliteratorPrimitive(10000000);
IntStream str1 = StreamSupport.intStream(spl1, false);
MierzenieCzasu.uruchom(() -> str1.sum());
SpliteratorPrimitive spl2 = new SpliteratorPrimitive(10000000);
IntStream str2 = StreamSupport.intStream(spl2, true);
MierzenieCzasu.uruchom(() -> str2.sum());
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/TestNieparzyste.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.Spliterator;
import java.util.function.Consumer;
public class TestNieparzyste {
public static void main(String[] args) {
Consumer<Integer> akcja = i -> System.out.print(i + ", ");
SpliteratorLiczbyNieparzyste spl1 = new SpliteratorLiczbyNieparzyste(100);
spl1.forEachRemaining(akcja);
System.out.println();
System.out.println();
Spliterator<Integer> spl2 = new SpliteratorLiczbyNieparzyste(100);
Spliterator<Integer> a = spl2.trySplit();
Spliterator<Integer> b = a.trySplit();
System.out.println("Fragmenty:");
b.forEachRemaining(akcja);
System.out.println();
a.forEachRemaining(akcja);
System.out.println();
spl2.forEachRemaining(akcja);
System.out.println();
System.out.println();
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/TestStrumienNieparzystych.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public class TestStrumienNieparzystych {
public static void main(String[] args) {
Consumer<Integer> akcja = i -> System.out.print(i + ", ");
SpliteratorLiczbyNieparzyste spl1 = new SpliteratorLiczbyNieparzyste(100);
Stream<Integer> str1 = StreamSupport.stream(spl1, false);
str1.forEach(akcja);
System.out.println();
System.out.println();
SpliteratorLiczbyNieparzyste spl2 = new SpliteratorLiczbyNieparzyste(100);
Stream<Integer> str2 = StreamSupport.stream(spl2, true);
str2.forEach(akcja);
System.out.println();
System.out.println();
SpliteratorLiczbyNieparzyste spl3 = new SpliteratorLiczbyNieparzyste(50);
Stream<Integer> str3 = StreamSupport.stream(spl3, false);
int suma3 = str3.mapToInt(x -> x).sum();
System.out.println(suma3);
SpliteratorLiczbyNieparzyste spl4 = new SpliteratorLiczbyNieparzyste(50);
Stream<Integer> str4 = StreamSupport.stream(spl4, true);
int suma4 = str4.mapToInt(x -> x).sum();
System.out.println(suma4);
}
}
src/main/java/pcz/p32_parallel_stream/b_spliterator/TestStrumienPrimite.java 0 → 100644
package pcz.p32_parallel_stream.b_spliterator;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;
public class TestStrumienPrimite {
public static void main(String[] args) {
IntConsumer akcja = i -> System.out.print(i + ", ");
SpliteratorPrimitive spl1 = new SpliteratorPrimitive(100);
IntStream str1 = StreamSupport.intStream(spl1, false);
str1.forEach(akcja);
System.out.println();
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment