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

@@ -19,7 +19,7 @@ public class A_TypowyPrzyklad {
 				.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,8 +5,8 @@ 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 {
 

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

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

src/p16_streamy/d_redukcje_i_grupowanie/Kolektory1.java

@@ -10,8 +10,8 @@ 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 {
 

src/p16_streamy/d_redukcje_i_grupowanie/Kolektory2.java

@@ -5,8 +5,8 @@ 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 {
 

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());
+
+
+    }
+}