przykłady pan_tadeusz

src/main/java/pan_tadeusz/EntryComparator.java

+package pan_tadeusz;
+
+import java.util.Comparator;
+import java.util.Map.Entry;
+
+public class EntryComparator implements Comparator<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/pan_tadeusz/PoliczKazdeSlowo1.java

+package pan_tadeusz;
+
+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/pan_tadeusz/PoliczKazdeSlowo2.java

+package pan_tadeusz;
+
+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/pan_tadeusz/PoliczKazdeSlowo3.java

+package pan_tadeusz;
+
+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/pan_tadeusz/PoliczKazdeSlowo4.java

+package pan_tadeusz;
+
+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/pan_tadeusz/PoliczKazdeSlowo4a.java

+package pan_tadeusz;
+
+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/pan_tadeusz/PoliczKazdeSlowo5.java

+package pan_tadeusz;
+
+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<Entry<String, Integer>> lista = new ArrayList<>(mapa.entrySet());
+			// definiujemy Comparator jako klasę anonimową
+			Collections.sort(lista, new Comparator<Entry<String, Integer>>() {
+				public int compare(Entry<String, Integer> e1, Entry<String, Integer> e2) {
+					return e1.getValue() - e2.getValue();
+				}
+			});
+			
+			for (Entry<String, Integer> entry : lista) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/pan_tadeusz/PoliczKazdeSlowo5a.java

+package pan_tadeusz;
+
+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<Entry<String, Integer>> lista = new ArrayList<>(mapa.entrySet());
+			// definiujemy Comparator jako klasę anonimową
+			Collections.sort(lista, new Comparator<Entry<String, Integer>>() {
+				public int compare(Entry<String, Integer> e1, Entry<String, Integer> e2) {
+					return e1.getValue() - e2.getValue();
+				}
+			});
+			
+			for (Entry<String, Integer> entry : lista) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/pan_tadeusz/PoliczKazdeSlowo5b.java

+package pan_tadeusz;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Collections;
+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<Entry<String, Integer>> lista = new ArrayList<>(mapa.entrySet());
+			Collections.sort(lista, new EntryComparator());
+			
+			for (Entry<String, Integer> entry : lista) {
+				System.out.printf("%-15s → %4d razy\n", entry.getKey(), entry.getValue());
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/pan_tadeusz/PoliczKazdeSlowo5c.java

+package pan_tadeusz;
+
+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/pan_tadeusz/PoliczKazdeSlowo5d.java

+package pan_tadeusz;
+
+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/pan_tadeusz/PoliczSlowaStream.java

+package pan_tadeusz;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+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/pan_tadeusz/PoliczWszystkieSlowa0.java

+package pan_tadeusz;
+
+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/pan_tadeusz/PoliczWszystkieSlowa1.java

+package pan_tadeusz;
+
+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/pan_tadeusz/SzukajSlowa_HashSet.java

+package pan_tadeusz;
+
+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/pan_tadeusz/SzukajSlowa_Lista.java

+package pan_tadeusz;
+
+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/pan_tadeusz/SzukajSlowa_Lista2.java

+package pan_tadeusz;
+
+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/pan_tadeusz/SzukajSlowa_Lista3.java

+package pan_tadeusz;
+
+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/pan_tadeusz/SzukajSlowa_Mapa.java

+package pan_tadeusz;
+
+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/pan_tadeusz/SzukajSlowa_TreeSet.java

+package pan_tadeusz;
+
+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/pan_tadeusz/SzukajSlowa_TreeSetCollator.java

+package pan_tadeusz;
+
+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/pan_tadeusz/WypiszHashSet.java

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