ostatnia duża wrzutka "gotowych"

src/main/java/gotowe/p30_lambdy/v3/EffectivelyFinal.java

@@ -2,6 +2,7 @@ package gotowe.p30_lambdy.v3;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class EffectivelyFinal {
 	private static int statyczna = 0;
@@ -22,23 +23,40 @@ public class EffectivelyFinal {
 		
 		liczba = liczba + imiona.size();
 		
+		// metoda forEach jest nowym sposobem iteracji po elementach list i innych kolekcji
+		// wydaje się podobna do pętli for-each, ale jednak działa inaczej
+//		for(String s: imiona) {
+//			// ...
+//		}
+
 		int x = 0;
+		int[] t = {0};
+		AtomicInteger ai = new AtomicInteger();
 
 		// Głupie rozwiązanie problemu "ile jest jest imion 3-literowych"
 		imiona.forEach(s -> {
 			if(s.length() == 3) {			
-				//NK x++; // wewnątrz wyrażeń lambda nie można modyfikować zmiennych lokalnych z otoczenia
+				// x++; // wewnątrz wyrażeń lambda nie można modyfikować zmiennych lokalnych z otoczenia
 
 				// ani nawet używać zmiennych modyfikowanych poza lambdą
 				//NK System.out.println(liczba);
 				
 				// mamy dostęp do zmiennych z poziomu klasy (statycznych, isntancyjnych)
 				statyczna++;
+				t[0]++;
+				ai.incrementAndGet();
 				// ale to zły styl
+				// System.out.println(x);
 			}
 		});
 		
 		System.out.println("        x : " + x);
 		System.out.println("statyczna : " + statyczna);
+		System.out.println("        t : " + t[0]);
+		System.out.println("AtomicInt : " + ai);
+
+		// ale najlepiej:
+		long count = imiona.stream().filter(s -> s.length() == 3).count();
+		System.out.println("count: " + count);
 	}
 }

src/main/java/gotowe/p31_streamy/KlasaOptional.java

+package gotowe.p31_streamy;
+
+import java.time.LocalTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+public class KlasaOptional {
+
+	public static void main(String[] args) {
+		Optional<String> napis0 = Optional.empty();
+		System.out.println(napis0);
+		
+		Optional<String> napis1 = Optional.of("Ala");
+		System.out.println(napis1);
+		
+		// Można też tworzyć Optional w oparciu o wartość, która może być nullem (null oznacza empty)
+		String a = "Ola", b = null;
+		
+		Optional<String> napis2 = Optional.ofNullable(a);
+		Optional<String> napis3 = Optional.ofNullable(b);
+		System.out.println(napis2);
+		System.out.println(napis3);
+		System.out.println();
+		
+		// Wartość, która jest w Optionalu, najprościej odczytać operacją get
+		System.out.println(napis1.get());
+		
+		// ale w przypadku pustego Optionala spowodowałoby to wyjątek
+		try {
+			System.out.println(napis0.get());
+		} catch (Exception e) {
+			System.err.println("próba odczytu napis0.get(): " + e);
+		}
+		System.out.println();
+		
+		// Aby porównać działanie dla pustych i niepustych, operacje uruchamiam w pętli dla 3 przykładowych obiektów.
+		List<Optional<String>> lista = new ArrayList<>(Arrays.asList(napis1, napis2, napis3));
+		// Od Javy 9 możnaby (lista jest niemutowalna)
+		// List<Optional<String>> lista = List.of(napis1, napis2, napis3);
+		
+		
+		// Dla każdego Optionala można za pomocą if sprawdzić czy on zawiera wartość:
+		for(Optional<String> opt : lista) {
+			if(opt.isPresent()) {
+				System.out.println("Jest wartość " + opt.get());
+			} else {
+				System.out.println("Brak wartości");
+			}
+		}
+		System.out.println();
+		
+		// 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);
+		}
+		System.out.println();
+		
+		// Ponieważ utworzenie domyślnej wartości może być czasami kosztowne,
+		// albo musi być zrobione w czasie działania programu,
+		// można też przekazać funkcję, która utworzy tę wartość - najczęściej jako wyrażenienie lambda:
+		for(Optional<String> opt : lista) {
+			String napis = opt.orElseGet(() -> "Brak danych stwierdzony o godzinie " + LocalTime.now());
+			System.out.println("Halo halo " + napis);
+		}
+		System.out.println();
+		
+		// Można też wyrzucić wyjątek, ale własny zamiast standardowego
+		try {
+			for(Optional<String> opt : lista) {
+				String napis = opt.orElseThrow(() -> new RuntimeException("Brak danych stwierdzony o godzinie " + LocalTime.now()));
+				System.out.println("Helo helo " + napis);
+			}
+		} catch (Exception e) {
+			System.err.println(e);
+		}
+		System.out.println();
+		
+		
+		// Są też operacje "funkcyjne", które przypominają operacje na strumieniach.
+		// Uwaga wstępna - wszystkie te operacjie noe modyfikują obiektu Optional w środku,
+		// tylko w wyniku zwracają nowego Optionala.
+		
+		// Operacja map zamienia wartość w Optionalu na wynik funkcji,
+		// ale w przypadku pustego Optionala zwraca pustego Optionala
+		
+		Optional<String> wynikMap0 = napis0.map(String::toUpperCase);
+		Optional<String> wynikMap1 = napis1.map(String::toUpperCase);
+		System.out.println(wynikMap0);
+		System.out.println(wynikMap1);
+		
+		for(Optional<String> opt : lista) {
+			System.out.println("hej " + opt.map(String::toLowerCase).orElse("nieznajomy"));
+		}
+		System.out.println();
+		// 
+
+		for(Optional<String> opt : lista) {
+			String napis = opt.filter(s -> s.startsWith("O")).map(String::toUpperCase).orElse("---");
+			System.out.println(napis); 
+		}
+	}
+
+}

src/main/java/gotowe/p31_streamy/a_poczatek/A_TypowyPrzyklad.java

+package gotowe.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/gotowe/p31_streamy/b_dzialanie/Strumienie1.java

+package gotowe.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/gotowe/p31_streamy/b_dzialanie/Strumienie2_JakToDziala.java

+package gotowe.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", "Iwona", "Ola", "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 imion: " + lista);
+		System.out.println("Jestem 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))
+			// .sorted()
+			.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/gotowe/p31_streamy/b_dzialanie/Strumienie2a.java

+package gotowe.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/gotowe/p31_streamy/b_dzialanie/Strumienie2b.java

+package gotowe.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/gotowe/p31_streamy/b_dzialanie/Strumienie2c.java

+package gotowe.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/gotowe/p31_streamy/b_dzialanie/Strumienie2d.java

+package gotowe.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/gotowe/p31_streamy/b_dzialanie/Strumienie2e.java

+package gotowe.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/gotowe/p31_streamy/b_dzialanie/Strumienie2f.java

+package gotowe.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/gotowe/p31_streamy/b_dzialanie/Strumienie2g.java

+package gotowe.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/gotowe/p31_streamy/b_dzialanie/Strumienie3_Peek.java

+package gotowe.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/gotowe/p31_streamy/c_przeglad_operacji/C01_Generowanie.java

+package gotowe.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/gotowe/p31_streamy/c_przeglad_operacji/C02_ZRoznychKlas.java

+package gotowe.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/gotowe/p31_streamy/c_przeglad_operacji/C11_FilterMap.java

+package gotowe.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/gotowe/p31_streamy/c_przeglad_operacji/C12_FlatMap.java

+package gotowe.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/gotowe/p31_streamy/c_przeglad_operacji/C12b_FlaMapTekstu.java

+package gotowe.p31_streamy.c_przeglad_operacji;
+
+import java.util.stream.Stream;
+
+public class C12b_FlaMapTekstu {
+
+    public static void main(String[] args) {
+        Stream<String> linie = Stream.of(
+                "Ala ma kota",
+                "Ola ma psa",
+                "Sierotka ma rysia"
+        );
+
+// tutaj powstaje strumień 3 strumieni
+//        linie.map(linia -> Stream.of(linia.split("\\s+")))
+//                .forEach(System.out::println);
+
+// tutaj powstaje strumień połączonych słów
+        linie.flatMap(linia -> Stream.of(linia.split("\\s+")))
+                .map(String::toUpperCase)
+                .forEach(System.out::println);
+
+    }
+}

src/main/java/gotowe/p31_streamy/c_przeglad_operacji/C13_RozneOperacje.java

+package gotowe.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/gotowe/p31_streamy/c_przeglad_operacji/C21_DistinctSorted.java

+package gotowe.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/gotowe/p31_streamy/c_przeglad_operacji/C22_DistinctSorted.java

+package gotowe.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/gotowe/p31_streamy/c_przeglad_operacji/C23_DistinctSorted.java

+package gotowe.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/gotowe/p31_streamy/c_przeglad_operacji/C31_TypyProste.java

+package gotowe.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/gotowe/p31_streamy/d_redukcje_i_grupowanie/Collect_i_Reduce.java

+package gotowe.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/gotowe/p31_streamy/d_redukcje_i_grupowanie/CollectorLaczacyNapisy.java

+package gotowe.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/gotowe/p31_streamy/d_redukcje_i_grupowanie/Collector_Test.java

+package gotowe.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/gotowe/p31_streamy/d_redukcje_i_grupowanie/Silnia_Reduce.java

+package gotowe.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/gotowe/p32_parallel_stream/a/SprawdzanieIleWatkow1.java

+package gotowe.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/gotowe/p32_parallel_stream/a/SprawdzanieIleWatkow2.java

+package gotowe.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/gotowe/p32_parallel_stream/a/SumArray.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/ArrayListSplit.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/LinkedListSplit.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/MierzenieCzasu.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/SpliteratorLiczbyNieparzyste.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/SpliteratorPowolny.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/SpliteratorPrimitive.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/Test1.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/Test2.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/Test3.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/TestNieparzyste.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/TestStrumienNieparzystych.java

+package gotowe.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/gotowe/p32_parallel_stream/b_spliterator/TestStrumienPrimite.java

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

src/main/java/gotowe/p35_daty/DataICzas.java

+package gotowe.p35_daty;
+
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.time.temporal.ChronoField;
+
+public class DataICzas {
+
+	public static void main(String[] args) {
+		
+		// Która godzina jest w innej strefie czasowej
+		LocalDateTime dt2 = LocalDateTime.now(ZoneId.of("UTC-4"));
+		System.out.println(dt2);
+		
+		
+		LocalDateTime dt = LocalDateTime.now();
+		System.out.println(dt);
+		
+		// Metody "with" modyfikują wybrane pole i zwracają wmieniony obiekt
+		dt.with(ChronoField.HOUR_OF_DAY, 17);
+		System.out.println(dt); // nie widać zmiany, bo dato-czasy są immutable
+		
+		// przypisanie na zmienną dt zapisuje zmieniony obiekt
+		dt = dt.with(ChronoField.HOUR_OF_DAY, 17);
+		System.out.println(dt);
+
+		dt = dt.withDayOfMonth(13);
+		System.out.println(dt);
+
+		dt = dt.withDayOfYear(200);
+		System.out.println(dt);
+
+		dt = dt.with(ChronoField.SECOND_OF_DAY, 12360);
+		System.out.println(dt);
+
+		try {
+			dt = dt.with(ChronoField.OFFSET_SECONDS, 7200);
+			System.out.println(dt);
+		} catch (Exception e) {
+			System.out.println("Był wyjątek " + e.getClass() + " " + e.getMessage());
+		}
+
+		dt = LocalDateTime.now();
+		System.out.println(dt);
+		OffsetDateTime przesuniety = dt.atOffset(ZoneOffset.ofHours(5));
+		System.out.println(przesuniety);
+		
+		dt = LocalDateTime.parse("2019-05-08T14:55:04.360");
+		System.out.println(dt);
+		
+		dt = LocalDateTime.parse("2019-05-08T14:55");
+		System.out.println(dt);
+
+		dt = LocalDateTime.parse("2019-05-08T14:55:00");
+		System.out.println(dt); // sekundy równe zero w ogóle się nie wypisują
+
+	}
+}

src/main/java/gotowe/p35_daty/Formatowanie1_Standardy.java

+package gotowe.p35_daty;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+
+public class Formatowanie1_Standardy {
+
+	public static void main(String[] args) {
+		LocalDateTime teraz = LocalDateTime.now();
+		
+		DateTimeFormatter[] formats = {
+				DateTimeFormatter.BASIC_ISO_DATE,
+				DateTimeFormatter.ISO_DATE,
+				DateTimeFormatter.ISO_DATE_TIME,
+				DateTimeFormatter.ISO_LOCAL_DATE_TIME,
+				DateTimeFormatter.ISO_ORDINAL_DATE,
+				DateTimeFormatter.ISO_WEEK_DATE,
+		};
+		
+		System.out.println("Format domyslny:");
+		System.out.println(teraz.toString());
+		System.out.println(LocalDate.now().toString());
+		System.out.println(LocalTime.now().toString());
+		System.out.println();
+		
+		for (DateTimeFormatter df : formats) {
+			// formatowanie można wywoływać na dwa sposoby
+			System.out.println(teraz.format(df));
+			System.out.println(df.format(teraz));
+		}
+	}
+}

src/main/java/gotowe/p35_daty/Formatowanie2_Jezykowo.java

+package gotowe.p35_daty;
+
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.FormatStyle;
+import java.util.Locale;
+
+public class Formatowanie2_Jezykowo {
+
+	public static void main(String[] args) {
+		ZonedDateTime teraz = ZonedDateTime.now();
+		
+		DateTimeFormatter df = DateTimeFormatter
+				.ofLocalizedDateTime(FormatStyle.FULL)
+				.withLocale(new Locale("ru", "RU"));
+
+		System.out.println(teraz.format(df));
+	}
+}

src/main/java/gotowe/p35_daty/Formatowanie3_Jezykowo_BezStrefy.java

+package gotowe.p35_daty;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.FormatStyle;
+import java.util.Locale;
+
+public class Formatowanie3_Jezykowo_BezStrefy {
+
+	public static void main(String[] args) {
+		LocalDateTime teraz = LocalDateTime.now();
+		
+		Locale[] locales = {
+			new Locale("pl", "PL"),
+			new Locale("pl"),
+			new Locale("fr", "FR"),
+			new Locale("de", "DE"),
+			new Locale("es", "ES"),
+			new Locale("it", "IT"),
+			new Locale("ru", "RU"),
+			new Locale("ja", "JP"),
+			new Locale("ar", "EY"),
+			new Locale("en", "GB"),
+			new Locale("en", "US"),
+			new Locale("en")
+		};
+		
+		FormatStyle[] styles = {
+			//FormatStyle.FULL,
+			//FormatStyle.LONG,
+			FormatStyle.MEDIUM,
+			FormatStyle.SHORT
+		};
+		
+		for(Locale locale : locales) {
+			System.out.println("\nLOCALE " + locale);
+			for(FormatStyle style : styles) {
+				DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(style);
+				System.out.println(teraz.format(df));
+			}
+		}
+		
+	}
+
+}

src/main/java/gotowe/p35_daty/Formatowanie4_Jezykowo_Strefa.java

+package gotowe.p35_daty;
+
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.FormatStyle;
+import java.util.Locale;
+
+public class Formatowanie4_Jezykowo_Strefa {
+
+	public static void main(String[] args) {
+		ZonedDateTime teraz = ZonedDateTime.now();
+		
+		Locale[] locales = {
+			new Locale("pl", "PL"),
+			new Locale("pl"),
+			new Locale("fr", "FR"),
+			new Locale("de", "DE"),
+			new Locale("es", "ES"),
+			new Locale("it", "IT"),
+			new Locale("ru", "RU"),
+			new Locale("ja", "JP"),
+			new Locale("ar", "EY"),
+			new Locale("en", "GB"),
+			new Locale("en", "US"),
+			new Locale("en")
+		};
+		
+		FormatStyle[] styles = {
+			FormatStyle.FULL,
+			FormatStyle.LONG,
+			FormatStyle.MEDIUM,
+			FormatStyle.SHORT
+		};
+		
+		for(Locale locale : locales) {
+			System.out.println("\nLOCALE " + locale);
+			for(FormatStyle style : styles) {
+				DateTimeFormatter df = DateTimeFormatter
+						.ofLocalizedDateTime(style)
+						.withLocale(locale);
+				System.out.println(teraz.format(df));
+				System.out.println(df.format(teraz));
+			}
+		}		
+	}
+}

src/main/java/gotowe/p35_daty/Formatowanie5_Pattern.java

+package gotowe.p35_daty;
+
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+
+public class Formatowanie5_Pattern {
+
+	public static void main(String[] args) {
+		ZonedDateTime teraz = ZonedDateTime.now();
+		
+		DateTimeFormatter df = DateTimeFormatter.ofPattern("YYYY-MM-dd");
+		System.out.println(teraz.format(df));
+
+		df = DateTimeFormatter.ofPattern("dd.MM.YY");
+		System.out.println(teraz.format(df));
+
+		df = DateTimeFormatter.ofPattern("dd.MM.YYY");
+		System.out.println(teraz.format(df));
+
+		df = DateTimeFormatter.ofPattern("d M Y");
+		System.out.println(teraz.format(df));
+
+		df = DateTimeFormatter.ofPattern("dd MM YY");
+		System.out.println(teraz.format(df));
+
+		df = DateTimeFormatter.ofPattern("e dd MMM");
+		System.out.println(teraz.format(df));
+
+		df = DateTimeFormatter.ofPattern("EEE, dd MMMM");
+		System.out.println(teraz.format(df));
+
+		df = DateTimeFormatter.ofPattern("EEEE, dd MMMMM");
+		System.out.println(teraz.format(df));
+	}
+}

src/main/java/gotowe/p35_daty/Formatowanie6_Parse.java

+package gotowe.p35_daty;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+public class Formatowanie6_Parse {
+
+	public static void main(String[] args) {
+		LocalDateTime data = LocalDateTime.now();
+
+		DateTimeFormatter df = DateTimeFormatter.ofPattern("EEEE,yyyyMMdd HH@mm");
+		System.out.println(data.format(df));
+		System.out.println(data);
+		System.out.println();
+		
+		data = LocalDateTime.parse("wtorek,19981208 12@13", df);
+		System.out.println(data);
+	}
+}

src/main/java/gotowe/p35_daty/Okresy.java

+package gotowe.p35_daty;
+
+import java.time.LocalDate;
+import java.time.Period;
+
+public class Okresy {
+
+	public static void main(String[] args) {
+		
+		LocalDate d1 = LocalDate.parse("2015-05-13");
+		LocalDate d2 = LocalDate.parse("2016-09-11");
+		
+		Period p1 = Period.between(d1, d2);
+		System.out.println(p1);
+
+		Period p2 = Period.of(3, 14, 44);
+		System.out.println(p2);
+		
+		LocalDate dzisiaj = LocalDate.now();
+		LocalDate przyszlosc1 = dzisiaj.plus(p2);
+		System.out.println(przyszlosc1);
+
+		LocalDate przyszlosc2 = (LocalDate) p2.addTo(dzisiaj);
+		System.out.println(przyszlosc2);
+		
+		Period p3 = p2.normalized();
+		System.out.println(p3); // miesiące są normalizowane (miesiące powyżej 12 są zamieniane na lata), ale dni nie, bo się nie da
+		System.out.println();
+		
+		Period p4 = Period.parse("P3M2W10D");  // tygodnie od razu przeliczają się na dni, ale miesiące nie przeliczają się na lata
+		System.out.println(p4);
+
+		Period p5 = Period.ofWeeks(3);
+		System.out.println(p5);
+
+		Period p6 = Period.ofDays(50);
+		System.out.println(p6);
+	}
+
+}

src/main/java/gotowe/p35_daty/Porownywanie.java

+package gotowe.p35_daty;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class Porownywanie {
+
+	public static void main(String[] args) {
+		LocalDate d1 = LocalDate.now();
+		LocalDate d2 = LocalDate.of(2016, 12, 7);
+		LocalDate d3 = LocalDate.parse("2016-04-04");
+		
+		System.out.println(d1.equals(d2)); // T
+		System.out.println(d1.equals(d3)); // F
+		
+		if(d1.compareTo(d3) > 0) {
+			System.out.println("d1 później niż d3");
+		} else {
+			System.out.println("d1 wcześniej niż d3");			
+		}
+
+		if(d1.isAfter(d3)) {
+			System.out.println("d1 później niż d3");
+		} else {
+			System.out.println("d1 wcześniej niż d3");			
+		}
+		
+		ArrayList<LocalDate> daty = new ArrayList<>();
+		daty.add(LocalDate.of(2015, 12, 24));
+		daty.add(LocalDate.of(2016, 9, 24));
+		daty.add(LocalDate.of(2015, 3, 11));
+		daty.add(LocalDate.of(2016, 8, 8));
+
+		System.out.println(daty);		
+		Collections.sort(daty);
+		System.out.println(daty);
+	}
+
+}

src/main/java/gotowe/p35_daty/ProsteDaty.java

+package gotowe.p35_daty;
+
+import java.time.LocalDate;
+import java.time.Month;
+import java.time.Period;
+
+public class ProsteDaty {
+
+	public static void main(String[] args) {
+		LocalDate data1 = LocalDate.now();
+		System.out.println(data1);
+		
+		LocalDate data2 = LocalDate.of(2016, 12, 5);
+		System.out.println(data2);
+
+		LocalDate data3 = LocalDate.of(2016, Month.DECEMBER, 5);
+		System.out.println(data3);
+
+		LocalDate data4 = LocalDate.parse("2016-12-05");
+		System.out.println(data4);
+
+		LocalDate data5 = LocalDate.parse("2016-02-29");
+		System.out.println(data5);
+
+//		LocalDate data6 = LocalDate.parse("2015-02-29");
+//		System.out.println(data6);
+
+		// najpierw starsza potem pozniejsza
+		Period czasTrwania = Period.between(data4, data1);
+		System.out.println(czasTrwania);
+		
+		System.out.println(czasTrwania.getDays());
+	}
+}

src/main/java/gotowe/p35_daty/ProstyCzas.java

+package gotowe.p35_daty;
+
+import java.time.LocalTime;
+
+public class ProstyCzas {
+
+	public static void main(String[] args) {
+		
+		LocalTime czas1 = LocalTime.now();  // ustawia z dokladnoscia do milisekundy
+		System.out.println(czas1);
+		
+		// uwaga: można utworzyć czas nie podając sekund
+		LocalTime czas2 = LocalTime.of(12, 15);
+		System.out.println(czas2);
+		
+		LocalTime czas3 = LocalTime.of(12, 15, 33);
+		System.out.println(czas3);
+		
+		// uwaga: nanosekumdy podajemy jako liczbę całkowitą (int)
+		LocalTime czas4 = LocalTime.of(12, 15, 33, 333222111);
+		System.out.println(czas4);
+
+		// to oznacza jedną nanosekundę (miliardową część sekundy),
+		// a nie jedną dizesiątą sekundy
+		LocalTime czas5 = LocalTime.of(12, 15, 33, 1);
+		System.out.println(czas5);
+	}
+}

src/main/java/gotowe/p35_daty/PrzykladInstant.java

+package gotowe.p35_daty;
+
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+public class PrzykladInstant {
+
+	public static void main(String[] args) {
+		Instant czas = Instant.now();
+		System.out.println(czas);
+		
+		ZonedDateTime uNas = czas.atZone(ZoneId.systemDefault());
+		System.out.println(uNas);
+		
+		ZonedDateTime zoned = ZonedDateTime.now();
+		System.out.println(zoned);
+	}
+
+}

src/main/java/gotowe/p35_daty/StareFormatowanieDat.java

+package gotowe.p35_daty;
+
+import java.text.DateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+
+	public class StareFormatowanieDat {
+
+		public static void display(Date date, Locale locale) {
+			DateFormat df;
+
+			df = DateFormat.getDateInstance(DateFormat.DEFAULT, locale);
+			System.out.println("Date DEFAULT: " + df.format(date));
+
+			df = DateFormat.getDateInstance(DateFormat.FULL, locale);
+			System.out.println("Date FULL: " + df.format(date));
+
+			df = DateFormat.getDateInstance(DateFormat.LONG, locale);
+			System.out.println("Date LONG: " + df.format(date));
+
+			df = DateFormat.getDateInstance(DateFormat.MEDIUM, locale);
+			System.out.println("Date MEDIUM: " + df.format(date));
+
+			df = DateFormat.getDateInstance(DateFormat.SHORT, locale);
+			System.out.println("Date SHORT: " + df.format(date));
+
+			df = DateFormat.getTimeInstance(DateFormat.DEFAULT, locale);
+			System.out.println("Time DEFAULT: " + df.format(date));
+
+			df = DateFormat.getTimeInstance(DateFormat.FULL, locale);
+			System.out.println("Time FULL: " + df.format(date));
+
+			df = DateFormat.getTimeInstance(DateFormat.LONG, locale);
+			System.out.println("Time LONG: " + df.format(date));
+
+			df = DateFormat.getTimeInstance(DateFormat.MEDIUM, locale);
+			System.out.println("Time MEDIUM: " + df.format(date));
+
+			df = DateFormat.getTimeInstance(DateFormat.SHORT, locale);
+			System.out.println("Time SHORT: " + df.format(date));
+
+			//Tu już tylko przykładowo
+			df = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, locale);
+			System.out.println("DateTime DEFAULT DEFAULT: " + df.format(date));
+
+			df = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.SHORT, locale);
+			System.out.println("DateTime LONG SHORT: " + df.format(date));
+
+		}
+
+		public static void main(String[] args) {
+			Locale[] all = {
+				new Locale("pl", "PL"),
+				new Locale("pl"),
+				new Locale("de", "DE"),
+				new Locale("fr", "FR"),
+				new Locale("ru", "RU"),
+				new Locale("es", "ES"),
+				new Locale("it", "IT"),
+				new Locale("ja", "JP"),
+				new Locale("ar", "EY"),
+				new Locale("en", "GB"),
+				new Locale("en", "US"),
+				new Locale("en") };
+
+			Date now = Calendar.getInstance().getTime();
+
+			DateFormat df = DateFormat.getInstance();
+			System.out.println("domyślnie: " + df.format(now));
+
+			for (Locale locale : all) {
+				System.out.println("Dla locali " + locale.toString());
+				display(now, locale);
+				System.out.println();
+			}
+		}
+
+	}

src/main/java/gotowe/p35_daty/WypiszDostepneLocale.java

+package gotowe.p35_daty;
+
+import java.text.DateFormat;
+import java.util.Locale;
+import java.util.Locale.Category;
+
+public class WypiszDostepneLocale {
+
+	public static void main(String[] args) {
+		System.out.println("DEFAULT: "+Locale.getDefault());
+		System.out.println("DISPLAY: "+Locale.getDefault(Category.DISPLAY));
+		System.out.println("FORMAT: "+Locale.getDefault(Category.FORMAT));
+		
+        for (Locale loc : DateFormat.getAvailableLocales()) {
+            System.out.println(loc.toString() + " " + loc.getDisplayLanguage() + "/" + loc.getDisplayCountry() );
+        }
+	}
+}

src/main/java/gotowe/p36_lokalizacja/EnumerateBundle.java

+package gotowe.p36_lokalizacja;
+
+import java.util.Enumeration;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+public class EnumerateBundle {
+
+	public static void main(String[] args) {
+		Locale actualLocale;
+
+		if (args.length == 2) {
+			String language = args[0];
+			String country = args[1];
+			actualLocale = new Locale(language, country);
+		} else {
+			actualLocale = Locale.getDefault();
+		}
+		ResourceBundle messages = ResourceBundle.getBundle("pakiet.NaszBundle", actualLocale);
+
+		Enumeration<String> bundleKeys = messages.getKeys();
+		while (bundleKeys.hasMoreElements()) {
+		    String key = (String)bundleKeys.nextElement();
+		    String value = messages.getString(key);
+		    System.out.println("key = " + key + ", " + "value = " + value);
+		}
+	}
+}

src/main/java/gotowe/p36_lokalizacja/HelloFixed.java

+package gotowe.p36_lokalizacja;
+
+public class HelloFixed {
+
+	public static void main(String[] args) {
+		System.out.println("Hello.");
+        System.out.println("How are you?");
+        System.out.println("Goodbye.");
+	}
+}

src/main/java/gotowe/p36_lokalizacja/HelloInternational.java

+package gotowe.p36_lokalizacja;
+
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+public class HelloInternational {
+
+	public static void main(String[] args) {
+		Locale actualLocale;
+
+		if (args.length == 2) {
+			String language = args[0];
+			String country = args[1];
+			actualLocale = Locale.of(language, country);
+		} else {
+			actualLocale = Locale.getDefault();
+		}
+		System.out.println("Używam locali "+actualLocale);
+
+		ResourceBundle messages = ResourceBundle.getBundle("gotowe.p36_lokalizacja.tlumaczenia.NaszBundle", actualLocale);
+		System.out.println("Klasa bundla "+messages.getClass().getName());
+
+		System.out.println(messages.getString("greetings"));
+		System.out.println(messages.getObject("inquiry"));
+		System.out.println(messages.getString("farewell"));
+
+		Object obiekt = messages.getObject("liczba");
+		// Object obiekt = messages.getString("liczba"); // wyjatek
+
+		System.out.println("Klasa "+obiekt.getClass() + " " + obiekt);
+
+		System.out.println(Arrays.toString(messages.getStringArray("tablica")));
+	}
+}

src/main/java/gotowe/p36_lokalizacja/PrintAvailableLocale.java

+package gotowe.p36_lokalizacja;
+
+import java.text.DateFormat;
+import java.util.Locale;
+import java.util.Locale.Category;
+
+public class PrintAvailableLocale {
+
+	public static void main(String[] args) {
+		System.out.println("DEFAULT: "+Locale.getDefault());
+		System.out.println("DISPLAY: "+Locale.getDefault(Category.DISPLAY));
+		System.out.println("FORMAT: "+Locale.getDefault(Category.FORMAT));
+		
+        for (Locale loc : DateFormat.getAvailableLocales()) {
+            System.out.println(loc.toString() + " " + loc.getDisplayLanguage() + "/" + loc.getDisplayCountry() );
+        }
+	}
+}

src/main/java/gotowe/p36_lokalizacja/SetDefault.java

+package gotowe.p36_lokalizacja;
+
+import java.text.DateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+
+public class SetDefault {
+
+	public static void main(String[] args) {
+		Date now = Calendar.getInstance().getTime();
+		
+		System.out.println(Locale.getDefault());
+		DateFormat df1 = DateFormat.getDateInstance(DateFormat.FULL);
+		System.out.println(df1.format(now));
+		
+		Locale.setDefault(Locale.CANADA_FRENCH);
+		System.out.println(Locale.getDefault());
+		System.out.println("Nowy formatter:");
+		DateFormat df2 = DateFormat.getDateInstance(DateFormat.FULL);
+		System.out.println(df2.format(now));
+
+		System.out.println("Formatuje starym formatterem:");
+		System.out.println(df1.format(now));
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/SetDefault2.java

+package gotowe.p36_lokalizacja;
+
+import java.text.DateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+import java.util.Locale.Category;
+
+public class SetDefault2 {
+
+	public static void main(String[] args) {
+		Date now = Calendar.getInstance().getTime();
+		
+		System.out.println(Locale.getDefault());
+		DateFormat df1 = DateFormat.getDateInstance(DateFormat.FULL);
+		System.out.println(df1.format(now));
+		
+		//Locale.setDefault(Category.FORMAT, Locale.US);
+		Locale.setDefault(Category.FORMAT, Locale.CANADA_FRENCH);
+		Locale.setDefault(Category.DISPLAY, Locale.US);
+		System.out.println(Locale.getDefault());
+		DateFormat df2 = DateFormat.getDateInstance(DateFormat.FULL);
+		System.out.println(df2.format(now));
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/UseLocale1.java

+package gotowe.p36_lokalizacja;
+
+import java.text.DateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+
+// pl_PL en_US
+
+public class UseLocale1 {
+
+	public static void main(String[] args) {
+		Locale polski = new Locale("pl");
+		Locale brytyjski = new Locale("en", "GB");
+		Locale amerykański = new Locale("en", "US");
+		Locale techniczny = new Locale("en", "US", "UTF8");
+		
+		DateFormat df = DateFormat.getDateInstance(DateFormat.FULL);
+		DateFormat dfPL = DateFormat.getDateInstance(DateFormat.FULL, polski);
+		DateFormat dfGB = DateFormat.getDateInstance(DateFormat.FULL, brytyjski);
+		DateFormat dfAM = DateFormat.getDateInstance(DateFormat.FULL, amerykański);
+		
+		Date now = Calendar.getInstance().getTime();
+		
+		System.out.println(df.format(now));
+		System.out.println(dfPL.format(now));
+		System.out.println(dfGB.format(now));
+		System.out.println(dfAM.format(now));
+	}
+}

src/main/java/gotowe/p36_lokalizacja/UseLocale2.java

+package gotowe.p36_lokalizacja;
+
+import java.text.DateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+
+public class UseLocale2 {
+
+	public static void main(String[] args) {
+		Locale polski = new Locale("pl");
+		Locale brytyjski = Locale.UK;
+		Locale amerykański = Locale.US;
+		
+		DateFormat dfPL = DateFormat.getDateInstance(DateFormat.FULL, polski);
+		DateFormat dfGB = DateFormat.getDateInstance(DateFormat.FULL, brytyjski);
+		DateFormat dfAM = DateFormat.getDateInstance(DateFormat.FULL, amerykański);
+		DateFormat dfJP = DateFormat.getDateInstance(DateFormat.FULL, Locale.JAPAN);
+		
+		Date now = Calendar.getInstance().getTime();
+		
+		System.out.println(dfPL.format(now));
+		System.out.println(dfGB.format(now));
+		System.out.println(dfAM.format(now));
+		System.out.println(dfJP.format(now));
+		
+		System.out.println(Locale.JAPAN);
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/UseLocale3_Builder.java

+package gotowe.p36_lokalizacja;
+
+import java.text.DateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+
+public class UseLocale3_Builder {
+
+	public static void main(String[] args) {
+		Locale polski1 = new Locale.Builder().setLanguage("pl").build();
+		Locale.Builder builder = new Locale.Builder();
+		
+		builder.setLanguage("pl");
+		Locale polski = builder.build();
+
+		builder.clear();
+		builder.setLanguage("ru").setRegion("RU").setScript("Cyrl");
+		Locale rosyjski = builder.build();
+		
+		DateFormat dfPL = DateFormat.getDateInstance(DateFormat.FULL, polski);
+		DateFormat dfRU = DateFormat.getDateInstance(DateFormat.FULL, rosyjski);
+		
+		Date now = Calendar.getInstance().getTime();
+		
+		System.out.println(dfPL.format(now));
+		System.out.println(dfRU.format(now));
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/formatowanie/ParsowanieDat.java

+package gotowe.p36_lokalizacja.formatowanie;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class ParsowanieDat {
+
+	public static void main(String[] args) {
+			System.out.println("Wlasne wzorce");
+			//DateFormat f = DateFormat.getDateInstance(DateFormat.SHORT);
+			
+			//DateFormat f = new SimpleDateFormat("HH:mm");
+			DateFormat f = new SimpleDateFormat("HH:mm:ss z");
+			Date now = new Date();
+			
+		try {
+			System.out.println("Wypisuje "+f.format(now));
+			//Date data = f.parse("15.03.09");
+			Date data = f.parse("20:12:13 GMT śmieci potem");
+			System.out.println("Wczytana "+data);
+		} catch (ParseException e) {
+			System.err.println("Wyjatek 1 "+e.getMessage());
+		}
+
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/formatowanie/PredefinedFormats_Date.java

+package gotowe.p36_lokalizacja.formatowanie;
+
+import java.text.DateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+
+public class PredefinedFormats_Date {
+
+	public static void display(Date date, Locale locale) {
+		DateFormat df;
+
+		df = DateFormat.getDateInstance(DateFormat.DEFAULT, locale);
+		System.out.println("Date DEFAULT: " + df.format(date));
+
+		df = DateFormat.getDateInstance(DateFormat.FULL, locale);
+		System.out.println("Date FULL: " + df.format(date));
+
+		df = DateFormat.getDateInstance(DateFormat.LONG, locale);
+		System.out.println("Date LONG: " + df.format(date));
+
+		df = DateFormat.getDateInstance(DateFormat.MEDIUM, locale);
+		System.out.println("Date MEDIUM: " + df.format(date));
+
+		df = DateFormat.getDateInstance(DateFormat.SHORT, locale);
+		System.out.println("Date SHORT: " + df.format(date));
+
+		df = DateFormat.getTimeInstance(DateFormat.DEFAULT, locale);
+		System.out.println("Time DEFAULT: " + df.format(date));
+
+		df = DateFormat.getTimeInstance(DateFormat.FULL, locale);
+		System.out.println("Time FULL: " + df.format(date));
+
+		df = DateFormat.getTimeInstance(DateFormat.LONG, locale);
+		System.out.println("Time LONG: " + df.format(date));
+
+		df = DateFormat.getTimeInstance(DateFormat.MEDIUM, locale);
+		System.out.println("Time MEDIUM: " + df.format(date));
+
+		df = DateFormat.getTimeInstance(DateFormat.SHORT, locale);
+		System.out.println("Time SHORT: " + df.format(date));
+
+		//Tu już tylko przykładowo
+		df = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, locale);
+		System.out.println("DateTime DEFAULT DEFAULT: " + df.format(date));
+
+		df = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.SHORT, locale);
+		System.out.println("DateTime LONG SHORT: " + df.format(date));
+
+	}
+
+	public static void main(String[] args) {
+		Locale[] all = {
+			new Locale("pl", "PL"),
+			new Locale("pl"),
+			new Locale("de", "DE"),
+			new Locale("fr", "FR"),
+			new Locale("ru", "RU"),
+			new Locale("es", "ES"),
+			new Locale("it", "IT"),
+			new Locale("ja", "JP"),
+			new Locale("ar", "EY"),
+			new Locale("en", "GB"),
+			new Locale("en", "US"),
+			new Locale("en") };
+
+		Date now = Calendar.getInstance().getTime();
+
+		DateFormat df = DateFormat.getInstance();
+		System.out.println("domyślnie: " + df.format(now));
+
+		for (Locale locale : all) {
+			System.out.println("Dla locali " + locale.toString());
+			display(now, locale);
+			System.out.println();
+		}
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/formatowanie/PredefinedFormats_Number.java

+package gotowe.p36_lokalizacja.formatowanie;
+
+import java.text.NumberFormat;
+import java.util.Locale;
+
+public class PredefinedFormats_Number {
+
+	public static void displayNumbers(Locale locale) {
+		Integer i = new Integer(123456);
+		Double d = new Double(1654.32173645263);
+
+		//NumberFormat nf = NumberFormat.getNumberInstance(locale);
+		NumberFormat nf = NumberFormat.getInstance(locale);
+		//nf.setMaximumFractionDigits(6);
+		System.out.println(nf.format(i));
+		System.out.println(nf.format(d));
+	}
+
+	public static void displayPercent(Locale locale) {
+		Integer i = new Integer(13);
+		Double d = new Double(0.7533);
+
+		NumberFormat nf = NumberFormat.getPercentInstance(locale);
+		System.out.println(nf.format(i));
+		System.out.println(nf.format(d));
+	}
+
+	public static void displayCurrencies(Locale locale) {
+		Double d = new Double(2200.90);
+
+		NumberFormat nf = NumberFormat.getCurrencyInstance(locale);
+		System.out.println(nf.format(d));
+	}
+
+	public static void main(String[] args) {
+		Locale[] all = {
+			new Locale("pl", "PL"),
+			new Locale("pl"),
+			new Locale("de", "DE"),
+			new Locale("fr", "FR"),
+			new Locale("en", "GB"),
+			new Locale("en", "US"),
+			new Locale("en") };
+
+		for (Locale locale : all) {
+			System.out.println("Dla locali " + locale.toString());
+			displayNumbers(locale);
+			displayPercent(locale);
+			displayCurrencies(locale);
+			System.out.println();
+		}
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/formatowanie/Printf.java

+package gotowe.p36_lokalizacja.formatowanie;
+
+import java.io.File;
+import java.util.Locale;
+
+public class Printf {
+
+	public static void main(String[] args) {
+		
+		System.out.println(Locale.getDefault());
+		int x = 7, y = 13;
+		double f = 112233.456;
+		String s = "Ala ma kota";
+		Object o = new File("plik.txt");
+		
+		System.out.printf("Dwa inty: %d %d, float: %f %f, stringi: %s %s%n",
+				x, y, f, Math.PI, s, o);
+
+		System.out.printf(new Locale("en", "US"), "Dwa inty: %d %d, float: %f %f, stringi: %s %s%n",
+				x, y, f, Math.PI, s, o);
+
+		System.out.printf("Dwa inty: %03d %-5d, float: %+,1.3f %1.20f, stringi: %s %s%n",
+				x, y, f, Math.PI, s, o);
+		
+		System.out.printf("%1$f %1$20.10f%n", Math.PI);
+
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/formatowanie/TestDateFormat.java

+package gotowe.p36_lokalizacja.formatowanie;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class TestDateFormat {
+
+	public static void main(String[] args) {
+		Date now = new Date();
+		
+		SimpleDateFormat f = new SimpleDateFormat();
+		System.out.println(f.format(now));
+
+		f.applyPattern("dd.MM.yyyy");
+		System.out.println(f.format(now));
+		
+
+		f.applyPattern("d MMM , H:mm");
+		System.out.println(f.format(now));
+
+		f.applyLocalizedPattern("dd.MM.yyyy");
+		System.out.println(f.format(now));
+
+		SimpleDateFormat f2 = new SimpleDateFormat("dd MMMM");
+		System.out.println(f2.format(now));
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/formatowanie/TestDecimalFormat.java

+package gotowe.p36_lokalizacja.formatowanie;
+
+import java.text.DecimalFormat;
+
+public class TestDecimalFormat {
+
+	public static void main(String[] args) {
+		double number = 123456.45;
+		DecimalFormat df1 = new DecimalFormat();
+		
+		//df1.setDecimalFormatSymbols(DecimalFormatSymbols.getInstance(new Locale("pl")));
+		System.out.println(df1.format(number));
+
+		df1.applyPattern("00000.000");
+		System.out.println(df1.format(number));
+
+		df1.applyLocalizedPattern("00000,000");
+		System.out.println(df1.format(number));
+
+		df1.applyPattern("#.0#");
+		System.out.println(df1.format(number));
+		
+		DecimalFormat df2 = new DecimalFormat("##,##.#");
+		System.out.println(df2.format(number));
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/formatowanie/TestDecimalFormat2.java

+package gotowe.p36_lokalizacja.formatowanie;
+
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.util.Locale;
+
+public class TestDecimalFormat2 {
+
+	public static void main(String[] args) {
+		Locale locale = new Locale("de", "DE");
+		double number = 1246.36;
+		DecimalFormat df = (DecimalFormat) NumberFormat.getInstance(locale); 
+		System.out.println(df.format(number));
+
+		df.applyPattern("0.0E00");
+		System.out.println(df.format(number));
+
+		df.applyLocalizedPattern("0,0##E0");
+		System.out.println(df.format(number));
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/formatowanie/Waluty.java

+package gotowe.p36_lokalizacja.formatowanie;
+
+import java.util.Currency;
+import java.util.Locale;
+
+public class Waluty {
+
+	public static void currencyInfo(Locale locale) {
+		Currency currency = Currency.getInstance(locale);
+		System.out.println("code: "
+				+ currency.getCurrencyCode());
+		System.out.println("symbol: "
+				+ currency.getSymbol());
+		System.out.println("displayName: "
+				+ currency.getDisplayName());
+	}
+
+
+	public static void main(String[] args) {
+		Locale[] all = {
+			new Locale("pl", "PL"),
+			new Locale("de", "DE"),
+			new Locale("fr", "FR"),
+			new Locale("en", "GB"),
+			new Locale("en", "US"),
+			//new Locale("en"),
+		};
+
+		for (Locale locale : all) {
+			System.out.println("Dla locali " + locale.toString());
+			currencyInfo(locale);
+			System.out.println();
+		}
+	}
+
+}

src/main/java/gotowe/p36_lokalizacja/tlumaczenia/NaszBundle.properties

+greetings=Hello\!
+inquiry=How are you?
+farewell=See you\!
\ No newline at end of file

src/main/java/gotowe/p36_lokalizacja/tlumaczenia/NaszBundle_cz.properties

+greetings=Ahoj!
+inquiry=Jak se m\u00E1\u0161?
+farewell=Sbohem
\ No newline at end of file

src/main/java/gotowe/p36_lokalizacja/tlumaczenia/NaszBundle_pl.properties

+greetings=Cze\u015B\u0107!
+inquiry=Jak si\u0119 dzi\u015B czujesz?
+farewell=Na razie.
\ No newline at end of file

src/main/java/gotowe/p36_lokalizacja/tlumaczenia/NaszBundle_pl_PL.java

+package gotowe.p36_lokalizacja.tlumaczenia;
+
+import java.util.ListResourceBundle;
+
+
+public class NaszBundle_pl_PL extends ListResourceBundle {
+	// ma zwracać tablicę dwuelementowych tablic: klucz - wartość
+    public Object[][] getContents() {
+    	System.out.println("sie laduje");
+        return contents;
+    }
+
+    private Object[][] contents = {
+        { "greetings", "Siema" },
+        { "farewell", "Papa" },
+        { "liczba", new Integer(17) },
+        { "tablica", new String [] {"Siema", "Czesc", "Ble"} },
+    };
+}
\ No newline at end of file

src/main/java/gotowe/p36_lokalizacja/tlumaczenia/NaszBundle_pl_PL.properties

+farewell=Heja.
+greetings=Jeden
\ No newline at end of file

src/main/java/gotowe/p40_io/Czytaj1.java

+package gotowe.p40_io;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+/*
+  InputStream - ogólna klasa opisująca "jakieś" źródło danych, np. plik, albo połączenie sieciowe itd.
+  FileInputStream - konkretnie otwarty plik 
+ */
+
+public class Czytaj1 {
+
+	public static void main(String[] args) {
+		try {
+			//FileInputStream in = new FileInputStream("pliki/plik.txt");
+			InputStream in = new FileInputStream("pliki/plik.txt");
+			System.out.println("Kolejne bajty:");
+			while(true) {
+				int bajt = in.read(); // wynik od 0 do 255: normalne dane, -1: koniec wejścia
+				if(bajt == -1)
+					break;
+				System.out.println(bajt);
+			}
+			System.out.println("Koniec");
+			in.close();
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/gotowe/p40_io/Czytaj2.java

+package gotowe.p40_io;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+
+public class Czytaj2 {
+	// Zazwyczaj dane czyta się większymi porcjami - żeby było szybciej
+
+	public static void main(String[] args) {
+		try {
+			InputStream in = new FileInputStream("pliki/plik.txt");
+			
+			byte[] bufor = new byte[128];
+			while(true) {
+				
+				int ile = in.read(bufor);
+				if(ile == -1)
+					break;
+				System.out.println("Kolejna porcja: (" + ile + ") : "
+						+ Arrays.toString(bufor));
+			}
+			
+			in.close();
+		} catch (IOException e) {  // to tez lapie FileNotFoundException
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/gotowe/p40_io/Czytaj3.java

+package gotowe.p40_io;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+
+public class Czytaj3 {
+	// Zazwyczaj dane czyta się większymi porcjami - żeby było szybciej
+
+	public static void main(String[] args) {
+		// "try-with-resources" - konstrukcja automatycznego zamykania zasobów dostępna od Javy 7
+		try(InputStream in = new FileInputStream("pliki/plik.txt")) {
+			
+			byte[] bufor = new byte[128];
+			while(true) {
+				
+				int ile = in.read(bufor);
+				if(ile == -1)
+					break;
+				System.out.println("Kolejna porcja: (" + ile + ") : "
+						+ Arrays.toString(bufor));
+			}
+		} catch (IOException e) {  // to tez lapie FileNotFoundException
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/gotowe/p40_io/Download_HttpClient.java

+package gotowe.p40_io;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+
+public class Download_HttpClient {
+
+    public static void main(String[] args) {
+        final String ADRES = "http://api.nbp.pl/api/exchangerates/tables/a/";
+
+        try {
+            System.out.println("Startujemy...");
+            URI uri = new URI(ADRES);
+            HttpClient httpClient = HttpClient.newHttpClient();
+            System.out.println("Mam klienta: " + httpClient);
+            System.out.println("Wysyłam zapytanie...");
+            HttpRequest request = HttpRequest.newBuilder(uri).build();
+            HttpResponse<String> response = httpClient.send(request, BodyHandlers.ofString());
+            System.out.println("Mam odpowiedź: " + response);
+            System.out.println("Kod: " + response.statusCode());
+            System.out.println("Content-Type: " + response.headers().firstValue("Content-Type").orElse("--nieokreślony--"));
+            String body = response.body();
+            System.out.println("Rozmiar treści: " + body.length());
+            System.out.println(body.substring(0, 80));
+            System.out.println("Gotowe.");
+        } catch(Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/main/java/gotowe/p40_io/Download_URL.java

+package gotowe.p40_io;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+
+public class Download_URL {
+
+	public static void main(String[] args) {
+		try {
+			URL url = new URL("http://api.nbp.pl/api/exchangerates/tables/A/");
+			try(InputStream wejscie = url.openStream()) {
+				Path wyjscie = Paths.get("kursy.json");
+				Files.copy(wejscie, wyjscie, StandardCopyOption.REPLACE_EXISTING);
+				System.out.println("Gotowe");
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/gotowe/p40_io/InputStream_DodatkoweMetody.java

+package gotowe.p40_io;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class InputStream_DodatkoweMetody {
+
+	public static void main(String[] args) {
+		try {
+			FileInputStream in = new FileInputStream("plik.txt");
+			//FileInputStream in = new FileInputStream("pan-tadeusz.txt");
+			
+			// Zwykły FileInputStream nie wspiera markowania
+			System.out.println("markSupported: " + in.markSupported());
+			
+			int available = in.available();
+			System.out.println("available: " + available);
+			
+			long skip = in.skip(12);
+			System.out.println("skip: " + skip);
+			System.out.println("available: " + in.available());
+			
+			byte[] bajty = new byte[100];
+			int ile = in.read(bajty);
+			System.out.println("read: " + ile);
+			
+			String tekst = new String(bajty, 0, ile);
+			System.out.println("tekst: " + tekst);
+			System.out.println("available: " + in.available());
+						
+			in.close();
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/gotowe/p40_io/InputStream_Markowanie.java

+package gotowe.p40_io;
+
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class InputStream_Markowanie {
+
+	public static void main(String[] args) {
+		try {
+			FileInputStream in = new FileInputStream("plik.txt");
+			//FileInputStream in = new FileInputStream("pan-tadeusz.txt");
+			
+			// Zwykły FileInputStream nie wspiera markowania
+			System.out.println("1 markSupported: " + in.markSupported());
+			
+			// BufferedInputStream jest przykładem klasy opakowującej inne strumienie
+			BufferedInputStream bin = new BufferedInputStream(in);
+			System.out.println("1 markSupported: " + bin.markSupported());
+			System.out.println();
+			
+			byte[] bajty = new byte[100];
+			
+			System.out.println("Wczytuję 4 pierwsze bajty");
+			// od pozycji 0 w tablicy wstaw do niej maksymalnie 4 bajty
+			bin.read(bajty, 0, 4);
+			System.out.println(new String(bajty, 0, 4));
+			
+			System.out.println("\nmarkuję to miejsce");
+			bin.mark(10); // 10 oznacza, że mogę pójść 10 bajtów do przodu, a potem się cofnąć
+			
+			System.out.println("Wczytuję 7 kolejnych bajtów");
+			bin.read(bajty, 0, 7);
+			System.out.println(new String(bajty, 0, 7));
+			
+			System.out.println("\nreset! - czyli cofam się w miejsce zamarkowane");
+			bin.reset();
+			
+			System.out.println("Wczytuję plik do końca:");
+			bin.read(bajty);
+			System.out.println(new String(bajty, 0, 7));
+			
+			System.out.println("\nKoniec...");
+						
+			in.close();
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/gotowe/p40_io/Kopiuj1.java

+package gotowe.p40_io;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class Kopiuj1 {
+	
+	public static void kopiuj(String wejscie, String wyjscie) {
+		InputStream is = null;
+		OutputStream os = null;
+
+		try {
+			 is = new FileInputStream(wejscie);
+			 os = new FileOutputStream(wyjscie);
+			 
+			 int licznik = 0;
+			 int bajt;	 
+			 while((bajt = is.read()) != -1) {
+				 os.write(bajt);
+				 //System.out.println(bajt);
+				 licznik ++;
+			 }
+			System.out.println(licznik);
+		} catch (FileNotFoundException e) {
+			System.out.println("Plik nie znaleziony "+e.getMessage());
+		} catch (IOException e) {
+			System.out.println("Błąd wej/wyj "+e.getMessage());
+		} finally {
+			if(is != null)
+				try { is.close(); } catch (IOException e) {	System.err.println(e.getMessage());}
+			if(os != null)
+				try { os.close(); } catch (IOException e) { System.err.println(e.getMessage()); }
+		}
+	}
+
+	public static void main(String[] args) {
+
+		long start = System.currentTimeMillis();
+		kopiuj("pliki/pan_tadeusz.txt", "kopia1.txt");
+		long koniec = System.currentTimeMillis();
+		
+		System.out.println("Koniec kopiowania, czas " + (koniec - start));
+	}
+}

src/main/java/gotowe/p40_io/Kopiuj2.java

+package gotowe.p40_io;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class Kopiuj2 {
+	private static final int ROZMIAR = 4096;
+	
+	public static void kopiuj(String wejscie, String wyjscie) {
+		// try-with-resources - dostepne od Javy 7
+		// Closable
+		try(FileInputStream is = new FileInputStream(wejscie);
+			FileOutputStream os = new FileOutputStream(wyjscie)) {
+			
+			 byte[] bufor = new byte[ROZMIAR];
+			 //Arrays.fill(bufor, (byte)'x');
+			 int licznik = 0;
+			 int ile;
+			 while((ile = is.read(bufor)) != -1) {
+				 System.out.println("Wczytałem "+ile+" bajtów");
+				 os.write(bufor, 0, ile);
+				 licznik += ile;
+				 // os.flush(); - popchanie danych do pliku
+			 }
+			 
+			 System.out.println("licznik = " + licznik);
+		} catch (FileNotFoundException e) {
+			System.out.println("Plik nie znaleziony "+e.getMessage());
+		} catch (IOException e) {
+			System.out.println("Błąd wej/wyj "+e.getMessage());
+		}
+	}
+	
+
+	public static void main(String[] args) {
+		long start = System.currentTimeMillis();
+		kopiuj("pliki/pan_tadeusz.txt", "kopia2.txt");
+		long koniec = System.currentTimeMillis();
+		
+		System.out.println("Koniec kopiowania, czas " + (koniec - start));
+	}
+}

src/main/java/gotowe/p40_io/Kopiuj3.java

+package gotowe.p40_io;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+
+public class Kopiuj3 {
+	
+	public static void kopiuj(String wejscie, String wyjscie) {
+		try(Reader is = new FileReader(wejscie);
+			Writer os = new FileWriter(wyjscie)) {
+			 
+			 int licznik = 0;
+			 int znak;
+			 while((znak = is.read()) != -1) {
+				 os.write(znak);
+				 //System.out.println(znak);
+				 licznik ++;
+			 }
+			System.out.println(licznik);
+			
+		} catch (FileNotFoundException e) {
+			System.out.println("Plik nie znaleziony "+e.getMessage());
+		} catch (IOException e) {
+			System.out.println("Błąd wej/wyj "+e.getMessage());
+		}
+	}
+	
+
+	public static void main(String[] args) {
+		kopiuj("pliki/pan_tadeusz.txt", "kopia3.txt");
+		
+		System.out.println("Koniec kopiowania");
+	}
+
+}

src/main/java/gotowe/p40_io/Kopiuj3_kodowanie.java

+package gotowe.p40_io;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.Writer;
+
+public class Kopiuj3_kodowanie {
+	
+	public static void kopiuj(String wejscie, String wyjscie) {
+		try(FileInputStream fis = new FileInputStream(wejscie);
+			Reader reader = new InputStreamReader(fis, "utf-8");
+			FileOutputStream fos = new FileOutputStream(wyjscie);
+			Writer writer = new OutputStreamWriter(fos, "windows-1250")) {
+			 
+			 int licznik = 0;
+			 int znak;
+			 while((znak = reader.read()) != -1) {
+				 writer.write(znak);
+				 licznik ++;
+			 }
+			System.out.println(licznik);
+			
+		} catch (FileNotFoundException e) {
+			System.out.println("Plik nie znaleziony "+e.getMessage());
+		} catch (IOException e) {
+			System.out.println("Błąd wej/wyj "+e.getMessage());
+		}
+		
+	}
+	
+
+	public static void main(String[] args) {
+		kopiuj("pliki/pan_tadeusz.txt", "wynik_win.txt");
+		
+		System.out.println("Koniec kopiowania");
+	}
+
+}

src/main/java/gotowe/p40_io/Kopiuj4.java

+package gotowe.p40_io;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+
+public class Kopiuj4 {
+	private static final int ROZMIAR = 2048;
+
+	public static void kopiuj(String wejscie, String wyjscie) {
+		try(Reader is = new FileReader(wejscie);
+			Writer os = new FileWriter(wyjscie)) {
+			 
+			 char[] bufor = new char[ROZMIAR];
+			 int ile;
+			 
+			 while((ile = is.read(bufor)) != -1) {
+				 os.write(bufor, 0, ile);
+				 
+				 //System.out.println("Ile = "+ile);
+				 
+				 //String napis = new String(bufor);
+				 //System.out.println("Napis = "+ napis);
+			 }
+			
+		} catch (FileNotFoundException e) {
+			System.out.println("Plik nie znaleziony "+e.getMessage());
+		} catch (IOException e) {
+			System.out.println("Błąd wej/wyj "+e.getMessage());
+		}
+		
+	}
+	
+
+	public static void main(String[] args) {
+		kopiuj("pliki/pan_tadeusz.txt", "wynik.txt");
+		
+		System.out.println("Koniec kopiowania");
+	}
+
+}

src/main/java/gotowe/p40_io/Upper3.java

+package gotowe.p40_io;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+
+public class Upper3 {
+	
+	public static void kopiuj(String wejscie, String wyjscie) {
+		try(Reader is = new FileReader(wejscie);
+			Writer os = new FileWriter(wyjscie)) {
+			 
+			 int znak;
+			 while((znak = is.read()) != -1) {
+				 //znak = Character.toLowerCase(znak);
+				 znak = Character.toUpperCase(znak);
+				 os.write(znak);
+			 }
+			
+		} catch (FileNotFoundException e) {
+			System.out.println("Plik nie znaleziony "+e.getMessage());
+		} catch (IOException e) {
+			System.out.println("Błąd wej/wyj "+e.getMessage());
+		}
+		
+	}
+	
+
+	public static void main(String[] args) {
+		kopiuj("pliki/pan_tadeusz.txt", "wynik_upper.txt");
+		
+		System.out.println("Koniec kopiowania");
+	}
+
+}

src/main/java/gotowe/p40_io/Upper4.java

+package gotowe.p40_io;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class Upper4 {
+	private static final int ROZMIAR = 4096;
+
+	public static void kopiuj(String wejscie, String wyjscie) {
+		try(FileReader is = new FileReader(wejscie);
+			FileWriter os = new FileWriter(wyjscie)) {
+			 
+			 char[] bufor = new char[ROZMIAR];
+			 int ile;
+			 
+			 while((ile = is.read(bufor)) != -1) {
+				 String napis = new String(bufor, 0, ile);
+				 os.write(napis.toLowerCase());
+			 }
+			
+		} catch (FileNotFoundException e) {
+			System.out.println("Plik nie znaleziony "+e.getMessage());
+		} catch (IOException e) {
+			System.out.println("Błąd wej/wyj "+e.getMessage());
+		}
+	}
+	
+
+	public static void main(String[] args) {
+		kopiuj("pliki/pan_tadeusz.txt", "wynik_lower.txt");
+		System.out.println("Koniec kopiowania");
+	}
+}

src/main/java/gotowe/p40_io/WierszPoWierszu.java

+package gotowe.p40_io;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class WierszPoWierszu {
+	public static void wypisz(String wejscie) {
+		try(BufferedReader br = new BufferedReader(new FileReader(wejscie))) {
+			 String napis;
+			 int licznik = 1;
+			 while((napis = br.readLine()) != null) {
+				 System.out.printf("%5d : ", licznik);
+				 System.out.println(napis);
+				 licznik++;
+			 }
+		} catch (FileNotFoundException e) {
+			System.out.println("Plik nie znaleziony "+e.getMessage());
+		} catch (IOException e) {
+			System.out.println("Błąd wej/wyj "+e.getMessage());
+		}
+	}
+	
+	public static void main(String[] args) {
+		wypisz("pliki/pan_tadeusz.txt");
+	}
+}

src/main/java/gotowe/p40_io/ZapiszJakisPlik1.java

+package gotowe.p40_io;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+ 
+public class ZapiszJakisPlik1 {
+ 
+    public static void main(String[] args) {
+    	System.out.println("Zaczynam");
+        try {
+            PrintWriter out = new PrintWriter("plik1.txt");
+            
+            out.println("Ala ma kota");
+            out.println("Ola ma psa");
+            
+            out.append("pies").append(" kot").append(" chomik").println();
+            
+            System.out.println("Gotowe");
+            
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p40_io/ZapiszJakisPlik1a.java

+package gotowe.p40_io;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+
+public class ZapiszJakisPlik1a {
+ 
+    public static void main(String[] args) {
+    	System.out.println("Zaczynam");
+        try {
+            PrintWriter out = new PrintWriter("plik1a.txt");
+
+            for (int i = 0; i < 10_000; i++) {
+                out.println(i);
+            }
+
+            // nie ma close
+            System.out.println("Gotowe");
+            
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p40_io/ZapiszJakisPlik2.java

+package gotowe.p40_io;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+ 
+public class ZapiszJakisPlik2 {
+ 
+    public static void main(String[] args) {
+    	System.out.println("Zaczynam");
+        try {
+            PrintWriter out = new PrintWriter("plik2.txt");
+            
+            out.println("Ala ma kota");
+            out.println("Ola ma psa");
+            
+            out.append("pies").append(" kot").append(" chomik").println();
+            
+            out.close();
+            System.out.println("Gotowe");
+            
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p40_io/ZapiszJakisPlik3.java

+package gotowe.p40_io;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.time.LocalTime;
+ 
+public class ZapiszJakisPlik3 {
+ 
+    public static void main(String[] args) {
+    	System.out.println("Zaczynam");
+        try {
+            PrintWriter out = new PrintWriter("plik3.txt");
+            out.println("Ala ma kota");
+			out.flush();
+
+            out.println("Ola ma psa");
+
+            int sekunda = LocalTime.now().getSecond();
+            out.println("Sekunda: " + sekunda);
+            int x = 60 / (sekunda % 2);
+            
+            out.append("pies").append(" kot").append(" chomik").println();
+            
+            out.close();
+            System.out.println("Gotowe");
+            
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p40_io/ZapiszJakisPlik4.java

+package gotowe.p40_io;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.time.LocalTime;
+
+public class ZapiszJakisPlik4 {
+	// Klasyczne podejście do popawnego zamykania plików - stosowane do Javy 6
+
+	public static void main(String[] args) {
+		PrintWriter out = null;
+		try {
+			out = new PrintWriter("plik4.txt");
+			out.println("Ala ma kota");
+
+            out.println("Ola ma psa");
+
+            int sekunda = LocalTime.now().getSecond();
+            out.println("Sekunda: " + sekunda);
+            int x = 60 / (sekunda % 2);
+
+            out.append("pies").append(" kot").append(" chomik").println();
+
+			System.out.println("Gotowe");
+
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} finally {
+			if (out != null)
+				out.close();
+		}
+	}
+}

src/main/java/gotowe/p40_io/ZapiszJakisPlik5.java

+package gotowe.p40_io;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.time.LocalTime;
+
+//try-with-resources   --- od Java 7
+public class ZapiszJakisPlik5 {
+	public static void main(String[] args) {
+		try (PrintWriter out = new PrintWriter("plik5.txt")) {
+			out.println("Ala ma kota");
+			out.println("Ola ma psa");
+			
+            int sekunda = LocalTime.now().getSecond();
+            out.println("Sekunda: " + sekunda);
+            int x = 60 / (sekunda % 2);
+
+			out.append("pies").append(" kot").append(" chomik").println();
+
+			System.out.println("Gotowe");
+
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+		// nie piszemy już close() - plik zostanie automatycznie zamknity gdy będziemy
+		// opuszczać blok try
+	}
+}

src/main/java/gotowe/p41_file/Absolute.java

+package gotowe.p41_file;
+
+import java.io.File;
+import java.io.IOException;
+
+public class Absolute {
+
+	public static void main(String[] args) {
+
+		String path;
+		if(args.length > 0)
+			path = args[0];
+		else path = "/katalog/../nowy.txt";
+		String path2 = "./a/b/c.zip";
+		
+		File file = new File(path);
+		File file2 = new File(path2);
+		System.out.println("separatory: " + File.pathSeparator + " " +File.separator);
+
+		System.out.println("Argument : "+path);
+		System.out.println("Argument : "+path2);
+		System.out.println("Name     : "+file.getName());
+		System.out.println("Name     : "+file2.getName());
+		System.out.println("Absolute : "+file.getAbsolutePath());
+		System.out.println("Absolute : "+file2.getAbsolutePath());
+		
+		String[] czlony = file.getName().split("\\.");
+		if(czlony.length >= 2)
+			System.out.println(czlony[czlony.length-1]);
+		
+		try {
+			System.out.println("Canonical: "+file.getCanonicalPath());
+			System.out.println("Canonical: "+file2.getCanonicalPath());
+		} catch(IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/gotowe/p41_file/ListFiles.java

+package gotowe.p41_file;
+
+import java.io.File;
+
+public class ListFiles {
+
+	public static void main(String[] args) {
+		String start;
+		if(args.length > 0)
+			start = args[0];
+		else start = ".";
+		
+		File dir = new File(start);
+		listFilesRec(dir, "");
+	}
+	
+	public static void listFilesRec(File dir, String indent) {
+		if(dir.isDirectory()) {
+			String nextIndent = indent + "    ";
+			File[] files = dir.listFiles();
+			if(files != null)
+				for(File file: files) {
+					System.out.print(indent);
+					if(file.isFile()) {
+						System.out.print("F ");
+					} else	if(file.isDirectory()) {
+						System.out.print("D ");
+					} else {
+						System.out.print("S ");
+					}
+					System.out.println(file.getName());
+					listFilesRec(file, nextIndent);
+				}
+		}
+	}
+}

src/main/java/gotowe/p41_file/Modyfikowanie.java

+package gotowe.p41_file;
+
+import java.io.File;
+
+public class Modyfikowanie {
+
+	public static void main(String[] args) {
+		
+		File katalog = new File("nowy_katalog");
+		
+		boolean jest = katalog.exists();
+		System.out.println(jest);
+		if(jest) {
+			System.out.println("Usuwam katalog");
+			katalog.delete();
+		} else {
+			System.out.println("Tworze nowy katalog");
+			katalog.mkdir();
+		}
+		
+	}
+
+}

src/main/java/gotowe/p42_tekstowe/Odczyt1_FileReader.java

+package gotowe.p42_tekstowe;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class Odczyt1_FileReader {
+
+    public static void main(String[] args) {
+        try(FileReader in = new FileReader("pliki/pan_tadeusz.txt")) {
+            char[] porcja = new char[100];
+            int ile;
+            while((ile = in.read(porcja)) != -1) {
+                String tekst = new String(porcja, 0, ile);
+                System.out.println("[" + tekst + "]");
+            }
+
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p42_tekstowe/Odczyt1_FileReader_v1.java

+package gotowe.p42_tekstowe;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class Odczyt1_FileReader_v1 {
+
+    public static void main(String[] args) {
+        try(FileReader in = new FileReader("pliki/pan_tadeusz.txt")) {
+            char[] porcja = new char[100];
+            while(true) {
+                int ile = in.read(porcja);
+                if(ile == -1) break;
+                System.out.print("@ ");
+                System.out.println(porcja);
+            }
+
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p42_tekstowe/Odczyt2_BufferedReader.java

+package gotowe.p42_tekstowe;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class Odczyt2_BufferedReader {
+
+    public static void main(String[] args) {
+        try(FileReader in = new FileReader("pliki/pan_tadeusz.txt");
+            BufferedReader br = new BufferedReader(in)) {
+            String linia;
+            while((linia = br.readLine()) != null) {
+                System.out.println("[" + linia + "]");
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p42_tekstowe/Odczyt3_BufferedReader_Files.java

+package gotowe.p42_tekstowe;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+public class Odczyt3_BufferedReader_Files {
+
+    public static void main(String[] args) {
+        try(BufferedReader br = Files.newBufferedReader(Paths.get("pliki/pan_tadeusz.txt"))) {
+            String linia;
+            while((linia = br.readLine()) != null) {
+                System.out.println("[" + linia + "]");
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p42_tekstowe/Odczyt4_Scanner_Linie.java

+package gotowe.p42_tekstowe;
+
+import java.io.*;
+import java.util.Scanner;
+
+public class Odczyt4_Scanner_Linie {
+
+    public static void main(String[] args) {
+        try(Scanner sc = new Scanner(new File("pliki/pan_tadeusz.txt"))) {
+            while(sc.hasNextLine()) {
+                String linia = sc.nextLine();
+                System.out.println("[" + linia + "]");
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p42_tekstowe/Odczyt5_Scanner_Slowa.java

+package gotowe.p42_tekstowe;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class Odczyt5_Scanner_Slowa {
+
+    public static void main(String[] args) {
+        try(Scanner sc = new Scanner(new File("pliki/pan_tadeusz.txt"))) {
+            sc.useDelimiter("[^\\p{L}\\d]+");
+            while(sc.hasNext()) {
+                String slowo = sc.next();
+                System.out.println("[" + slowo + "]");
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p42_tekstowe/Odczyt5_Scanner_Slowa_v1.java

+package gotowe.p42_tekstowe;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class Odczyt5_Scanner_Slowa_v1 {
+
+    public static void main(String[] args) {
+        try(Scanner sc = new Scanner(new File("pliki/pan_tadeusz.txt"))) {
+            while(sc.hasNext()) {
+                String slowo = sc.next();
+                System.out.println("[" + slowo + "]");
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p42_tekstowe/Odczyt6_AllLines.java

+package gotowe.p42_tekstowe;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+
+public class Odczyt6_AllLines {
+
+    public static void main(String[] args) {
+        try {
+            List<String> lines = Files.readAllLines(Paths.get("pliki/pan_tadeusz.txt"));
+            for (String line : lines) {
+                System.out.println(line);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p42_tekstowe/Odczyt7_Lines.java

+package gotowe.p42_tekstowe;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+
+public class Odczyt7_Lines {
+
+    public static void main(String[] args) {
+        try {
+            Files.lines(Paths.get("pliki/pan_tadeusz.txt"))
+                    .forEachOrdered(line -> System.out.println(line));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/gotowe/p43_files/DStream.java

+package gotowe.p43_files;
+
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class DStream {
+	// DirectoryStream nie wchodzi do podkatalogów
+	public static void main(String[] args) throws IOException {
+		Path dir = Paths.get("src");
+		DirectoryStream<Path> dstream = Files.newDirectoryStream(dir);
+		for(Path p : dstream) {
+			System.out.println(p);
+		}
+		System.out.println("======");
+		// W DirectoryStream nie działają wildcardy wielopoziomowe (nie schodzi do podkatalogów)
+		dstream = Files.newDirectoryStream(dir, "**.java");
+		for(Path p : dstream) {
+			System.out.println(p);
+		}
+		System.out.println("======");
+		dstream = Files.newDirectoryStream(dir.resolve("main/java/alx/p43_files"), "*.java");
+		for(Path p : dstream) {
+			System.out.println(p);
+		}
+	}
+}

src/main/java/gotowe/p43_files/FilesProperties.java

+package gotowe.p43_files;
+
+import java.nio.file.FileStore;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.DosFileAttributes;
+import java.nio.file.attribute.PosixFileAttributes;
+import java.nio.file.attribute.PosixFilePermission;
+import java.util.Map;
+import java.util.Set;
+
+public class FilesProperties {
+
+	public static void main(String[] args) {
+		try {
+			String name;
+			if(args.length > 0)
+				name = args[0];
+			else name = "src";
+			
+		Path start = Paths.get(name);
+		
+		System.out.println("dir " + Files.isDirectory(start));
+		System.out.println("dirL " + Files.isDirectory(start, LinkOption.NOFOLLOW_LINKS));
+		System.out.println("exe " + Files.isExecutable(start));
+		System.out.println("hid " + Files.isHidden(start));
+		System.out.println("reg " + Files.isRegularFile(start));
+		System.out.println("regL" + Files.isRegularFile(start, LinkOption.NOFOLLOW_LINKS));
+		System.out.println("red " + Files.isReadable(start));
+		System.out.println("wri " + Files.isWritable(start));
+		System.out.println("sym " + Files.isSymbolicLink(start));
+		System.out.println("lmt " + Files.getLastModifiedTime(start));
+		System.out.println("lmtL" + Files.getLastModifiedTime(start, LinkOption.NOFOLLOW_LINKS));
+		System.out.println();
+		
+		FileStore store = Files.getFileStore(start);
+		System.out.println("store total " + store.getTotalSpace() + " (" + store.getTotalSpace() / 1_000_000 + "M)");
+		System.out.println("store usable " + store.getUsableSpace() + " (" + store.getUsableSpace() / 1_000_000 + "M)");
+		
+		System.out.println();
+		BasicFileAttributes attrs = Files.readAttributes(start, BasicFileAttributes.class);
+		System.out.println("A reg " + attrs.isRegularFile());
+		System.out.println("A time " + attrs.lastModifiedTime());
+		System.out.println("A other " + attrs.isOther());
+
+		DosFileAttributes dattrs = Files.readAttributes(start, DosFileAttributes.class);
+		System.out.println("D reg " + dattrs.isRegularFile());
+		System.out.println("D arc " + dattrs.isArchive());
+		
+		
+		System.out.println("Lista atrybutów");
+		Map<String, Object> pAttributes = Files.readAttributes(start, "*");
+		for(Map.Entry<String, Object> entry : pAttributes.entrySet()) {
+			System.out.println(entry.getKey() + " : "+entry.getValue());
+		}
+
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/gotowe/p43_files/FilesProperties_Unix.java

+package gotowe.p43_files;
+
+import java.nio.file.FileStore;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.DosFileAttributes;
+import java.nio.file.attribute.PosixFileAttributes;
+import java.nio.file.attribute.PosixFilePermission;
+import java.util.Map;
+import java.util.Set;
+
+public class FilesProperties_Unix {
+
+	public static void main(String[] args) {
+		try {
+			String name;
+			if(args.length > 0)
+				name = args[0];
+			else name = "src";
+			//else name = "link_do_katalogu";
+			
+		Path start = Paths.get(name);
+		
+		System.out.println("dir " + Files.isDirectory(start));
+		System.out.println("dirL " + Files.isDirectory(start, LinkOption.NOFOLLOW_LINKS));
+		System.out.println("exe " + Files.isExecutable(start));
+		System.out.println("hid " + Files.isHidden(start));
+		System.out.println("reg " + Files.isRegularFile(start));
+		System.out.println("regL" + Files.isRegularFile(start, LinkOption.NOFOLLOW_LINKS));
+		System.out.println("red " + Files.isReadable(start));
+		System.out.println("wri " + Files.isWritable(start));
+		System.out.println("sym " + Files.isSymbolicLink(start));
+		System.out.println("lmt " + Files.getLastModifiedTime(start));
+		System.out.println("lmtL" + Files.getLastModifiedTime(start, LinkOption.NOFOLLOW_LINKS));
+		
+		FileStore store = Files.getFileStore(start);
+		System.out.println("store total " + store.getTotalSpace() + " (" + store.getTotalSpace() / 1_000_000 + "M)");
+		System.out.println("store usable " + store.getUsableSpace() + " (" + store.getUsableSpace() / 1_000_000 + "M)");
+		
+		BasicFileAttributes attrs = Files.readAttributes(start, BasicFileAttributes.class);
+		System.out.println("A reg " + attrs.isRegularFile());
+		System.out.println("A time " + attrs.lastModifiedTime());
+		System.out.println("A other " + attrs.isOther());
+
+		DosFileAttributes dattrs = Files.readAttributes(start, DosFileAttributes.class);
+		System.out.println("D reg " + dattrs.isRegularFile());
+		System.out.println("D arc " + dattrs.isArchive());
+		
+		PosixFileAttributes pattrs = Files.readAttributes(start, PosixFileAttributes.class);
+		System.out.println("P reg " + pattrs.isRegularFile());
+		System.out.println("P own " + pattrs.owner());
+		System.out.println("P grp " + pattrs.group());
+		Set<PosixFilePermission> permissions = pattrs.permissions();
+		System.out.println("POSIX permissions: " + permissions);
+		
+		Set<PosixFilePermission> permissions2 = Files.getPosixFilePermissions(start);
+		System.out.println("POSIX perms again: "+permissions2);
+		
+		
+		System.out.println("Lista atrybutów");
+		Map<String, Object> pAttributes = Files.readAttributes(start, "*");
+		for(Map.Entry<String, Object> entry : pAttributes.entrySet()) {
+			System.out.println(entry.getKey() + " : "+entry.getValue());
+		}
+
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/gotowe/p43_files/Kopiowanie.java

+package gotowe.p43_files;
+
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+
+public class Kopiowanie {
+
+	public static void main(String[] args) {
+		
+		try {
+		String skad = "pan-tadeusz.txt";
+		String dokad = "kopia.txt";
+		
+		Path pskad = Paths.get(skad);
+		Path pdokad = Paths.get(dokad);
+
+		System.out.println("Kopiuje");
+		Path copy = Files.copy(pskad, pdokad, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES, LinkOption.NOFOLLOW_LINKS);
+		System.out.println("Skopiowalem " + copy);
+
+		// kopiuje pojedyncze pliki, nie kopiuje katalogów rekurencyjnie
+		// dla katalogu - tworzy pusty katalog wynikowy
+		
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/gotowe/p43_files/Ls_Funkcyjnie.java

+package gotowe.p43_files;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class Ls_Funkcyjnie {
+
+	public static void main(String[] args) {
+		Path dir = Paths.get(".");
+		
+		try {
+			Files.list(dir)
+				.forEach(path -> System.out.println(path + " " + Files.isRegularFile(path)));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/gotowe/p43_files/Przenoszenie.java

+package gotowe.p43_files;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+
+public class Przenoszenie {
+
+	public static void main(String[] args) {
+		
+		try {
+			String skad = "kopia.txt";
+			//String dokad = "przeniesione.txt";
+			String dokad = "/tmp/przeniesione.txt";
+			//String skad = "/home/patryk/kopiowanie/katalog";
+			//String dokad = "/home/patryk/katalog_nowy";
+			//String dokad = "/tmp/wynik";
+			
+			Path pskad = Paths.get(skad);
+			Path pdokad = Paths.get(dokad);
+	
+			System.out.println("Przenosze");
+			// To działa także przy przenoszeniu jednego pliku na inną partycję.
+			Path copy = Files.move(pskad, pdokad);
+			
+			// ATOMIC_MOVE jest możliwy tylko w obrębie tej samej partycji, a nie zadziała gdy spróbujemy na inną
+			// Dodanie opcji ATOMIC_MOVE może spowodować wyjątek w sytuacjach, gdy bez tej opcji wszystko by zadziałało.
+			// Path copy = Files.move(pskad, pdokad, StandardCopyOption.ATOMIC_MOVE);
+			System.out.println("Przenioslem " + copy);
+			
+			// przenosi pliki
+			// przenosi też katalogi wraz z zawartością
+			// ale tylko w obrębie tej samej partycji
+		
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/gotowe/p43_files/Sciezki.java

+package gotowe.p43_files;
+
+import java.nio.file.FileSystem;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class Sciezki {
+
+	public static void main(String[] args) {
+		
+		//Path p = Paths.get("A/B/C");
+		//Path p = Paths.get("B/C");
+		Path p = Paths.get("/A/../B/C");
+		System.out.println(p);
+
+		System.out.println(p.isAbsolute());
+		System.out.println(p.getNameCount());
+		System.out.println(p.getFileName());
+		System.out.println(p.getName(0));
+		System.out.println(p.getName(1));
+		//System.out.println(p.getName(2));
+
+		FileSystem fs = p.getFileSystem();
+		System.out.println(fs + " " + fs.isReadOnly());
+		
+		System.out.println(p.getRoot()); // null
+		
+		Path parent = p.getParent();
+		System.out.println("parent: " + parent);
+		
+		Path norm = p.normalize();
+		System.out.println("normalize: " + norm);
+
+		Path inny = Paths.get("A/B/D");
+		
+		System.out.println("resolve " + p.resolve(inny));
+		System.out.println(inny.toAbsolutePath());
+		System.out.println(p.resolve(inny.toAbsolutePath()));
+		System.out.println(p.resolve("/home/users"));
+		System.out.println(p.toAbsolutePath().resolve("/home/users"));
+		System.out.println("abs res " + p.toAbsolutePath().resolve(inny));
+
+//		System.out.println("rel " + p.relativize(inny));
+//		System.out.println(p.normalize());
+//		System.out.println(p.normalize().relativize(inny));
+
+		System.out.println("Poprawny relativize: /A/B/C relativize /A/X/Y :");		
+		System.out.println(Paths.get("/A/B/C").relativize(Paths.get("/A/X/Y")));
+
+		// to jest wyjatek, bo mieszam absolute i relative
+		//System.out.println(Paths.get("A/B/C").relativize(Paths.get("A/X/Y")));
+
+		//System.out.println(p.normalize().relativize(inny.toAbsolutePath()));
+		//System.out.println(p.toAbsolutePath().relativize(inny));
+
+		System.out.println(p.normalize().toAbsolutePath().relativize(inny.toAbsolutePath()));
+		
+	}
+
+}
+

src/main/java/gotowe/p43_files/Tworzenie.java

+package gotowe.p43_files;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.FileAttribute;
+import java.nio.file.attribute.PosixFileAttributeView;
+import java.nio.file.attribute.PosixFileAttributes;
+import java.nio.file.attribute.PosixFilePermission;
+import java.nio.file.attribute.PosixFilePermissions;
+import java.nio.file.attribute.UserPrincipal;
+import java.util.Arrays;
+import java.util.Set;
+
+public class Tworzenie {
+
+	public static void main(String[] args) {
+		try {
+
+			Path start = Paths.get("katalog");
+			
+			Path path = Paths.get("ala");
+			if(! Files.exists(path)) {
+				Files.createDirectory(path);
+			}
+
+			Path path2 = Paths.get("ola");
+			Files.deleteIfExists(path2);
+			Files.createFile(path2);
+
+// dziala pod Linuxem			
+//			Path path21 = Paths.get("uprawnienia");
+//			Files.deleteIfExists(path21);
+//			Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rwxrw-r--");
+//			Files.createFile(path21, PosixFilePermissions.asFileAttribute(perms));
+
+			Path path3 = Files.createTempDirectory("temp");
+			System.out.println(path3);
+
+			byte[] buf = new byte[10];
+			Arrays.fill(buf, (byte)68);
+			
+			Path path4 = Files.createTempFile("PLIK", ".tmp");
+			System.out.println(path4);
+			//Files.write(path4, buf);
+			
+			OutputStream stream = Files.newOutputStream(path4);
+			stream.write(buf);
+			stream.close();
+			
+			Path path5 = Files.createTempDirectory(start, "bbb");
+
+			Path nowy = start.resolve("moj/nowy/katalog");
+			
+			Path path6 = Files.createDirectories(nowy);
+			System.out.println(path6);
+
+			
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/gotowe/p43_files/Watchery.java

+package gotowe.p43_files;
+
+import java.nio.file.FileSystem;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardWatchEventKinds;
+import java.nio.file.WatchEvent;
+import java.nio.file.WatchKey;
+import java.nio.file.WatchService;
+
+public class Watchery {
+
+	// WatchService potrafi obserwowac tylko katalogi a nie pojedyncze pliki)
+	
+	public static void main(String[] args) {
+		try {
+			Path start = Paths.get("katalog");
+
+			FileSystem fs = start.getFileSystem();
+			System.out.println("newWatchService()");
+			WatchService ws = fs.newWatchService();
+			System.out.println("Register:");
+			start.register(ws,
+					StandardWatchEventKinds.ENTRY_CREATE,
+					StandardWatchEventKinds.ENTRY_DELETE,
+					StandardWatchEventKinds.ENTRY_MODIFY,
+					StandardWatchEventKinds.OVERFLOW);
+			System.out.println("Czekam");
+			WatchKey key = ws.take();
+			System.out.println("Jest "+key);
+			for(WatchEvent<?> event : key.pollEvents()) {
+				System.out.println("Event "+event.kind().name() + " "+event.context());
+			}
+			System.out.println("Koniec");
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/gotowe/p43_files/WczytajWszystko.java

+package gotowe.p43_files;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
+
+public class WczytajWszystko {
+
+	public static void main(String[] args) {
+		Path plik = Paths.get("pan-tadeusz.txt");
+		Path plik2 = Paths.get("posortowane.txt");
+		
+		try {
+			List<String> linie = Files.readAllLines(plik);
+			
+			System.out.println("Pan Tadeusz ma " + linie.size() + " linii");
+			Collections.sort(linie);
+			
+			Files.write(plik2, linie);
+			System.out.println("Gotowe");
+			
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/gotowe/p43_files/WczytajWszystko2.java

+package gotowe.p43_files;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class WczytajWszystko2 {
+
+	public static void main(String[] args) {
+		Path plik = Paths.get("pan-tadeusz.txt");
+		Path plik2 = Paths.get("posortowane2.txt");
+		
+		try {
+			List<String> wyniki = Files.lines(plik)
+					.filter(s -> s.trim().length() > 10)
+					.map(s -> s.trim().toUpperCase())
+					.sorted()
+					.collect(Collectors.toList());
+			
+			Files.write(plik2, wyniki);
+			System.out.println("Gotowe");
+			
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/gotowe/p43_files/Wizytowanie.java

+package gotowe.p43_files;
+
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+
+// To schodzi do podkatalogów
+public class Wizytowanie {
+
+	public static void main(String[] args) {
+		try {
+			Path start = Paths.get("src");
+			MojWizytor visitor = new MojWizytor();
+			
+			Files.walkFileTree(start, visitor);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+}
+
+class MojWizytor extends SimpleFileVisitor<Path> {
+
+	@Override
+	public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
+			throws IOException {
+		System.out.println("preVisitDirectory "+dir);
+		
+		if("p10_klasy".equals(dir.getFileName().toString())) {
+			System.out.println("p10_klasy - omijam");
+			
+			// Za pomocą wartości wynikowej sterujemy algorytmem - mówimy co ma robić dalej
+			return FileVisitResult.SKIP_SUBTREE;
+		} else
+			return FileVisitResult.CONTINUE;
+	}
+
+	@Override
+	public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
+			throws IOException {
+		System.out.println("visitFile "+file.getFileName());
+		if("Kopiuj1.java".equals(file.getFileName().toString())) {
+			System.out.println("SKIP_SIBLINGS");
+			return FileVisitResult.SKIP_SIBLINGS;
+		} else
+			return FileVisitResult.CONTINUE;
+	}
+
+	@Override
+	public FileVisitResult postVisitDirectory(Path dir, IOException exc)
+			throws IOException {
+		System.out.println("postVisitDirectory "+dir);
+		return FileVisitResult.CONTINUE;
+	}
+	
+	@Override
+	public FileVisitResult visitFileFailed(Path file, IOException exc)
+			throws IOException {
+		System.out.println("visitFileFailed "+file);
+		return FileVisitResult.TERMINATE;
+	}
+
+}

src/main/java/gotowe/p43_files/WizytowanieMatcher.java

+package gotowe.p43_files;
+
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+
+public class WizytowanieMatcher {
+	private static PathMatcher pm = FileSystems.getDefault().getPathMatcher("glob:**moje**.java");
+	//private static PathMatcher pm = FileSystems.getDefault().getPathMatcher("regex:.*owa.*\\.java");
+
+	public static void main(String[] args) {
+		try {
+			Path start = Paths.get("src");
+			MojWizytorZMatcherem visitor = new MojWizytorZMatcherem();
+			
+			Files.walkFileTree(start, visitor);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+
+private static class MojWizytorZMatcherem extends SimpleFileVisitor<Path> {
+
+	@Override
+	public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
+			throws IOException {
+		System.out.println("preVisitDirectory "+dir);
+		
+		if("p10_klasy".equals(dir.getFileName().toString())) {
+			System.out.println("p10_klasy - omijam");
+			return FileVisitResult.SKIP_SUBTREE;
+		} else
+			return FileVisitResult.CONTINUE;
+	}
+
+	@Override
+	public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
+			throws IOException {
+		
+		boolean pasuje = pm.matches(file);
+		
+		System.out.println("visitFile "+file + " " + pasuje);
+		
+		return FileVisitResult.CONTINUE;
+	}
+
+	@Override
+	public FileVisitResult visitFileFailed(Path file, IOException exc)
+			throws IOException {
+		System.out.println("visitFileFailed "+file);
+		return FileVisitResult.CONTINUE;
+	}
+
+	@Override
+	public FileVisitResult postVisitDirectory(Path dir, IOException exc)
+			throws IOException {
+		System.out.println("postVisitDirectory "+dir);
+		return FileVisitResult.CONTINUE;
+	}
+	
+}
+
+}
\ No newline at end of file

src/main/java/na_zywo/lambdy/FunkcjaLiczbowa.java

 package na_zywo.lambdy;
 
+@FunctionalInterface
 public interface FunkcjaLiczbowa {
     double oblicz(double arg);
 

src/main/java/na_zywo/lambdy/Przyklady.java

@@ -29,7 +29,7 @@ public class Przyklady {
         System.out.println(Arrays.toString(liczby));
         Operacje.zmienTablice(liczby, f);
         System.out.println(Arrays.toString(liczby));
-        Operacje.zmienTablice(liczby, x -> Math.sqrt(x));
+        // Operacje.zmienTablice(liczby, x -> Math.sqrt(x));
         Operacje.zmienTablice(liczby, Math::sqrt);
         System.out.println(Arrays.toString(liczby));
         Operacje.zmienTablice(liczby, x -> 10*x);