Ostatnie znalezione rozwiązania zadań domowych

src/main/java/domowe/r2/z03_funkcje/Fibonacci1.java

+package domowe.r2.z03_funkcje;
+
+import java.util.Scanner;
+
+public class Fibonacci1 {
+	// 0 1 1 2 3 5 8 13 21 34 55
+	
+	// Wersja rekurencyjna, oparta bezpośrednio o definicję matematyczną.
+	// Ta wersja ma złożoność wykładniczą (czyli działa w czasie proporcjonalnym do funkcji wykładniczej / w zasadzie do wartości wyliczanej liczby Fibonacciego)
+	static long fib(int n) {
+		if(n == 0)
+			return 0;
+		if(n == 1)
+			return 1;
+		return fib(n-1) + fib(n-2);
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Aby zakończyć, wpisz -1");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			int liczba = sc.nextInt();
+			if(liczba < 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			var wynik = fib(liczba);
+			long k = System.currentTimeMillis();
+			
+			System.out.println("F(" + liczba + ") = " + wynik);
+			System.out.println("Obliczenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

src/main/java/domowe/r2/z03_funkcje/Fibonacci1_IlustracjaWykladniczejRekurencji.java

+package domowe.r2.z03_funkcje;
+
+import java.util.Scanner;
+
+// W tej wersji funkcja wypisuje znaczek na odpowiednim poziomie wcięcia, aby pokazać jak dużo razy jest uruchamiana przy podejściiu rekurencyjnym
+public class Fibonacci1_IlustracjaWykladniczejRekurencji {
+	private static int kolumna_wyrownania = 50;
+	
+	static long fib(int n) {
+		System.out.println(" ".repeat(kolumna_wyrownania-n) + ">");
+		long wynik;
+		if(n == 0) {
+			wynik = 0;
+		} else if(n == 1) {
+			wynik = 1;
+		} else {
+			long res1 = fib(n-1);
+			long res2 = fib(n-2);
+			wynik = res1 + res2;
+		}
+		System.out.println(" ".repeat(kolumna_wyrownania-n) + "<");
+		return wynik;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Aby zakończyć, wpisz -1");
+		while(true) {
+			System.out.print("\nPodaj liczbę: ");
+			int liczba = sc.nextInt();
+			if(liczba < 0) break;
+			kolumna_wyrownania = liczba;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			var wynik = fib(liczba);
+			long k = System.currentTimeMillis();
+			
+			System.out.println("F(" + liczba + ") = " + wynik);
+			System.out.println("Obliczenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

src/main/java/domowe/r2/z03_funkcje/Fibonacci2.java

+package domowe.r2.z03_funkcje;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class Fibonacci2 {
+	// 0 1 1 2 3 5 8 13 21 34 55
+	
+	static long fib(int n) {
+		long[] f = new long[n+2];
+		f[0] = 0;
+		f[1] = 1;
+		for(int i = 2; i <= n; i++) {
+			f[i] = f[i-2] + f[i-1];
+		}
+		System.out.println("Cała tablica: " + Arrays.toString(f));
+		return f[n];
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Aby zakończyć, wpisz -1");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			int liczba = sc.nextInt();
+			if(liczba < 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			var wynik = fib(liczba);
+			long k = System.currentTimeMillis();
+			
+			System.out.println("F(" + liczba + ") = " + wynik);
+			System.out.println("Obliczenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

src/main/java/domowe/r2/z03_funkcje/Fibonacci3.java

+package domowe.r2.z03_funkcje;
+
+import java.util.Scanner;
+
+public class Fibonacci3 {
+	// 0 1 1 2 3 5 8 13 21 34 55
+	
+	static long fib(int n) {
+		long ostatnia = 0;
+		long przedostatnia = 1;
+		for(int i = 1; i <= n; i++) {
+			long nowa = ostatnia + przedostatnia;
+			przedostatnia = ostatnia;
+			ostatnia = nowa;
+		}
+		return ostatnia;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Aby zakończyć, wpisz -1");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			int liczba = sc.nextInt();
+			if(liczba < 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			var wynik = fib(liczba);
+			long k = System.currentTimeMillis();
+			
+			System.out.println("F(" + liczba + ") = " + wynik);
+			System.out.println("Obliczenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

src/main/java/domowe/r2/z03_funkcje/Fibonacci4.java

+package domowe.r2.z03_funkcje;
+
+import java.math.BigInteger;
+import java.util.Scanner;
+
+public class Fibonacci4 {
+	// 0 1 1 2 3 5 8 13 21 34 55
+	
+	static BigInteger fib(int n) {
+		BigInteger ostatnia = BigInteger.ZERO;
+		BigInteger przedostatnia = BigInteger.ONE;
+		for(int i = 1; i <= n; i++) {
+			BigInteger nowa = ostatnia.add(przedostatnia);
+			przedostatnia = ostatnia;
+			ostatnia = nowa;
+		}
+		return ostatnia;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Aby zakończyć, wpisz -1");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			int liczba = sc.nextInt();
+			if(liczba < 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			var wynik = fib(liczba);
+			long k = System.currentTimeMillis();
+			
+			System.out.println("F(" + liczba + ") = " + wynik);
+			System.out.println("Obliczenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

src/main/java/domowe/r2/z03_funkcje/SumaCyfr_Matematycznie.java

+package domowe.r2.z03_funkcje;
+
+import java.util.Scanner;
+
+public class SumaCyfr_Matematycznie {
+	
+	static int sumaCyfr(long liczba) {
+		int suma = 0;
+		while(liczba > 0) {
+			suma += liczba % 10;
+			liczba /= 10;
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Podawaj liczby, a zakończ innym tekstem");
+		while(sc.hasNextLong()) {
+			long liczba = sc.nextLong();
+			int wynik = sumaCyfr(liczba);
+			System.out.println("Suma cyfr tej liczby wynosi " + wynik);
+			System.out.println();
+		}
+
+		System.out.println("pa pa ");
+	}
+
+}
+

src/main/java/domowe/r2/z03_funkcje/SumaCyfr_Tekstowo1.java

+package domowe.r2.z03_funkcje;
+
+import java.util.Scanner;
+
+public class SumaCyfr_Tekstowo1 {
+	
+	static int sumaCyfr(long liczba) {
+		String tekstowo = String.valueOf(liczba);
+		int suma = 0;
+		for(char ch : tekstowo.toCharArray()) {
+			if(Character.isDigit(ch)) {
+				suma += Character.digit(ch, 10);
+			}
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Podawaj liczby, a zakończ innym tekstem");
+		while(sc.hasNextLong()) {
+			long liczba = sc.nextLong();
+			int wynik = sumaCyfr(liczba);
+			System.out.println("Suma cyfr tej liczby wynosi " + wynik);
+			System.out.println();
+		}
+
+		System.out.println("pa pa ");
+	}
+
+}
+

src/main/java/domowe/r2/z03_funkcje/SumaCyfr_Tekstowo2.java

+package domowe.r2.z03_funkcje;
+
+import java.util.Scanner;
+
+public class SumaCyfr_Tekstowo2 {
+	
+	static int sumaCyfr(long liczba) {
+		String tekstowo = String.valueOf(liczba);
+		int suma = 0;
+		for(int i = 0; i < tekstowo.length(); i++) {
+			char ch = tekstowo.charAt(i);
+			int wartosc = Integer.parseInt(String.valueOf(ch));
+			suma += wartosc;
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Podawaj liczby, a zakończ innym tekstem");
+		while(sc.hasNextLong()) {
+			long liczba = sc.nextLong();
+			int wynik = sumaCyfr(liczba);
+			System.out.println("Suma cyfr tej liczby wynosi " + wynik);
+			System.out.println();
+		}
+
+		System.out.println("pa pa ");
+	}
+
+}
+

src/main/java/domowe/r2/z03_funkcje/SumaNieparzystych_v1.java

+package domowe.r2.z03_funkcje;
+
+public class SumaNieparzystych_v1 {
+	
+	static int sumaNieparzystych(int n) {
+		int suma = 0;
+		for(int i = 1; i < 2*n; i+=2) {
+			suma += i;
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		System.out.println(sumaNieparzystych(0));
+		System.out.println(sumaNieparzystych(1));
+		System.out.println(sumaNieparzystych(5));
+		System.out.println(sumaNieparzystych(7));
+		System.out.println(sumaNieparzystych(10));
+		System.out.println(sumaNieparzystych(100));
+	}
+
+}
+

src/main/java/domowe/r2/z03_funkcje/SumaNieparzystych_v2.java

+package domowe.r2.z03_funkcje;
+
+public class SumaNieparzystych_v2 {
+	
+	static int sumaNieparzystych(int n) {
+		int suma = 0;
+		for(int i = 0; i < n; i++) {
+			suma += 2*i+1;
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		System.out.println(sumaNieparzystych(0));
+		System.out.println(sumaNieparzystych(1));
+		System.out.println(sumaNieparzystych(5));
+		System.out.println(sumaNieparzystych(7));
+		System.out.println(sumaNieparzystych(10));
+		System.out.println(sumaNieparzystych(100));
+	}
+
+}
+

src/main/java/domowe/r2/z07_skarb/GraSzukanieSkarbu.java

+package domowe.r2.z07_skarb;
+
+import java.util.Random;
+import java.util.Scanner;
+
+/*
+Napisz grę polegającą na poszukiwaniu skarbu na dwuwymiarowej planszy o rozmiarach 10 na 10.
+Plansza jest wirtualna - nie trzeba ani w pamięci tworzyć żadnych tablic, ani żadnej planszy wyświetlać :)
+
+Program na początku losuje położenie skarbu na planszy (współrzędne x i y)
+oraz początkowe położenie gracza.
+
+Następnie w pętli użytkownik może wprowadzać komendy zmieniające położenie gracza.
+(np. po polsku G D L P, albo po angielsku U D L R, albo konwencja graczy W S A D)
+
+Po każdym ruchu użytkownik powinien otrzymywać informację o tym, czy zmierza w dobrym kierunku.
+
+Wyjście poza planszę oznacza porażkę - koniec gry.
+Wejście przez gracza na pozycję skarbu oznacza wygraną.
+
+Po znalezieniu skarbu program wypisuje gratulacje i informację o liczbie ruchów
+wykorzystanych przez użytkownika na dojście do celu.
+*/
+
+public class GraSzukanieSkarbu {
+	private static final boolean PODPOWIADANIE = true;
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in); // aby czytać polecenia
+		Random random = new Random(); // aby losować
+		
+		int skarb_x = random.nextInt(10); // liczba od 0 do 9
+		int skarb_y = random.nextInt(10);
+		int gracz_x = random.nextInt(10);
+		int gracz_y = random.nextInt(10);
+
+		if(PODPOWIADANIE)
+			System.out.printf("Pozycja skarbu: (%d , %d)\n", skarb_x, skarb_y);
+
+		petla:
+		while(true) {
+			if(PODPOWIADANIE)
+				System.out.printf("\nAktualna pozycja: (%d , %d)\n", gracz_x, gracz_y);
+			
+			int staraOdleglosc = Math.abs(skarb_x - gracz_x) + Math.abs(skarb_y - gracz_y);
+			
+			System.out.println("Podaj ruch [WSAD] lub przerwij [Q]: ");
+			String ruch = sc.nextLine();
+			
+			switch(ruch.trim().toUpperCase()) {
+			case "W" : gracz_y--; break;
+			case "S" : gracz_y++; break;
+			case "A" : gracz_x--; break;
+			case "D" : gracz_x++; break;
+			case "Q" : 
+				System.out.println("Poddajesz się? miękiszon...");
+				break petla; // mówimy, że break odnosi się do pętli oznaczonej tą etykietą
+				
+			default:
+				System.out.println("nie ma takiej komendy");
+				continue petla; // etykiety można podawać także przy instrukcji continue, chociaż w tym konkretnym przypadku nie jest to konieczne
+			}
+			
+			if(gracz_x < 0 || gracz_x > 9 || gracz_y < 0 || gracz_y > 9) {
+				System.out.println("Wypadłeś poza planszę - porażka");
+				break;
+			}
+			
+			if(gracz_x == skarb_x && gracz_y == skarb_y) {
+				System.out.println("Wygrana, gratulacje!");
+				break;
+			}
+			
+			int nowaOdleglosc = Math.abs(skarb_x - gracz_x) + Math.abs(skarb_y - gracz_y);
+			// System.out.println("odległość: " + nowaOdleglosc);
+			if(nowaOdleglosc < staraOdleglosc) {
+				System.out.println("Zbliżasz się do skarbu");
+			} else {
+				System.out.println("Oddalasz się od skarbu");
+			}
+		}
+		
+		System.out.println("\n================================\n  To była gra napisania na kursie ALX\n================================");
+	}
+}

src/main/java/domowe/r2/z08_range/Range.java

+package domowe.r2.z08_range;
+
+public class Range {
+	
+	private static void wypiszLiczbyUp(int start, int koniec, int krok) {
+		assert krok > 0; // tylko informacyjnie, to nie wpływa na działanie
+		for(int i = start; i < koniec; i += krok) {
+			System.out.print(i + " ");
+		}
+		System.out.println();
+	}
+
+	private static void wypiszLiczbyDown(int start, int koniec, int krok) {
+		assert krok < 0; // tylko informacyjnie, to nie wpływa na działanie
+		for(int i = start; i > koniec; i += krok) {
+			System.out.print(i + " ");
+		}
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		// domyślne wartości w razie braku argumentów
+		int start = 0;
+		int koniec = 0;
+		int krok = 1;
+		
+		if(args.length == 1) {
+			koniec = Integer.parseInt(args[0]);
+		}
+		if(args.length >= 2) {
+			start = Integer.parseInt(args[0]);
+			koniec = Integer.parseInt(args[1]);
+		}
+		if(args.length >= 3) {
+			krok = Integer.parseInt(args[2]);
+		}
+		
+		System.out.println("Ustalone parametry: " + start+ ", " + koniec + ", " + krok);
+		System.out.println();
+		
+		if(krok == 0) {
+			System.out.println("krok nie może być równy 0");
+		} else if(krok > 0) {
+			wypiszLiczbyUp(start, koniec, krok);
+		} else {
+			wypiszLiczbyDown(start, koniec, krok);
+		}
+	}
+
+}

src/main/java/domowe/r2/z09_kalkulator/Kalkulator1.java

+package domowe.r2.z09_kalkulator;
+
+import java.util.Scanner;
+
+public class Kalkulator1 {
+
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Podaj działanie na zasadzie 12 + 15");
+		
+		double x = sc.nextDouble();
+		String znak = sc.next();
+		double y = sc.nextDouble();
+		
+		switch(znak) {
+		case "+": System.out.println("wynik: " + (x + y)); break;
+		case "-": System.out.println("wynik: " + (x - y)); break;
+		case "*": System.out.println("wynik: " + (x * y)); break;
+		case "/": System.out.println("wynik: " + (x / y)); break;
+		case "%": System.out.println("wynik: " + (x % y)); break;
+		default: System.out.println("Nie ma takiego działania: " + znak);
+		}
+		
+	}
+
+}

src/main/java/domowe/r2/z09_kalkulator/Kalkulator2.java

+package domowe.r2.z09_kalkulator;
+
+import java.util.Scanner;
+
+public class Kalkulator2 {
+
+	static double oblicz(double arg1, double arg2, String operacja) {
+		switch(operacja) {
+		case "+": return arg1 + arg2;
+		case "-": return arg1 - arg2;
+		case "*": return arg1 * arg2;
+		case "/": return arg1 / arg2;
+		case "%": return arg1 % arg2;
+		default : return 0.0;
+		}
+	}
+	
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Podaj działanie na zasadzie 12 + 15");
+		
+		double x = sc.nextDouble();
+		String znak = sc.next();
+		double y = sc.nextDouble();
+		
+		double wynik = oblicz(x, y, znak);
+		System.out.println("wynik: " + wynik);
+	}
+
+}

src/main/java/domowe/r2/z09_kalkulator/Kalkulator3.java

+package domowe.r2.z09_kalkulator;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Kalkulator3 {
+
+	static double oblicz(double arg1, double arg2, String operacja) {
+		switch(operacja) {
+		case "+": return arg1 + arg2;
+		case "-": return arg1 - arg2;
+		case "*": return arg1 * arg2;
+		case "/": return arg1 / arg2;
+		case "%": return arg1 % arg2;
+		case "^": return Math.pow(arg1, arg2);
+		default : throw new IllegalArgumentException("Nie ma takiej operacji " + operacja);
+		}
+	}
+	
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		sc.useLocale(Locale.US);
+		
+		while (true) {
+			System.out.println("Podaj działanie na zasadzie 12 + 15 lub napisz KONIEC");
+
+			if(!sc.hasNextDouble() && sc.nextLine().trim().toLowerCase().equals("koniec")) {
+				break;
+			}
+			
+			try {
+				double x = sc.nextDouble();
+				String znak = sc.next();
+				double y = sc.nextDouble();
+				
+				// Aby Scanner "przeszedł do następnej linii"
+				// (czyli wczytał wszystko co jest za tą liczbą i w następnej linii czekał na dalsze polecenia)
+				sc.nextLine();
+				
+				double wynik = oblicz(x, y, znak);
+				System.out.println("wynik: " + wynik);
+			} catch (Exception e) {
+				System.out.println("Błąd: " + e.getMessage());
+			}
+		}
+		
+		System.out.println("Dziękujemy, papa");
+	}
+
+}

src/main/java/domowe/r4/odmiana_slow/BazaOdmian.java

+package domowe.r4.odmiana_slow;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class BazaOdmian {
+	private static final String DOMYSLNY_PLIK = "PoliMorf-0.6.7.tab";
+	
+	// dla formy podstawowej zawiera zbiór odmian
+	private final Map<String, Set<String>> odmiany = new HashMap<>();
+
+	// dla formy odmienionej zawiera zbiór form podstawowych
+	private final Map<String, Set<String>> podstawowe = new HashMap<>();
+	
+	// tylko po to, aby konstruktor nie był publiczny:
+	private BazaOdmian() {
+		
+	}
+	
+	// oficjalnym, publicznym sposobem tworzenia obiektów jest ta metoda statyczna:
+	public static BazaOdmian zPliku(String sciezka) {
+		BazaOdmian baza = new BazaOdmian();
+		baza.wczytajDaneZPliku(sciezka);
+		return baza;
+	}
+	
+	public static BazaOdmian zDomyslnegoPliku() {
+		return BazaOdmian.zPliku(DOMYSLNY_PLIK);
+	}
+	
+	// to jest metoda pomocnicza, więc oznaczam jako prywatną
+	private void wczytajDaneZPliku(String sciezka) {
+		try(BufferedReader input = new BufferedReader(new FileReader(sciezka))) {
+			String linia;
+			while((linia = input.readLine()) != null) {
+				String[] t = linia.split("\t", 3);				
+//				final String formaPodstawowa = t[1];
+//				final String formaOdmieniona = t[0];
+
+				// intern znajduje "wewnętrznego" stringa o takiej samej treści
+				// co pozwala zaoszczędzić pamięć, ale spowalnia wczytywanie
+				final String formaPodstawowa = t[1].intern();
+				final String formaOdmieniona = t[0].intern();
+				
+				Set<String> zbiorOdmian = odmiany.get(formaPodstawowa);
+				if(zbiorOdmian == null) {
+					zbiorOdmian = new HashSet<>();
+					odmiany.put(formaPodstawowa, zbiorOdmian);
+				}
+				zbiorOdmian.add(formaOdmieniona);
+
+				Set<String> zbiorPodstawowych = podstawowe.get(formaOdmieniona);
+				if(zbiorPodstawowych == null) {
+					zbiorPodstawowych = new HashSet<>();
+					podstawowe.put(formaOdmieniona, zbiorPodstawowych);
+				}
+				zbiorPodstawowych.add(formaPodstawowa);
+			}
+			
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public Set<String> znajdzFormyPodstawowe(String slowoOdmienione) {
+		Set<String> wyniki = podstawowe.get(slowoOdmienione);
+		if(wyniki == null) {
+			return Collections.emptySet(); // od Javy 9 można też Set.of()
+		} else {
+			// zwracam zbiór niemodyfikowalny, aby klient tej klasy nie miał prawa modyfikowania zawartości bazy odmian
+			return Collections.unmodifiableSet(wyniki);
+		}
+	}
+
+	public Set<String> znajdzOdmiany(String slowo) {
+		Set<String> wyniki = odmiany.get(slowo);
+		if(wyniki == null) {
+			return Collections.emptySet();
+		} else {
+			return Collections.unmodifiableSet(wyniki);
+		}
+	}
+
+}

src/main/java/domowe/r4/odmiana_slow/BazaOdmian_MaleLitery.java

+package domowe.r4.odmiana_slow;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class BazaOdmian_MaleLitery {
+	private static final String DOMYSLNY_PLIK = "PoliMorf-0.6.7.tab";
+	
+	// dla formy podstawowej zawiera zbiór odmian
+	private final Map<String, Set<String>> odmiany = new HashMap<>();
+
+	// dla formy odmienionej zawiera zbiór form podstawowych
+	private final Map<String, Set<String>> podstawowe = new HashMap<>();
+	
+	// tylko po to, aby konstruktor nie był publiczny:
+	private BazaOdmian_MaleLitery() {
+		
+	}
+	
+	// oficjalnym, publicznym sposobem tworzenia obiektów jest ta metoda statyczna:
+	public static BazaOdmian_MaleLitery zPliku(String sciezka) {
+		BazaOdmian_MaleLitery baza = new BazaOdmian_MaleLitery();
+		baza.wczytajDaneZPliku(sciezka);
+		return baza;
+	}
+	
+	public static BazaOdmian_MaleLitery zDomyslnegoPliku() {
+		return BazaOdmian_MaleLitery.zPliku(DOMYSLNY_PLIK);
+	}
+	
+	// to jest metoda pomocnicza, więc oznaczam jako prywatną
+	private void wczytajDaneZPliku(String sciezka) {
+		try(BufferedReader input = new BufferedReader(new FileReader(sciezka))) {
+			String linia;
+			while((linia = input.readLine()) != null) {
+				String[] t = linia.split("\t", 3);				
+//				final String formaPodstawowa = t[1];
+//				final String formaOdmieniona = t[0];
+
+				// intern znajduje "wewnętrznego" stringa o takiej samej treści
+				// co pozwala zaoszczędzić pamięć, ale spowalnia wczytywanie
+				final String formaPodstawowa = t[1].toLowerCase().intern();
+				final String formaOdmieniona = t[0].toLowerCase().intern();
+				
+				Set<String> zbiorOdmian = odmiany.get(formaPodstawowa);
+				if(zbiorOdmian == null) {
+					zbiorOdmian = new HashSet<>();
+					odmiany.put(formaPodstawowa, zbiorOdmian);
+				}
+				zbiorOdmian.add(formaOdmieniona);
+
+				Set<String> zbiorPodstawowych = podstawowe.get(formaOdmieniona);
+				if(zbiorPodstawowych == null) {
+					zbiorPodstawowych = new HashSet<>();
+					podstawowe.put(formaOdmieniona, zbiorPodstawowych);
+				}
+				zbiorPodstawowych.add(formaPodstawowa);
+			}
+			
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public Set<String> znajdzFormyPodstawowe(String slowoOdmienione) {
+		Set<String> wyniki = podstawowe.get(slowoOdmienione);
+		if(wyniki == null) {
+			return Collections.emptySet();
+		} else {
+			return Collections.unmodifiableSet(wyniki);
+		}
+	}
+
+	public Set<String> znajdzOdmiany(String slowo) {
+		Set<String> wyniki = odmiany.get(slowo);
+		if(wyniki == null) {
+			return Collections.emptySet();
+		} else {
+			return Collections.unmodifiableSet(wyniki);
+		}
+	}
+
+}

src/main/java/domowe/r4/odmiana_slow/BazaOdmian_v1.java

+package domowe.r4.odmiana_slow;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.Set;
+
+public class BazaOdmian_v1 {
+	// dla formy podstawowej zawiera zbiór odmian
+	private Map<String, Set<String>> odmiany = new HashMap<>();
+	
+	void wczytajDaneZPliku(String sciezka) {
+		try(Scanner scanner = new Scanner(new File(sciezka))) {
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				String[] t = linia.split("\t");
+				Set<String> zbiorOdmian = odmiany.get(t[1]);
+				if(zbiorOdmian == null) {
+					zbiorOdmian = new HashSet<>();
+					odmiany.put(t[1], zbiorOdmian);
+				}
+				zbiorOdmian.add(t[0]);
+			}
+			
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	Set<String> znajdzFormyPodstawowe(String slowoOdmienione) {
+		// W tej wersji przeglądamy całą bazę wiedzy sprawdzając gdzie wsytępuje taie słowo odmienione
+		HashSet<String> wyniki = new HashSet<>();
+		for (Map.Entry<String, Set<String>> entry : odmiany.entrySet()) {
+			// jeśli zbiór odmian zawiera slowoOdmienione, to klucz (czyli forma bazowa) powinien być dodany do wyników tej metody
+			if(entry.getValue().contains(slowoOdmienione)) {
+				wyniki.add(entry.getKey());
+			}
+		}
+		
+		return wyniki;
+	}
+
+	Set<String> znajdzOdmiany(String slowo) {
+		return odmiany.get(slowo);
+	}
+
+}
+
+

src/main/java/domowe/r4/odmiana_slow/BazaOdmian_v2.java

+package domowe.r4.odmiana_slow;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.Set;
+
+public class BazaOdmian_v2 {
+	private static final String DOMYSLNY_PLIK = "PoliMorf-0.6.7.tab";
+	
+	// dla formy podstawowej zawiera zbiór odmian
+	private final Map<String, Set<String>> odmiany = new HashMap<>();
+
+	// dla formy odmienionej zawiera zbiór form podstawowych
+	private final Map<String, Set<String>> podstawowe = new HashMap<>();
+	
+	// tylko po to, aby konstruktor nie był publiczny:
+	private BazaOdmian_v2() {
+		
+	}
+	
+	// oficjalnym, publicznym sposobem tworzenia obiektów jest ta metoda statyczna:
+	public static BazaOdmian_v2 zPliku(String sciezka) {
+		BazaOdmian_v2 baza = new BazaOdmian_v2();
+		baza.wczytajDaneZPliku(sciezka);
+		return baza;
+	}
+	
+	public static BazaOdmian_v2 zDomyslnegoPliku() {
+		return BazaOdmian_v2.zPliku(DOMYSLNY_PLIK);
+	}
+	
+	// to jest metoda pomocnicza, więc oznaczam jako prywatną
+	private void wczytajDaneZPliku(String sciezka) {
+		try(Scanner scanner = new Scanner(new File(sciezka))) {
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				String[] t = linia.split("\t");
+				Set<String> zbiorOdmian = odmiany.get(t[1]);
+				if(zbiorOdmian == null) {
+					zbiorOdmian = new HashSet<>();
+					odmiany.put(t[1], zbiorOdmian);
+				}
+				zbiorOdmian.add(t[0]);
+
+				Set<String> zbiorPodstawowych = podstawowe.get(t[0]);
+				if(zbiorPodstawowych == null) {
+					zbiorPodstawowych = new HashSet<>();
+					podstawowe.put(t[0], zbiorPodstawowych);
+				}
+				zbiorPodstawowych.add(t[1]);
+			}
+			
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public Set<String> znajdzFormyPodstawowe(String slowoOdmienione) {
+		return podstawowe.get(slowoOdmienione);
+	}
+
+	public Set<String> znajdzOdmiany(String slowo) {
+		return odmiany.get(slowo);
+	}
+
+}
+
+

src/main/java/domowe/r4/odmiana_slow/PoliczKazdeSlowo6.java

+package domowe.r4.odmiana_slow;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.TreeMap;
+
+public class PoliczKazdeSlowo6 {
+
+	public static void main(String[] args) {
+		System.out.println("Buduję bazę odmian...");
+		BazaOdmian_MaleLitery bazaOdmian = BazaOdmian_MaleLitery.zDomyslnegoPliku();
+		
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			System.out.println("Buduję mapę...");
+			Map<String, Integer> mapa = new TreeMap<>(Collator.getInstance());
+			while(scanner.hasNext()) {
+				String slowo = scanner.next().toLowerCase().intern();
+				Set<String> podstawowe = bazaOdmian.znajdzFormyPodstawowe(slowo);
+				if(!podstawowe.isEmpty()) {
+					slowo = podstawowe.iterator().next(); // biorę pierwszą formę podstawową
+				}
+				int ileBylo = mapa.getOrDefault(slowo, 0);
+				mapa.put(slowo, ileBylo+1);
+			}
+			
+			System.out.println("Unikalnych słów: " + mapa.size());
+			
+			System.out.println("Sortuję dane...");
+			List<Map.Entry<String, Integer>> lista = new ArrayList<>(mapa.entrySet());
+			// W Java 8 do Map.Entry dodano gotowy komparator, którego możemy użyć
+			lista.sort(Map.Entry.comparingByValue());
+			
+			for (Map.Entry<String, Integer> entry : lista) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/domowe/r4/odmiana_slow/TestOdmian.java

+package domowe.r4.odmiana_slow;
+
+import java.util.Scanner;
+import java.util.Set;
+
+public class TestOdmian {
+
+	public static void main(String[] args) {
+		long p, k;
+		System.out.println("Wczytuję bazę odmian..");
+		p = System.nanoTime();
+		
+		BazaOdmian baza = BazaOdmian.zDomyslnegoPliku();
+		k = System.nanoTime();
+		System.out.printf("Wczytywanie trwało %,d us\n", k-p);
+		
+		Runtime runtime = Runtime.getRuntime();
+		System.out.printf("Zajęta pamięć: %,d\n", runtime.totalMemory() - runtime.freeMemory());
+		
+		Scanner scanner = new Scanner(System.in);
+		while(true) {
+			System.out.print("Podaj słowo: ");
+			String slowo = scanner.nextLine();
+			if(slowo.isEmpty())
+				break;
+			
+			p = System.nanoTime();
+			Set<String> odmiany = baza.znajdzOdmiany(slowo);
+			k = System.nanoTime();
+			System.out.printf("(czas %,d) Słowo %s posiada nast. odmiany: %s\n", k-p, slowo, odmiany);
+
+			p = System.nanoTime();
+			Set<String> podstawowe = baza.znajdzFormyPodstawowe(slowo);
+			k = System.nanoTime();
+			System.out.printf("(czas %,d) Słowo %s jest odmianą takich słów: %s\n", k-p, slowo, podstawowe);
+			System.out.println();
+			
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/EntryComparator.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class EntryComparator implements Comparator<Map.Entry<?, Integer>> {
+
+	@Override
+	public int compare(Entry<?, Integer> e1, Entry<?, Integer> e2) {
+		// taki zapis (zamiast odejmowania) działa poprawnie także w przypadku bardzo dużych i bardzo małych wartości - nie będzie integer overflow
+		return Integer.compare(e1.getValue(), e2.getValue());
+	}
+
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczKazdeSlowo1.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+public class PoliczKazdeSlowo1 {
+
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			Map<String, Integer> mapa = new HashMap<>();
+			while(scanner.hasNext()) {
+				String slowo = scanner.next();
+				if(mapa.containsKey(slowo)) {
+					int ileBylo = mapa.get(slowo);
+					mapa.put(slowo, ileBylo+1);
+				} else {
+					mapa.put(slowo, 1);
+				}
+			}
+			
+			System.out.println("Unikalnych słów: " + mapa.size());
+
+			for (Map.Entry<String, Integer> entry : mapa.entrySet()) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+				
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczKazdeSlowo2.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+public class PoliczKazdeSlowo2 {
+
+	// W tej wersji: LinkedHashMap - kolejność słów jak w pliku
+	// Inny sposób sprawdzania czy słowo występowało: spr czy nie null
+	
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			Map<String, Integer> mapa = new LinkedHashMap<>();
+			while(scanner.hasNext()) {
+				String slowo = scanner.next();
+				Integer ileBylo = mapa.get(slowo);
+				if(ileBylo == null) {
+					ileBylo = 0;
+				}
+				mapa.put(slowo, ileBylo+1);
+			}
+			
+			System.out.println("Unikalnych słów: " + mapa.size());
+
+			for (Map.Entry<String, Integer> entry : mapa.entrySet()) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+				
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczKazdeSlowo3.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class PoliczKazdeSlowo3 {
+
+	// W tej wersji: TreeMap - kolejność słów wg kodów Unicode
+	// operacja getOrDefault (od Java 8)
+	
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			System.out.println("Buduję mapę...");
+			Map<String, Integer> mapa = new TreeMap<>();
+			while(scanner.hasNext()) {
+				String slowo = scanner.next();
+				int ileBylo = mapa.getOrDefault(slowo, 0);
+				mapa.put(slowo, ileBylo+1);
+			}
+			
+			System.out.println("Unikalnych słów: " + mapa.size());
+
+			for (Map.Entry<String, Integer> entry : mapa.entrySet()) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+				
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczKazdeSlowo4.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class PoliczKazdeSlowo4 {
+
+	// W tej wersji: TreeMap(Collator) - kolejność słów wg alfabetu polskiego
+	// operacja getOrDefault (od Java 8)
+	
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			System.out.println("Buduję mapę...");
+			Map<String, Integer> mapa = new TreeMap<>(Collator.getInstance());
+			while(scanner.hasNext()) {
+				String slowo = scanner.next();
+				int ileBylo = mapa.getOrDefault(slowo, 0);
+				mapa.put(slowo, ileBylo+1);
+			}
+			
+			System.out.println("Unikalnych słów: " + mapa.size());
+
+			for (Map.Entry<String, Integer> entry : mapa.entrySet()) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+				
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczKazdeSlowo4a.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class PoliczKazdeSlowo4a {
+
+	// W tej wersji: TreeMap(Collator) - kolejność słów wg alfabetu polskiego
+	// operacja getOrDefault (od Java 8)
+	
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			System.out.println("Buduję mapę...");
+			Map<String, Integer> mapa = new TreeMap<>(Collator.getInstance());
+			while(scanner.hasNext()) {
+				String slowo = scanner.next().toLowerCase();
+				int ileBylo = mapa.getOrDefault(slowo, 0);
+				mapa.put(slowo, ileBylo+1);
+			}
+			System.out.println("Unikalnych słów: " + mapa.size());
+
+			for (Map.Entry<String, Integer> entry : mapa.entrySet()) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+				
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczKazdeSlowo5.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class PoliczKazdeSlowo5 {
+
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			System.out.println("Buduję mapę...");
+			Map<String, Integer> mapa = new TreeMap<>(Collator.getInstance());
+			while(scanner.hasNext()) {
+				String slowo = scanner.next();
+				int ileBylo = mapa.getOrDefault(slowo, 0);
+				mapa.put(slowo, ileBylo+1);
+			}
+			
+			System.out.println("Unikalnych słów: " + mapa.size());
+			
+			System.out.println("Sortuję dane...");
+			List<Map.Entry<String, Integer>> lista = new ArrayList<>(mapa.entrySet());
+			// definiujemy Comparator jako klasę anonimową
+			Collections.sort(lista, new Comparator<Map.Entry<String, Integer>>() {
+				public int compare(Entry<String, Integer> e1, Entry<String, Integer> e2) {
+					return e1.getValue() - e2.getValue();
+				}
+			});
+			
+			for (Map.Entry<String, Integer> entry : lista) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczKazdeSlowo5a.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class PoliczKazdeSlowo5a {
+
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			System.out.println("Buduję mapę...");
+			Map<String, Integer> mapa = new TreeMap<>(Collator.getInstance());
+			while(scanner.hasNext()) {
+				String slowo = scanner.next().toLowerCase();
+				int ileBylo = mapa.getOrDefault(slowo, 0);
+				mapa.put(slowo, ileBylo+1);
+			}
+			
+			System.out.println("Unikalnych słów: " + mapa.size());
+			
+			System.out.println("Sortuję dane...");
+			List<Map.Entry<String, Integer>> lista = new ArrayList<>(mapa.entrySet());
+			// definiujemy Comparator jako klasę anonimową
+			Collections.sort(lista, new Comparator<Map.Entry<String, Integer>>() {
+				public int compare(Entry<String, Integer> e1, Entry<String, Integer> e2) {
+					return e1.getValue() - e2.getValue();
+				}
+			});
+			
+			for (Map.Entry<String, Integer> entry : lista) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczKazdeSlowo5b.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class PoliczKazdeSlowo5b {
+
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			System.out.println("Buduję mapę...");
+			Map<String, Integer> mapa = new TreeMap<>(Collator.getInstance());
+			while(scanner.hasNext()) {
+				String slowo = scanner.next();
+				int ileBylo = mapa.getOrDefault(slowo, 0);
+				mapa.put(slowo, ileBylo+1);
+			}
+			
+			System.out.println("Unikalnych słów: " + mapa.size());
+			
+			System.out.println("Sortuję dane...");
+			List<Map.Entry<String, Integer>> lista = new ArrayList<>(mapa.entrySet());
+			Collections.sort(lista, new EntryComparator());
+			
+			for (Map.Entry<String, Integer> entry : lista) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczKazdeSlowo5c.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class PoliczKazdeSlowo5c {
+
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			System.out.println("Buduję mapę...");
+			Map<String, Integer> mapa = new TreeMap<>(Collator.getInstance());
+			while(scanner.hasNext()) {
+				String slowo = scanner.next();
+				int ileBylo = mapa.getOrDefault(slowo, 0);
+				mapa.put(slowo, ileBylo+1);
+			}
+			
+			System.out.println("Unikalnych słów: " + mapa.size());
+			
+			System.out.println("Sortuję dane...");
+			List<Map.Entry<String, Integer>> lista = new ArrayList<>(mapa.entrySet());
+			// W Java 8 do Map.Entry dodano gotowy komparator, którego możemy użyć
+			lista.sort(Map.Entry.comparingByValue());
+			
+			for (Map.Entry<String, Integer> entry : lista) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczKazdeSlowo5d.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.TreeMap;
+
+public class PoliczKazdeSlowo5d {
+
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			
+			System.out.println("Buduję mapę...");
+			Map<String, Integer> mapa = new TreeMap<>(Collator.getInstance());
+			while(scanner.hasNext()) {
+				String slowo = scanner.next();
+				int ileBylo = mapa.getOrDefault(slowo, 0);
+				mapa.put(slowo, ileBylo+1);
+			}
+			
+			System.out.println("Unikalnych słów: " + mapa.size());
+			
+			System.out.println("Sortuję dane...");
+			List<Map.Entry<String, Integer>> lista = new ArrayList<>(mapa.entrySet());
+			// definiujemy Comparator jako wyrażenie lambda
+			lista.sort((e1, e2) -> e1.getValue() - e2.getValue());
+			
+			for (Map.Entry<String, Integer> entry : lista) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczSlowaStream.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class PoliczSlowaStream {
+
+    private static final String SEP = "[^\\p{L}\\d]+";
+
+    public static void main(String[] args) {
+        try(Stream<String> lines = Files.lines(Paths.get("pan-tadeusz.txt"), Charset.forName("UTF-8"))) {
+            lines.flatMap(line -> Stream.of(line.split(SEP)))
+                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
+                .entrySet()
+                .stream()
+                .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
+                .forEachOrdered(entry -> System.out.println(entry.getKey() + ": " + entry.getValue()));
+        } catch(IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczWszystkieSlowa0.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class PoliczWszystkieSlowa0 {
+
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			System.out.println("Domyślny delimiter: " + scanner.delimiter());
+
+			int ilosc = 0;
+			while(scanner.hasNext()) {
+				String slowo = scanner.next();
+				System.out.println("[" + slowo + "]");
+				ilosc++;
+			}
+			
+			System.out.println("Ilość słów: " + ilosc);
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/PoliczWszystkieSlowa1.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class PoliczWszystkieSlowa1 {
+
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			// scanner.useDelimiter(" ");
+			// scanner.useDelimiter("\\s+"); // to jest domyślny delimiter w Scannerze - ciąg białych znaków
+			// scanner.useDelimiter("[\\s,.:;?!()—+…«»]+"); // możemy wymienić wszystkie znaki, które mają być uznane za separatory 
+			scanner.useDelimiter("[^\\p{L}\\d]+"); // ciąg znaków, które nie są literami ani cyframi traktujemy jak separator
+			
+			int ilosc = 0;
+			while(scanner.hasNext()) {
+				String slowo = scanner.next();
+				System.out.println("[" + slowo + "]");
+				ilosc++;
+			}
+			
+			System.out.println("Ilość słów: " + ilosc);
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/SzukajSlowa_HashSet.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.HashSet;
+import java.util.Scanner;
+import java.util.Set;
+
+import javax.swing.JOptionPane;
+
+public class SzukajSlowa_HashSet {
+	
+	static Set<String> wczytajSlowa(String sciezka) {
+		Set<String> slowa = new HashSet<>();
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			while(scanner.hasNext()) {
+				slowa.add(scanner.next());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+		return slowa;
+	}
+
+	public static void main(String[] args) {
+		long p, k;
+		
+		p = System.nanoTime();
+		Set<String> slowa = wczytajSlowa("pan-tadeusz.txt");
+		k = System.nanoTime();
+		JOptionPane.showMessageDialog(null, String.format("Wczytano %d słów. Czas: %,d µs", slowa.size(), (k-p)/1000));
+		
+		while(true) {
+			String szukaneSlowo = JOptionPane.showInputDialog("Jakiego słowa szukasz?");
+			if(szukaneSlowo == null)
+				break;
+			p = System.nanoTime();
+			boolean jest = slowa.contains(szukaneSlowo);
+			k = System.nanoTime();
+			if(jest) {
+				JOptionPane.showMessageDialog(null, String.format("Słowo znalezione, czas: %,d µs", (k-p)/1000));
+			} else {
+				JOptionPane.showMessageDialog(null, String.format("Słowa nie ma, czas: %,d µs", (k-p)/1000));
+			}
+		}
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/SzukajSlowa_Lista.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+import javax.swing.JOptionPane;
+
+public class SzukajSlowa_Lista {
+	
+	static List<String> wczytajSlowa(String sciezka) {
+		List<String> slowa = new ArrayList<>();
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			while(scanner.hasNext()) {
+				slowa.add(scanner.next());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+		return slowa;
+	}
+
+	public static void main(String[] args) {
+		long p, k;
+		
+		p = System.nanoTime();
+		List<String> slowa = wczytajSlowa("pan-tadeusz.txt");
+		k = System.nanoTime();
+		JOptionPane.showMessageDialog(null, String.format("Wczytano %d słów. Czas: %,d µs", slowa.size(), (k-p)/1000));
+		
+		while(true) {
+			String szukaneSlowo = JOptionPane.showInputDialog("Jakiego słowa szukasz?");
+			if(szukaneSlowo == null)
+				break;
+			p = System.nanoTime();
+			boolean jest = slowa.contains(szukaneSlowo);
+			k = System.nanoTime();
+			if(jest) {
+				JOptionPane.showMessageDialog(null, String.format("Słowo znalezione, czas: %,d µs", (k-p)/1000));
+			} else {
+				JOptionPane.showMessageDialog(null, String.format("Słowa nie ma, czas: %,d µs", (k-p)/1000));
+			}
+		}
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/SzukajSlowa_Lista2.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+import javax.swing.JOptionPane;
+
+public class SzukajSlowa_Lista2 {
+	
+	static List<String> wczytajSlowa(String sciezka) {
+		List<String> slowa = new ArrayList<>();
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			while(scanner.hasNext()) {
+				slowa.add(scanner.next());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+		return slowa;
+	}
+
+	public static void main(String[] args) {
+		long p, k;
+		
+		p = System.nanoTime();
+		List<String> slowa = wczytajSlowa("pan-tadeusz.txt");
+		k = System.nanoTime();
+		JOptionPane.showMessageDialog(null, String.format("Wczytano %d słów. Czas: %,d µs", slowa.size(), (k-p)/1000));
+		
+		while(true) {
+			String szukaneSlowo = JOptionPane.showInputDialog("Jakiego słowa szukasz?");
+			if(szukaneSlowo == null)
+				break;
+			p = System.nanoTime();
+			int poz = slowa.indexOf(szukaneSlowo);
+			k = System.nanoTime();
+			if(poz >= 0) {
+				JOptionPane.showMessageDialog(null, String.format("Słowo znalezione na pozycji %d, czas: %,d µs", poz, (k-p)/1000));
+			} else {
+				JOptionPane.showMessageDialog(null, String.format("Słowa nie ma, czas: %,d µs", (k-p)/1000));
+			}
+		}
+	}
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/SzukajSlowa_Lista3.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+import javax.swing.JOptionPane;
+
+public class SzukajSlowa_Lista3 {
+	
+	static List<String> wczytajSlowa(String sciezka) {
+		List<String> slowa = new ArrayList<>();
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			while(scanner.hasNext()) {
+				slowa.add(scanner.next());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+		return slowa;
+	}
+
+	static int ileRazy(List<String> slowa, String szukaneSlowo) {
+		int ileRazy = 0;
+		for(String slowo : slowa) {
+			if(slowo.equals(szukaneSlowo)) {
+				ileRazy++;
+			}
+		}
+		return ileRazy;
+	}
+
+	public static void main(String[] args) {
+		long p, k;
+		
+		p = System.nanoTime();
+		List<String> slowa = wczytajSlowa("pan-tadeusz.txt");
+		k = System.nanoTime();
+		JOptionPane.showMessageDialog(null, String.format("Wczytano %d słów. Czas: %,d µs", slowa.size(), (k-p)/1000));
+		
+		while(true) {
+			String szukaneSlowo = JOptionPane.showInputDialog("Jakiego słowa szukasz?");
+			if(szukaneSlowo == null)
+				break;
+			p = System.nanoTime();
+			int ileRazy = ileRazy(slowa, szukaneSlowo);
+			k = System.nanoTime();
+			if(ileRazy >= 0) {
+				JOptionPane.showMessageDialog(null, String.format("Słowo występuje %d razy, czas: %,d µs", ileRazy, (k-p)/1000));
+			} else {
+				JOptionPane.showMessageDialog(null, String.format("Słowa nie ma, czas: %,d µs", (k-p)/1000));
+			}
+		}
+	}
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/SzukajSlowa_Mapa.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+import javax.swing.JOptionPane;
+
+public class SzukajSlowa_Mapa {
+
+	static Map<String, Integer> wczytajSlowa(String sciezka) {
+		Map<String, Integer> mapa = new HashMap<>();
+		try (Scanner scanner = new Scanner(new File(sciezka))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			while (scanner.hasNext()) {
+				String slowo = scanner.next();
+				int ileBylo = mapa.getOrDefault(slowo, 0);
+				mapa.put(slowo, ileBylo + 1);
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+		return mapa;
+	}
+
+	public static void main(String[] args) {
+		long p, k;
+
+		p = System.nanoTime();
+		Map<String, Integer> slowa = wczytajSlowa("pan-tadeusz.txt");
+		k = System.nanoTime();
+		JOptionPane.showMessageDialog(null,
+				String.format("Wczytano %d słów. Czas: %,d µs", slowa.size(), (k - p) / 1000));
+
+		while (true) {
+			String szukaneSlowo = JOptionPane.showInputDialog("Jakiego słowa szukasz?");
+			if (szukaneSlowo == null)
+				break;
+			p = System.nanoTime();
+			Integer ileRazy = slowa.get(szukaneSlowo);
+			k = System.nanoTime();
+			if (ileRazy != null) {
+				JOptionPane.showMessageDialog(null,
+						String.format("Słowo występuje %d razy, czas: %,d µs", ileRazy, (k - p) / 1000));
+			} else {
+				JOptionPane.showMessageDialog(null, String.format("Słowa nie ma, czas: %,d µs", (k - p) / 1000));
+			}
+		}
+	}
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/SzukajSlowa_TreeSet.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.TreeSet;
+
+import javax.swing.JOptionPane;
+
+public class SzukajSlowa_TreeSet {
+	
+	static Set<String> wczytajSlowa(String sciezka) {
+		Set<String> slowa = new TreeSet<>();
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			while(scanner.hasNext()) {
+				slowa.add(scanner.next());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+		return slowa;
+	}
+
+	public static void main(String[] args) {
+		long p, k;
+		
+		p = System.nanoTime();
+		Set<String> slowa = wczytajSlowa("pan-tadeusz.txt");
+		k = System.nanoTime();
+		JOptionPane.showMessageDialog(null, String.format("Wczytano %d słów. Czas: %,d µs", slowa.size(), (k-p)/1000));
+		
+		while(true) {
+			String szukaneSlowo = JOptionPane.showInputDialog("Jakiego słowa szukasz?");
+			if(szukaneSlowo == null)
+				break;
+			p = System.nanoTime();
+			boolean jest = slowa.contains(szukaneSlowo);
+			k = System.nanoTime();
+			if(jest) {
+				JOptionPane.showMessageDialog(null, String.format("Słowo znalezione, czas: %,d µs", (k-p)/1000));
+			} else {
+				JOptionPane.showMessageDialog(null, String.format("Słowa nie ma, czas: %,d µs", (k-p)/1000));
+			}
+		}
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/SzukajSlowa_TreeSetCollator.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.TreeSet;
+
+import javax.swing.JOptionPane;
+
+public class SzukajSlowa_TreeSetCollator {
+	
+	static Set<String> wczytajSlowa(String sciezka) {
+		Set<String> slowa = new TreeSet<>(Collator.getInstance());
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			while(scanner.hasNext()) {
+				slowa.add(scanner.next());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+		return slowa;
+	}
+
+	public static void main(String[] args) {
+		long p, k;
+		
+		p = System.nanoTime();
+		Set<String> slowa = wczytajSlowa("pan-tadeusz.txt");
+		k = System.nanoTime();
+		JOptionPane.showMessageDialog(null, String.format("Wczytano %d słów. Czas: %,d µs", slowa.size(), (k-p)/1000));
+		
+		while(true) {
+			String szukaneSlowo = JOptionPane.showInputDialog("Jakiego słowa szukasz?");
+			if(szukaneSlowo == null)
+				break;
+			p = System.nanoTime();
+			boolean jest = slowa.contains(szukaneSlowo);
+			k = System.nanoTime();
+			if(jest) {
+				JOptionPane.showMessageDialog(null, String.format("Słowo znalezione, czas: %,d µs", (k-p)/1000));
+			} else {
+				JOptionPane.showMessageDialog(null, String.format("Słowa nie ma, czas: %,d µs", (k-p)/1000));
+			}
+		}
+	}
+
+}

src/main/java/domowe/r4/pan_tadeusz_stare_wersje/WypiszHashSet.java

+package domowe.r4.pan_tadeusz_stare_wersje;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.HashSet;
+import java.util.Scanner;
+import java.util.Set;
+
+public class WypiszHashSet {
+	
+	static Set<String> wczytajSlowa(String sciezka) {
+		Set<String> slowa = new HashSet<>();
+		try (Scanner scanner = new Scanner(new File("pan-tadeusz.txt"))) {
+			scanner.useDelimiter("[^\\p{L}\\d]+");
+			while(scanner.hasNext()) {
+				slowa.add(scanner.next());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+		return slowa;
+	}
+
+	public static void main(String[] args) {
+		Set<String> slowa = wczytajSlowa("pan-tadeusz.txt");
+		
+		for (String slowo : slowa) {
+			System.out.println(slowo);
+		}
+		System.out.println("Unikalnych słów " + slowa.size());
+	}
+
+}