Nowa wersja przykładów Stream i Optional

.gitignore

 /.vscode/
 /bin/
 /*.log
+/.project
+/.classpath
+/.settings/

src/p16_streamy/Zadanka1.java

-package p16_streamy;
-
-import java.util.List;
-
-public class Zadanka1 {
-    public static void main(String[] args) {
-        List<String> miasta = List.of("Warszawa", "Kraków", "Wrocław", "Łódź", "Poznań");
-
-        // strumieniowo wypisz:
-        // - miasta, których nazwy mają >= 5 liter posortowane rosnąco
-        miasta.stream()
-            .filter(s -> s.length() >= 5)
-            .sorted() // .sorted(Collator.getInstance())
-            .map(String::toUpperCase)
-            .forEach(System.out::println);
-
-
-    }
-
-}

src/p16_streamy/a_poczatek/A_TypowyPrzyklad.java

@@ -13,13 +13,13 @@ public class A_TypowyPrzyklad {
 		
 		System.out.println(lista);
 		System.out.println();
-		
+
 		lista.stream()
-			.filter(s -> s.contains("a"))
-			.map(s -> s.toUpperCase())
-			.forEach(s -> System.out.println(s));
-		
-		
+				.filter(s -> s.contains("a"))
+				.map(s -> s.toUpperCase())
+				.forEach(s -> System.out.println(s));
+
+		System.out.println("\n=================\n");
 		// To odpowiada takiej pętli:
 		for(String s1 : lista) {
 			if(s1.contains("a")) {

src/p16_streamy/b_dzialanie/Zamykanie.java

+package p16_streamy.b_dzialanie;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+public class Zamykanie {
+    public static void main(String[] args) {
+        List<String> lista = List.of("Warszawa", "Kraków", "Wrocław", "Łódź", "Poznań");
+
+        System.out.println("próba 0:");
+        lista.stream()
+                .onClose(() -> System.out.println("zamykanie 0"))
+                .map(String::toUpperCase)
+                .forEach(System.out::println);
+                // samo wywołanie forEach nie skutkuje wywołaniem close
+
+        System.out.println("____\npróba 1:");
+        lista.stream()
+                .onClose(() -> System.out.println("zamykanie 1"))
+                .map(String::toUpperCase)
+                // nie da się zapisać łańcuchowo tak ani odwrotnie:
+                // .close().forEachOrdered(System.out::println)
+                // .forEachOrdered(System.out::println).close()
+                // zrobię tylko close
+                .close();
+
+        System.out.println("____\npróba 2:");
+        Stream<String> stream2 = lista.stream().onClose(() -> System.out.println("zamykanie 2"));
+        stream2.map(String::toUpperCase).forEach(System.out::println);
+        stream2.close();
+
+        System.out.println("____\npróba 3:");
+        Stream<String> stream3 = lista.stream()
+                .onClose(() -> System.out.println("zamykanie 3a"))
+                .map(String::toUpperCase)
+                .onClose(() -> System.out.println("zamykanie 3b"))
+                ;
+        stream3.forEach(System.out::println);
+        stream3.close();
+
+        System.out.println("____\npróba 4:");
+        try(Stream<String> stream4 = lista.stream()
+                .onClose(() -> System.out.println("zamykanie 4"))) {
+            stream4.map(String::toUpperCase)
+                    .forEach(System.out::println);
+        }
+
+        System.out.println("____\npróba 5:");
+        try(Stream<String> stream5 = lista.stream()) {
+            stream5.onClose(() -> System.out.println("zamykanie 5"))
+                    .map(String::toUpperCase)
+                    .forEach(System.out::println);
+        }
+    }
+}

src/p16_streamy/c_przeglad_operacji/C01_Generowanie.java

 package p16_streamy.c_przeglad_operacji;
 
 import java.time.LocalTime;
+import java.util.List;
 import java.util.stream.IntStream;
 import java.util.stream.LongStream;
 import java.util.stream.Stream;
@@ -29,10 +30,10 @@ public class C01_Generowanie {
 		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));
+		// List<LocalTime> lista = czasy.toList();
 
 		czasy.limit(20).forEach(lt -> System.out.println(lt));
 

src/p16_streamy/c_przeglad_operacji/C02_ZRoznychKlas.java

@@ -12,13 +12,12 @@ 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:
+		// 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();
@@ -34,7 +33,7 @@ public class C02_ZRoznychKlas {
 			
 			// dostęp strumieniowy
 			// strumienie też można zamykać; ten należy zamykać
-			try(Stream<String> lines = Files.lines(Paths.get("pan-tadeusz.txt"))) {
+			try(Stream<String> lines = Files.lines(Paths.get("pan_tadeusz.txt"))) {
 				lines.filter(s -> s.contains("Tadeusz"))
 					.sorted(Collator.getInstance())
 					.forEachOrdered(System.out::println);
@@ -44,13 +43,11 @@ public class C02_ZRoznychKlas {
 		}
 		System.out.println();
 		
-		Path dir = Paths.get("src");
-		try {
-			Files.list(dir)
-				.forEach(f -> System.out.println(f + " " + Files.isRegularFile(f)));
+		Path dir = Paths.get("src/main/java");
+		try(Stream<Path> paths = Files.list(dir)) {
+			paths.forEach(f -> System.out.println(f + " " + Files.isRegularFile(f)));
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 	}
-
 }

src/p16_streamy/c_przeglad_operacji/C12_FlatMap.java

@@ -16,46 +16,47 @@ public class C12_FlatMap {
 	}
 	
 	static Stream<Integer> generujStrumien(int ilosc) {
-		List<Integer> lista = new ArrayList<>();
-		for(int i = 1; i <= ilosc; i++) {
-			lista.add(i);
-		}
-		return lista.stream();
+		return generuj(ilosc).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);
+		return generujStrumien(ilosc).mapToInt(Integer::intValue);
 	}
 	
 
 	public static void main(String[] args) {
 		System.out.println(generuj(1));
 		System.out.println(generuj(3));
+		System.out.println(generuj(0));
 		System.out.println(generuj(5));
 		System.out.println();
 		
 		System.out.println("Elementy strumienia wejściowego:");
-		Stream.of(1, 3, 5)
+		Stream.of(1, 3, 0, 5)
 			.forEach(x -> System.out.print(x + " | "));
 		System.out.println();
 		System.out.println();
 
+		// W zwykłym map wynikowy strumień zawiera tyle samo elementów, co wejściowy.
+		// Jeśli funkcja mapuje wartości na kolekcje - wynikiem jest strumień kolekcji.
+		// Jeśli funkcja mapuje wartości na strumienie - wynikiem jest strumień strumieni.
 		System.out.println("Zwykłe mapowanie:");
-		Stream.of(1, 3, 5)
+		Stream.of(1, 3, 0, 5)
 			.map(C12_FlatMap::generuj)
 			.forEach(x -> System.out.print(x + " | "));
 		System.out.println();
-		
-		Stream.of(1, 3, 5)
+
+
+		Stream.of(1, 3, 0, 5)
 			.map(x -> C12_FlatMap.generuj(x).stream())
 			.forEach(x -> System.out.print(x + " | "));
 		System.out.println();
 		System.out.println();
 
+		// We flatMap funkcja powinna mapować wartość na strumień, a wynikiem jest konkatenacja wynikowych strumieni.
+		// Daje to możliwość mapowania pojedynczego elementu wejściowego na dowolną liczbę elementóœ wynikowych:
+		// zero (!), jeden, dowolną skończoną liczbę, a nawet nieskońćzoność.
+		// Funkcja mapuje wartości na strumienie - wynikiem jest strumień wartości.
 		System.out.println("Płaskie mapowanie:");
 		Stream.of(1, 3, 5)
 			.flatMap(x -> C12_FlatMap.generuj(x).stream())
@@ -74,5 +75,5 @@ public class C12_FlatMap {
 			.sum();
 		System.out.println(suma);
 	}
-
 }
+

src/p16_streamy/c_przeglad_operacji/C13_MultiMap.java

+package p16_streamy.c_przeglad_operacji;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class C13_MultiMap {
+	
+	public static void main(String[] args) {
+		System.out.println("Elementy strumienia wejściowego:");
+		Stream.of(1, 3, 0, 5)
+				.forEach(x -> System.out.print(x + " | "));
+		System.out.println();
+
+		// W mapMulti funkcja powinna przyjąć element strumienia wejściowego i wykonać odpowiednią ilość akcji
+		// na przekazanym do niej obiekcie Consumer.
+		// Wynikiem jest strumień składający się z tych wartości, które za pomocą accept zostały dostarczone do Consumera.
+		// Istotne jest, że wynikowy strumień może zawierać mniej lub więcej elementów, niż wejściowy (podobnie jak we flatMap).
+		System.out.println("mapMulti");
+		Stream.of(1, 3, 0, 5)
+				.mapMulti((n, c) -> {
+					for (int i = 1; i <= n; i++) {
+						c.accept(i);
+					}
+				})
+				.forEach(x -> System.out.print(x + " | "));
+		System.out.println("=================");
+		// przykład mapowania 1→1 za pomocą mapMulti (wiadomo, że dałoby się zwykłym map)
+		Stream.of(1, 3, 0, 5)
+				.mapMulti((n, c) -> c.accept(n*n))
+				.forEach(x -> System.out.print(x + " , "));
+	}
+
+}

src/p16_streamy/c_przeglad_operacji/C14_MinMax.java

@@ -5,21 +5,21 @@ import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 
-import emps.v2_obiektowo.Employee;
-import emps.v2_obiektowo.ObslugaCSV;
+import emps.v3_funkcyjnie.Employee;
+import emps.v3_funkcyjnie.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();
@@ -27,7 +27,7 @@ public class C14_MinMax {
 		} else {
 			System.out.println("nie ma minimum");
 		}
-		
+
 		if(max.isPresent()) {
 			System.out.println("Znaleziono maximum:");
 			Employee emp = max.get();
@@ -36,8 +36,8 @@ public class C14_MinMax {
 			System.out.println("nie ma maximum");
 		}
 		System.out.println();
-		
-		
+
+
 		String [] stanowiska = {"Programmer", "Shipping Clerk", "Brygadier"};
 		for (String stanowisko : stanowiska) {
 			String tekst = lista.stream()
@@ -45,9 +45,9 @@ public class C14_MinMax {
 				.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/p16_streamy/c_przeglad_operacji/C13_RozneOperacje.java → src/p16_streamy/c_przeglad_operacji/C15_RozneOperacje.java

@@ -6,7 +6,7 @@ import java.util.Optional;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public class C13_RozneOperacje {
+public class C15_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"};

src/p16_streamy/d_redukcje_i_grupowanie/Collect_i_Reduce.java

@@ -57,7 +57,7 @@ public class Collect_i_Reduce {
 			System.out.println("4: " + wynik);
 		}
 		
-		// to tłumaczy się na taką pętlę:
+		// to tłumaczy się na taką pętlę:
 		{
 			String wynik = "";
 			for (String s : imiona) {

src/p16_streamy/d_redukcje_i_grupowanie/CollectorLaczacyNapisy.java

@@ -38,6 +38,7 @@ public class CollectorLaczacyNapisy	implements Collector<String, StringBuilder,
 
 	@Override
 	public Set<Characteristics> characteristics() {
-		return Collections.emptySet();				
+		return Collections.emptySet();
+		// return Set.of(Characteristics.CONCURRENT);
 	}
 }

src/p16_streamy/d_redukcje_i_grupowanie/Kolektory1.java

@@ -10,32 +10,32 @@ import java.util.Set;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 
-import emps.v2_obiektowo.Employee;
-import emps.v2_obiektowo.ObslugaCSV;
+import emps.v3_funkcyjnie.Employee;
+import emps.v3_funkcyjnie.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()
@@ -50,7 +50,7 @@ public class Kolektory1 {
 		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)
@@ -58,7 +58,7 @@ public class Kolektory1 {
 			.distinct()
 			.collect(Collectors.toList());
 		System.out.println(list1);
-	
+
 		Set<String> set1 = emps.stream()
 				.map(Employee::getCity)
 				.collect(Collectors.toSet());
@@ -69,29 +69,29 @@ public class Kolektory1 {
 				.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()

src/p16_streamy/d_redukcje_i_grupowanie/Kolektory2.java

@@ -5,20 +5,20 @@ import java.util.Map;
 import java.util.TreeMap;
 import java.util.stream.Collectors;
 
-import emps.v2_obiektowo.Employee;
-import emps.v2_obiektowo.ObslugaCSV;
+import emps.v3_funkcyjnie.Employee;
+import emps.v3_funkcyjnie.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 -> {
@@ -26,35 +26,35 @@ public class Kolektory2 {
 			});
 		});
 		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()));
@@ -63,12 +63,12 @@ public class Kolektory2 {
 		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/p16_streamy/e_parallel/CompletableFutureExample.java

+package p16_streamy.e_parallel;
+
+import java.util.concurrent.CompletableFuture;
+
+public class CompletableFutureExample {
+    public static void main(String[] args) {
+        CompletableFuture.supplyAsync(() -> ("Hello, Async!"))
+                         .thenApply(String::toUpperCase)
+                         .thenAccept(System.out::println)
+                ;
+        System.out.println("Koniec main");
+    }
+}
\ No newline at end of file

src/p16_streamy/e_parallel/CompletableFutureMonadExample.java

+package p16_streamy.e_parallel;
+
+import java.util.concurrent.CompletableFuture;
+
+public class CompletableFutureMonadExample {
+    public static void main(String[] args) {
+        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello, Monads!")
+                .thenApply(String::toUpperCase) // Zmiana na wielkie litery
+                .thenApply(result -> result + " with CompletableFuture");
+
+        future.thenAccept(System.out::println); // Wyświetlenie wyniku
+    }
+}
\ No newline at end of file

src/p16_streamy/e_parallel/IleMamProckow.java

+package p16_streamy.e_parallel;
+
+public class IleMamProckow {
+
+	public static void main(String[] args) {
+		Runtime runtime = Runtime.getRuntime();
+		System.out.println("procki " + runtime.availableProcessors());
+		System.out.println("zajęta pamięć: " + (runtime.totalMemory() - runtime.freeMemory()));
+	}
+
+}

src/p17_parallel_stream/a/SprawdzanieIleWatkow1.java → src/p16_streamy/e_parallel/SprawdzanieIleWatkow1.java

-package p17_parallel_stream.a;
+package p16_streamy.e_parallel;
 
 import java.util.Arrays;
 import java.util.function.IntUnaryOperator;

src/p17_parallel_stream/a/SprawdzanieIleWatkow2.java → src/p16_streamy/e_parallel/SprawdzanieIleWatkow2.java

-package p17_parallel_stream.a;
+package p16_streamy.e_parallel;
 
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicIntegerArray;

src/p17_parallel_stream/a/SumArray.java → src/p16_streamy/e_parallel/SumArray.java

-package p17_parallel_stream.a;
+package p16_streamy.e_parallel;
 
 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 N = 200_000_000;
 	static final int MAX = 1000;
 	static final int POWTORZENIA = 40;
 	static long[] tab;

src/p17_parallel_stream/b_spliterator/ArrayListSplit.java → src/p17_spliterator/ArrayListSplit.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.ArrayList;
 import java.util.List;

src/p17_parallel_stream/b_spliterator/LinkedListSplit.java → src/p17_spliterator/LinkedListSplit.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.LinkedList;
 import java.util.List;

src/p17_parallel_stream/b_spliterator/MierzenieCzasu.java → src/p17_spliterator/MierzenieCzasu.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.function.LongSupplier;
 

src/p17_spliterator/SlidingWindowSpliterator.java

+package p17_spliterator;
+
+import java.util.List;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+public class SlidingWindowSpliterator<T> implements Spliterator<List<T>> {
+    private final List<T> list;
+    private final int windowSize;
+    private int currentIndex = 0;
+
+    public SlidingWindowSpliterator(List<T> list, int windowSize) {
+        this.list = list;
+        this.windowSize = windowSize;
+    }
+
+    @Override
+    public boolean tryAdvance(Consumer<? super List<T>> action) {
+        if (currentIndex + windowSize <= list.size()) {
+            List<T> window = list.subList(currentIndex, currentIndex + windowSize);
+            action.accept(window);
+            currentIndex++;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public Spliterator<List<T>> trySplit() {
+        return null; // Prosta implementacja, brak podziału
+    }
+
+    @Override
+    public long estimateSize() {
+        return list.size() - windowSize + 1L;
+    }
+
+    @Override
+    public int characteristics() {
+        return ORDERED | NONNULL | SIZED;
+    }
+
+    public static <T> Stream<List<T>> slidingWindowStream(List<T> list, int windowSize) {
+        return StreamSupport.stream(new SlidingWindowSpliterator<>(list, windowSize), false);
+    }
+
+    public static void main(String[] args) {
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
+
+        SlidingWindowSpliterator.slidingWindowStream(numbers, 3)
+                .forEach(System.out::println);
+
+        // Wynik:
+        // [1, 2, 3]
+        // [2, 3, 4]
+        // [3, 4, 5]
+    }
+}
\ No newline at end of file

src/p17_parallel_stream/b_spliterator/SpliteratorLiczbyNieparzyste.java → src/p17_spliterator/SpliteratorLiczbyNieparzyste.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.Spliterator;
 import java.util.function.Consumer;

src/p17_parallel_stream/b_spliterator/SpliteratorPowolny.java → src/p17_spliterator/SpliteratorPowolny.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.Spliterator;
 import java.util.function.Consumer;

src/p17_parallel_stream/b_spliterator/SpliteratorPrimitive.java → src/p17_spliterator/SpliteratorPrimitive.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.Spliterator;
 import java.util.function.IntConsumer;

src/p17_parallel_stream/b_spliterator/Test1.java → src/p17_spliterator/Test1.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;

src/p17_parallel_stream/b_spliterator/Test2.java → src/p17_spliterator/Test2.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.Spliterator;
 import java.util.stream.Stream;

src/p17_parallel_stream/b_spliterator/Test3.java → src/p17_spliterator/Test3.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.stream.IntStream;
 import java.util.stream.StreamSupport;

src/p17_parallel_stream/b_spliterator/TestNieparzyste.java → src/p17_spliterator/TestNieparzyste.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.Spliterator;
 import java.util.function.Consumer;

src/p17_parallel_stream/b_spliterator/TestStrumienNieparzystych.java → src/p17_spliterator/TestStrumienNieparzystych.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.function.Consumer;
 import java.util.stream.Stream;

src/p17_parallel_stream/b_spliterator/TestStrumienPrimite.java → src/p17_spliterator/TestStrumienPrimite.java

-package p17_parallel_stream.b_spliterator;
+package p17_spliterator;
 
 import java.util.function.IntConsumer;
 import java.util.stream.IntStream;

src/p16_streamy/KlasaOptional.java → src/p18_optional/KlasaOptional.java

-package p16_streamy;
+package p18_optional;
 
 import java.time.LocalTime;
 import java.util.ArrayList;
@@ -51,7 +51,7 @@ public class KlasaOptional {
 		}
 		System.out.println();
 		
-		// Można też pobierając wartość zastąpić ją wartością domyślną w przypadku braku danych:
+		// Można też pobierając wartość zastąpić ją wartością domyślną w przypadku braku danych:
 		for(Optional<String> opt : lista) {
 			String napis = opt.orElse("nieznana osoba");
 			System.out.println("Witaj osobo " + napis);

src/p18_optional/OrElseGet.java

+package p18_optional;
+
+import java.time.LocalTime;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+public class OrElseGet {
+
+    public static void main(String[] args) {
+        Supplier<LocalTime> dajCzas = () -> {
+            try { Thread.sleep(1000);
+            } catch (InterruptedException e) { }
+            return LocalTime.now();
+        };
+
+        System.out.println("A przed, " + LocalTime.now());
+        LocalTime wynik1 = Stream.generate(dajCzas)
+                .limit(5)
+                .filter(t -> t.getSecond() >= 50)
+                .findFirst()
+                .orElse(LocalTime.now());
+        System.out.println("A wynik: " + wynik1);
+        System.out.println("A po:    " + LocalTime.now());
+        System.out.println();
+
+        System.out.println("B przed, " + LocalTime.now());
+        LocalTime wynik2 = Stream.generate(dajCzas)
+                .limit(5)
+                .filter(t -> t.getSecond() >= 50)
+                .findFirst()
+                .orElseGet(LocalTime::now);
+        System.out.println("B wynik: " + wynik2);
+        System.out.println("B po:    " + LocalTime.now());
+
+
+    }
+}