Skip to content

J
jvstd1
Commit 1e457c41 by Patryk Czarnik
Options

gotowe przykłądy na kolekcje itp

parent 8d650a74
Showing with 2988 additions and 0 deletions
src/main/java/p11_tablice/A_Wstep.java 0 → 100644
package p11_tablice;
import java.util.Arrays;
public class A_Wstep {
public static void main(String[] args) {
// Zamiast tworzyć wielu oddzielnych zmiennych:
String miasto1 = "Kraków";
String miasto2 = "Wrocław";
String miasto3 = "Łódź";
System.out.println("Miasto nr 1 to " + miasto1);
// można utworzyć tablicę wielu wartości:
String[] miasta = new String[5];
// Każdy element tablicy może być traktowany jak zmienna danego typu:
miasta[1] = "Kraków";
miasta[2] = "Wrocław";
miasta[3] = "Łódź";
System.out.println("Miasto nr 2 to " + miasta[2]);
// Jednak mając dane w tablicy uzyskujemy dodatkowe możliwości:
// Operacje wykonywane na całej tablicy, np. wypisanie całej tablicy
// uwaga - taki print nie wypisze zawartości:
System.out.println(miasta);
// Aby zobaczyć zawartość, trzeba użyć operacji Arrays.toString()
System.out.println(Arrays.toString(miasta));
// Przy okazji zauważamy, że numery pozycji w tablicy idą od 0.
// W tablicy rozmiaru 5 prawidłowe indeksy to liczby od 0 do 4
// Jeśli nie wpiszemy żadnej wartości w dane miejsce tablicy,
// to pozostaje tam wartość null (w przypadku typów obiektowych) lub 0 (w przypdaku typów int itp)
miasta[0] = "Warszawa";
miasta[4] = "Poznań";
System.out.println(Arrays.toString(miasta));
System.out.println();
// Aby wykonać czynność "dla każdego elementu tablicy",
// można użyć tzw pętli "for-each"
for(String m : miasta) {
System.out.println("Pozdrawiamy mieszkańców miasta " + m);
}
System.out.println();
// Tworząc tablicę, można też od razu podać jej zawartość:
int[] t = {5, 10, 15, -5, -10, -15, 0};
System.out.println("Tablica liczb o rozmiarze " + t.length);
System.out.println(Arrays.toString(t));
// przykład pętli, w której modyfikujemy elementy tablicy,
// zwiększa każdą liczbę o 1:
for(int i = 0; i < t.length; i++) {
t[i] += 1;
}
System.out.println(Arrays.toString(t));
/* to by nie zmieniło zawartości tablicy:
for(int x : t) {
x += 1;
}
*/
}
}
/*
int - typ prosty
Integer - typ obiektowy
BigInteger - typ obiektowy , bez ograniczenia na wielkość
tablice - rzecz "niskopoziomowa"
kolekcje: List, Set, Map - klasy, które służą do przechowywania danych,
"mądrzejsze" od tablic, ale czasami działają wolniej
*/
src/main/java/p11_tablice/B_Tworzenie.java 0 → 100644
package p11_tablice;
import java.math.BigDecimal;
import java.util.Arrays;
public class B_Tworzenie {
public static void main(String[] args) {
// Gdy tworzymy tablicę podając jej rozmiar,
// to jest ona automatycznie wypełniania wartościami:
// - 0 dla prostych typów liczbowych (int, long, double)
int[] liczby = new int[10];
System.out.println(Arrays.toString(liczby));
// łatwo wypełnić tablicę jednakowymi elementami
Arrays.fill(liczby, 13);
System.out.println(Arrays.toString(liczby));
// - false dla typu boolean
// - null dla wszystkich typów obiektowych, w tym String, Integer, BigDecimal, List ...
String[] napisy = new String[5];
BigDecimal[] ceny = new BigDecimal[3];
System.out.println(napisy);
System.out.println(ceny);
System.out.println();
double x = 55.55;
// Można też od razu podać listę wartości w nawiasach klamrowych (podczas deklaracji zmiennej tablicowej)
// Kompilator Javy sam policzy jaki ma być rozmiar tablicy
double[] d = {1.0, 3.14, Math.sqrt(2), liczby[2], x};
System.out.println("Tablica d ma rozmiar " + d.length);
System.out.println(Arrays.toString(d));
}
}
src/main/java/p11_tablice/C_Petle.java 0 → 100644
package p11_tablice;
import java.util.Arrays;
public class C_Petle {
public static void main(String[] args) {
String[] miasta = {"Warszawa", "Kraków", "Łódź", "Wrocław", "Poznań"};
int[] liczby = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};
System.out.println(Arrays.toString(miasta));
System.out.println(Arrays.toString(liczby));
System.out.println();
// Są dwa sposoby wykonywania czynności dla wszystkich elementów tablicy:
// 1) Tradycyjna pętla for / for z licznikiem
for(int i = 0; i < miasta.length; i++) {
System.out.println("! " + miasta[i]);
}
System.out.println();
for(int i = 0; i < liczby.length; i++) {
System.out.print(liczby[i] + "; ");
}
System.out.println();
System.out.println();
// 2) Pętla "for-each" / "enhanced for loop"
// Bezpośrednio przeglądamy elementy tablicy/kolekcji. Są one po kolei wpisywane na nową zmienną.
for(String miasto : miasta) {
System.out.println("* " + miasto);
}
System.out.println();
// zwróćmy uwagę, że to są elementy tablicy, a nie indeksy (pozycje)
for(int liczba : liczby) {
System.out.print(liczba + ", ");
}
System.out.println();
System.out.println();
System.out.println();
// Pętla for-each nie nadaje się do modyfikowania zawartości tablicy.
System.out.println(Arrays.toString(liczby));
System.out.println();
System.out.println("w pętli for-each próbuję zmieniać wartości...");
for (int x : liczby) {
x++;
// modyfikowanie zmiennej w for-each nie wpływa na zawartość tablicy
// w x mamy kopię wartości, a nie "referencję do miejsca w tablicy"
}
System.out.println();
System.out.println(Arrays.toString(liczby)); // liczby się nie zmieniły
System.out.println();
// Jeśli chcemy modyfikować elementy tablicy, to w praktyce uzywamy tradycyjnej pętli for
System.out.println("w zwykłym for zmieniam wartości");
for (int i = 0; i < liczby.length; i++) {
System.out.println(liczby[i] + " -> " + (liczby[i]+1));
liczby[i]++;
}
System.out.println(Arrays.toString(liczby));
// Zwykłe pętli for używamy też wtedy, gdy algorytm wymaga jednoczesnego dostępu do różnych elementów.
}
}
src/main/java/p11_tablice/D_Dwuwymiarowe.java 0 → 100644
package p11_tablice;
import java.util.Arrays;
public class D_Dwuwymiarowe {
public static void main(String[] args) {
// Tablice wielowymiarowe... To tak naprawdę tablice tablic.
// Tutaj powstanie 3-elementowa tablica, której elementami są tablice typu int[]
// z których każda ma 5 elementów int.
int[][] a = new int[3][5];
//NK int[][] a2 = new int[3,5];
System.out.println(a.length); // 3
System.out.println(a[0].length); // 5
System.out.println();
// regularna macierz
a[0][4] = 44;
a[1][2] = 22;
System.out.println(a[0][4]);
System.out.println("a: " + a + " , zawartość: " + Arrays.toString(a));
System.out.println("a[0]: " + a[0]+ " , zawartość: " + Arrays.toString(a[0]));
System.out.println();
System.out.println(Arrays.toString(a));
System.out.println(Arrays.deepToString(a));
System.out.println();
// Można nie wypełniać od razu wierszy jednakowymi tablicami,
// ale początkowo zostawić null-e i dopiero potem wpisać poszczególne wiersz.
// Wtedy mogą być one nawet różnej długości.
int[][] b = new int[4][];
System.out.println(Arrays.toString(b));
// inicjujemy poszczególne wiersze
b[0] = new int[7];
Arrays.fill(b[0], 9);
b[1] = new int[] {3, 4, 5};
b[2] = null;
b[3] = new int[0]; // pusta tablica i null to są różne rzeczy
System.out.println(Arrays.deepToString(b));
// Można użyć notacji {} także do wypełniania tablic wielowymiarowych.
String[][] c = {
{"Ala", "Ola", "Ela"},
{"Jacek", "Placek"},
null,
{},
};
System.out.println(Arrays.deepToString(c));
}
}
src/main/java/p11_tablice/Kopiowanie1.java 0 → 100644
package p11_tablice;
import java.util.Arrays;
public class Kopiowanie1 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6,7,8,9};
// clone(), copyOf(), copyOfRange() - tworzą nową tablicę wypełnioną takimi samymi danymi (lub fragment)
int[] b = a.clone();
int[] c = Arrays.copyOf(a, 5);
int[] d = Arrays.copyOf(a, 12);
int[] e = Arrays.copyOfRange(a, 4, 8);
int[] f = Arrays.copyOfRange(a, 4, 12);
// arraycopy: Docelowa tablica musi istnieć
int[] g = new int[8];
System.arraycopy(a, 2, g, 1, 5);
// Referencja do tej samej tablicy (do tego samego obiektu)
// Zmiany w tablicy a będą widziane przez zmienną r i vice versa
int[] r = a;
System.out.println("a: " + Arrays.toString(a));
System.out.println("b: " + Arrays.toString(b));
System.out.println("c: " + Arrays.toString(c));
System.out.println("d: " + Arrays.toString(d));
System.out.println("e: " + Arrays.toString(e));
System.out.println("f: " + Arrays.toString(f));
System.out.println("g: " + Arrays.toString(g));
System.out.println("r: " + Arrays.toString(r));
System.out.println();
System.out.println("Zmieniam a w środku");
a[0]=13;
a[1]++;
a[2]+=10;
a[3]*=5;
System.out.println("a: " + Arrays.toString(a));
System.out.println("b: " + Arrays.toString(b));
System.out.println("c: " + Arrays.toString(c));
System.out.println("d: " + Arrays.toString(d));
System.out.println("e: " + Arrays.toString(e));
System.out.println("f: " + Arrays.toString(f));
System.out.println("g: " + Arrays.toString(g));
System.out.println("r: " + Arrays.toString(r));
System.out.println();
System.out.println("Na a wpisuję nową tablicę");
a = new int[] {77,88,99};
System.out.println("a: " + Arrays.toString(a));
System.out.println("b: " + Arrays.toString(b));
System.out.println("r: " + Arrays.toString(r));
}
}
src/main/java/p11_tablice/Kopiowanie2.java 0 → 100644
package p11_tablice;
import java.util.Arrays;
public class Kopiowanie2 {
public static void main(String[] args) {
int[][] a = {{1,2,3,4,5}, {10,20,30,40}};
int[][] r = a;
int[][] b = a.clone();
System.out.println(Arrays.deepToString(a));
System.out.println(Arrays.deepToString(r));
System.out.println(Arrays.deepToString(b));
System.out.println();
a[1][1] = 77; // zmienia się w a i b
System.out.println(Arrays.deepToString(a));
System.out.println(Arrays.deepToString(r));
System.out.println(Arrays.deepToString(b));
System.out.println();
a[0] = new int[] {300, 400, 500}; // zmienia się tylko w a (i r)
System.out.println(Arrays.deepToString(a));
System.out.println(Arrays.deepToString(r));
System.out.println(Arrays.deepToString(b));
System.out.println();
}
}
src/main/java/p11_tablice/Kopiowanie3.java 0 → 100644
package p11_tablice;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicInteger;
public class Kopiowanie3 {
public static void main(String[] args) {
AtomicInteger[] t = new AtomicInteger[4];
t[0] = new AtomicInteger(5);
t[1] = new AtomicInteger(10);
AtomicInteger[] kopia = t.clone();
System.out.println(Arrays.toString(t));
System.out.println(Arrays.toString(kopia));
t[0].addAndGet(100); // widać w kopii
t[1] = new AtomicInteger(333); // nie widać w kopii
System.out.println(Arrays.toString(t));
System.out.println(Arrays.toString(kopia));
}
}
src/main/java/p11_tablice/Srednia.java 0 → 100644
package p11_tablice;
import java.util.Arrays;
import java.util.stream.IntStream;
public class Srednia {
public static void main(String[] args) {
// Mamy przykładową tablicę, np ocen
int[] oceny = {5, 4, 4, 3, 4, 3};
// Oblicz średnią z liczb, które są w tablicy:
// wersja "nieskalowalna", dobra tylko dla kilku elementów
double srednia1 = (oceny[0] + oceny[1] + oceny[2] + oceny[3] + oceny[4] + oceny[5]) / 6.0;
System.out.println(srednia1);
// zamiast wypisywać oceny[0], oceny[1] itd, musimy te składniki dodawać w pętli
// Aby mieć miejsce, do którego można dodawać składniki, tworzymy zmienną typu "skarbonka".
// W tej wersji stosuję pętlę "for z licznikiem"
int suma = 0;
for(int i = 0; i < oceny.length; i++) {
suma = suma + oceny[i];
}
// Zarówno suma, jak i length to są inty. Aby wynik obejmował część ułamkową, trzeba sumę zrzutować na double
// double srednia2 = (double)suma / oceny.length;
// Można też pomnożyć przez 1.0
double srednia2 = 1. * suma / oceny.length;
System.out.println(srednia2);
// ostatnia wersja: zmienna suma od razu będzie typu double,
// użyjemy pętli for-each
double suma3 = 0;
for(int ocena : oceny) {
suma3 += ocena;
}
double srednia3 = suma3 / oceny.length;
System.out.println(srednia3);
// Istnieją też gotowe rozwiązania, które w Javie oparte są o tzw. "strumienie"
double srednia4 = IntStream.of(oceny).average().getAsDouble();
System.out.println(srednia4);
double srednia5 = Arrays.stream(oceny).average().orElse(0);
System.out.println(srednia5);
}
}
src/main/java/p12_kolekcje/A_Wprowadzenie.java 0 → 100644
package p12_kolekcje;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
public class A_Wprowadzenie {
public static void main(String[] args) {
// W języku Java mamy tablice:
int[] ti = new int[10];
String[] ts = {"Ala", "Ola", "Ela"};
System.out.println(Arrays.toString(ti));
System.out.println(Arrays.toString(ts));
// Tablice mają swoje ograniczenia:
// - nie posiadają metod, a pewne ogólne operacje dla tablic są dostępne w klasie Arrays
Arrays.fill(ti, 4);
System.out.println(Arrays.toString(ti));
// - nie da się zmienić rozmiaru istniejącej tablicy; nie ma operacji "dodaj nowy element na końcu"
// ewentualnie można użyć copyOf, aby stworzyć NOWĄ większą tablicę, ale to jest kosztowne i nie zawsze wygodne
ts = Arrays.copyOf(ts, 5);
ts[3] = "Ula";
System.out.println(Arrays.toString(ts));
System.out.println();
// Kolekcja to klasa, której obiekty służą do przechowywania w pamięci wielu obiektów.
// Główne rodzaje kolekcji: List, Queue, Set, Map, przy czym Map nie jest podinterfejsem interfejsu Collection
List<String> lista = new ArrayList<>();
// dodawanie elementu na koniec:
lista.add("Adam");
lista.add("Ludwik");
lista.add("Xawery");
System.out.println(lista + " size = " + lista.size());
// Dla kolekcji działa pętla for-each
for(String s : lista) {
System.out.println("Witaj " + s);
}
// Listy - ale już nie inne kolekcje - posiadają metody get oraz set, które dają dostęp do elementów o określonym numerze
System.out.println("Element nr 2 to jest " + lista.get(2));
lista.set(2, "Ksawery");
lista.add("Adam");
System.out.println("Element nr 2 to teraz jest " + lista.get(2));
System.out.println(lista);
System.out.println();
// Kolejki tu pomińmy...
// Zbiór:
// - nie zawiera duplikatów
// - ma prawo zmienić kolejność elementów - ale to zależy, której klasy użyjemy
// - nie są dostępne operacje get(i) itp.
Set<String> zbior = new HashSet<>();
zbior.add("Warszawa");
zbior.add("Kraków");
zbior.add("Katowice");
System.out.println(zbior);
zbior.add("Kraków");
System.out.println(zbior);
// operacja add zwraca true, jeśli element został dodany, a false, jeśli nie został dodany (bo już istniał)
// Dla zbiorów operacja contains (sprawdzająca, czy element należy) działa wydajnie.
if(zbior.contains("Katowice")) {
System.out.println("Katowice są");
}
// słownik / mapa służy do przechowywania par klucz → wartość
Map<String, Integer> cennik = new HashMap<>();
cennik.put("kawa", 15);
cennik.put("herbata", 19);
cennik.put("ciastko", 22);
System.out.println(cennik);
System.out.println("cena kawy: " + cennik.get("kawa"));
System.out.println("cena szampana: " + cennik.get("szampan")); // brak klucza → null
cennik.put("ciastko", 19);
System.out.println(cennik);
System.out.println();
// Można utworzyć jeden kolekcji na podstawie innego:
Set<String> zbiorImion = new TreeSet<>(lista);
System.out.println(zbiorImion);
// Nie istnieją kolekcje typów prostych - zawsze trzeba użyć klasy
// List<int> liczby = new ArrayList<>();
List<Integer> liczby = new ArrayList<>();
liczby.addAll(List.of(5, 10, 15, 20, 25));
System.out.println(liczby);
}
}
src/main/java/p12_kolekcje/SzukajSlow.java 0 → 100644
package p12_kolekcje;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.Scanner;
public class SzukajSlow {
public static void main(String[] args) {
// Wczytamy wszystkie linie Pana Tadeusza do listy
try {
List<String> lines = Files.readAllLines(Paths.get("pliki", "pan_tadeusz.txt"), Charset.forName("utf-8"));
System.out.println("Wczytano " + lines.size() + " linie");
// jednorazowo albo w pętli:
// pytaj użytkownika, jakiego słowa szuka
// następnie oblicz, w ilu liniach to słowo (ten fragment) występuje i wypisz wynik
Scanner scanner = new Scanner(System.in);
while(true) {
System.out.print("Czego szukasz? ");
String szukane = scanner.nextLine();
if(szukane.isEmpty())
break;
int ile = 0;
for(String line : lines) {
if(line.contains(szukane)) {
ile++;
}
}
System.out.println(ile + " razy");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
src/main/java/p12_kolekcje/sortowanie/KomparatorDlugosciNapisow.java 0 → 100644
package p12_kolekcje.sortowanie;
import java.util.Comparator;
public class KomparatorDlugosciNapisow implements Comparator<String> {
@Override
public int compare(String s1, String s2) {
// Taka metoda ma za zadanie zwrócić:
// - wartość ujemną, jeśli lewy element jest mniejszy
// - wartość dodatnią, jeśli lewy element jest większy
// - zero, jeśli oba są równe
// W tej wersji bierzemy pod uwagę długości napisów.
return s1.length() - s2.length();
}
}
src/main/java/p12_kolekcje/sortowanie/Sortowanie.java 0 → 100644
package p12_kolekcje.sortowanie;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.TreeSet;
public class Sortowanie {
public static void main(String[] args) {
String[] tablica = {"Ola", "ala", "Ala", "Marek", "Łukasz", "Ącki", "Alamakota", "Ab", "Żaneta", "Lucek", "Ala", "23"};
List<String> lista = new ArrayList<>(List.of(tablica));
System.out.println(lista);
// sortowanie listy w sposób domyślny od Javy 8 zapisuje się tak:
lista.sort(null);
// w przypadku Stringów oznacza to sortowanie wg kodów Unicode
System.out.println(lista);
// Istnieje też taki sposób, dostępny też w starszych wersjach Javy:
Collections.sort(lista);
System.out.println(lista);
// Wprowadzenie w temat Comparatorów.
// Comparator to jest taka maszynka, która (w metodzie compare) jak waga porównuje dwa obiekty
// Możemy sami stworzyć własny Comparator - tutaj jest to klasa KomparatorDlugosciNapisow
KomparatorDlugosciNapisow komparator = new KomparatorDlugosciNapisow();
lista.sort(komparator);
System.out.println(lista);
// Komparatory można też tworzyć jako klasy anonimowe oraz (od Java 8) wyrażenia lambda
lista.sort((s1, s2) -> s2.length() - s1.length());
System.out.println(lista);
System.out.println();
// SORTOWANIE ZGODNE Z ALFABETEM
// Klasa Collator jest takim gotowym Comparatorem, który porównuje napisy zgodnie z alfabetem jakiegoś ludzkiego języka
// sortowanie zgodne z bieżącymi ustawieniami komputera:
lista.sort(Collator.getInstance());
System.out.println(lista);
// sortownaie zgodne z określonym językiem
lista.sort(Collator.getInstance(Locale.FRANCE));
System.out.println(lista);
lista.sort(Collator.getInstance(Locale.of("pl", "PL")));
System.out.println(lista);
System.out.println();
// Sortować można też tablice
// sposób domyślny:
Arrays.sort(tablica);
System.out.println(Arrays.toString(tablica));
// w oparciu o podany komparator:
Arrays.sort(tablica, Collator.getInstance());
System.out.println(Arrays.toString(tablica));
System.out.println();
// Comparator / Collator może być też wykorzystany podczas tworzenia TreeSet i TreeMap
Set<String> zbior = new TreeSet<>(Collator.getInstance());
zbior.add("Łukasz");
zbior.add("Lucek");
zbior.add("Marek");
System.out.println(zbior);
}
}
src/main/java/p12_kolekcje/teoria/DeklaracjeGeneryczne.java 0 → 100644
package p12_kolekcje.teoria;
import java.util.ArrayList;
import java.util.List;
public class DeklaracjeGeneryczne {
public static void main(String[] args) {
List l1 = new ArrayList();
ArrayList l2 = new ArrayList();
List<String> l3 = new ArrayList<String>();
List<String> l4 = new ArrayList<>(); // diamond operator od Javy 7
List<String> l5 = new ArrayList();
List l6 = new ArrayList<>(); // lista Object-ów
//NK List<> l7 = new ArrayList<String>();
List<List<Integer>> l8 = new ArrayList<>();
//NK List<List<Integer>> l9 = new ArrayList<<>>();
//NK List<List<Integer>> l10 = new ArrayList<List<>>();
List<List<Integer>> l11 = new ArrayList<List<Integer>>();
//NK List<int> l12 = new ArrayList<>();
List<int[]> l13 = new ArrayList<>();
// "lista nie wiadomo czego"
// w praktyce takiej listy mogę używać tylko do odczytu, nie mogę w niej niczego zapisać
List<?> l14 = new ArrayList<>();
List<?> l15 = new ArrayList<String>();
// l15.add("ala");
// to nie to samo, co lista Objectów, bo np lista Stringów nie jest tym samym co lista Objectów, i nie można wpisać
//NK List<Object> l16 = new ArrayList<String>();
}
}
src/main/java/p12_kolekcje/teoria/ListNoweOperacje.java 0 → 100644
package p12_kolekcje.teoria;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
public class ListNoweOperacje {
public static void main(String[] args) {
ArrayList<String> lista = new ArrayList<>();
lista.add("Ala");
lista.add("Ola");
lista.add("Kasia");
lista.add("Ela");
lista.add("Łucja");
lista.add("Ula");
lista.add("Asia");
lista.add("Zosia");
System.out.println(lista);
System.out.println();
lista.sort(null);
// lista.sort(Comparator.reverseOrder());
lista.sort(Collator.getInstance());
// lista.sort(Collator.getInstance(Locale.CHINA));
// lista.sort(Collator.getInstance().reversed());
System.out.println(lista);
System.out.println();
lista.forEach(s -> System.out.print(s + ", "));
System.out.println();
System.out.println();
// jeden sposób skopiownaia listy - wymaga tego, aby zmienna lista była typu ArrayList (a nie wystarczy List)
List<String> lista1 = (List<String>)lista.clone();
System.out.println(lista1);
// predykat; operacja usuwa z listy wszystkie spełaniające warunek
lista1.removeIf(s -> s.length() <= 3);
System.out.println(lista1);
System.out.println();
// drugi (lepszy) sposób kopiowania listy: konstruktor z parametrem "inna kolekcja / źródło danych"
List<String> lista2 = new ArrayList<>(lista);
System.out.println(lista2);
lista2.replaceAll(s -> s.toUpperCase()); // lambda expression
// lista2.replaceAll(String::toUpperCase); // method reference - w tym przypadku równoważnie
System.out.println(lista2);
System.out.println();
}
}
src/main/java/p12_kolekcje/teoria/ListOperacje.java 0 → 100644
package p12_kolekcje.teoria;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class ListOperacje {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
System.out.println(lista);
// dodaje na koniec
lista.add("ola");
lista.add("ala");
boolean coSieStalo = lista.add("ela");
System.out.println(coSieStalo);
if(lista.add("iza")) {
System.out.println("Iza też");
}
System.out.println(lista);
System.out.println();
// odczyt z określonej pozycji, numeracja od 0 jak w tablicach
String x = lista.get(0); // lista[0] - tak się nie da
System.out.println(x);
x = lista.get(2);
System.out.println(x);
//EXN x = lista.get(lista.size());
// System.out.println(x);
// dodaje na okreslona pozycje, przesuwa dotychczasowe elementy w prawo
// tu może być od 0 do 4, ale już nie 5 (IOOBExn)
lista.add(2, "ewa");
lista.add(lista.size(), "ostatnia"); // OK
System.out.println(lista);
// nadpisuje element na podanej pozycji nowym elementem
lista.set(2, "ula");
System.out.println(lista);
System.out.println();
lista.add(0, "ala");
System.out.println(lista);
// usuwa z określonej pozycji, zwraca obiekt
String wynik = lista.remove(3);
System.out.println("usunąłem element : " + wynik);
System.out.println(lista);
// to by usunęło od razu wszystkie wystąpienia elementu "ala"
// boolean b = lista.removeAll(Collections.singleton("ala"));
// to usuwa pierwsze wystąpienie, elementy są porównywane za pomocą equals, wynik boolean mówi czy element został usunięty
boolean b = lista.remove("ala");
System.out.println("bool : " + b);
System.out.println(lista);
b = lista.remove("ala");
System.out.println("bool : " + b);
System.out.println(lista);
b = lista.remove("ala");
System.out.println("bool : " + b);
System.out.println(lista);
System.out.println();
lista.addAll(Arrays.asList("ola", "ela", "ewa", "kasia", "marysia", "aga"));
System.out.println(lista);
System.out.println("indexOf: " + lista.indexOf("ewa"));
System.out.println("contains: " + lista.contains("ewa"));
System.out.println();
System.out.println("indexOf: " + lista.indexOf("Ewa")); // -1
System.out.println("contains: " + lista.contains("Ewa")); // false
System.out.println();
Collections.sort(lista);
System.out.println(lista);
for(String s : lista) {
System.out.println("Kolejny element: " + s);
}
}
}
src/main/java/p12_kolekcje/teoria/ListyIZbiory.java 0 → 100644
package p12_kolekcje.teoria;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.TreeSet;
public class ListyIZbiory {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<>();
LinkedList<String> lista = new LinkedList<>();
HashSet<String> hasz = new HashSet<>();
LinkedHashSet<String> linkedHasz = new LinkedHashSet<>();
TreeSet<String> drzewo = new TreeSet<>();
al.add("ala"); lista.add("ala"); drzewo.add("ala"); hasz.add("ala"); linkedHasz.add("ala");
al.add("ola"); lista.add("ola"); drzewo.add("ola"); hasz.add("ola"); linkedHasz.add("ola");
al.add("ela"); lista.add("ela"); drzewo.add("ela"); hasz.add("ela"); linkedHasz.add("ela");
al.add("ula"); lista.add("ula"); drzewo.add("ula"); hasz.add("ula"); linkedHasz.add("ula");
al.add("ola"); lista.add("ola"); drzewo.add("ola"); hasz.add("ola"); linkedHasz.add("ola");
System.out.println("ArrayList: "+al);
System.out.println("LinkedList: "+lista);
System.out.println("TreeSet: "+drzewo);
System.out.println("HashSet: "+hasz);
System.out.println("LinkedHashSet: "+linkedHasz);
System.out.println();
// dla wszystkich list wolno działa operacja contains / indexOf
System.out.println(al.contains("ela"));
// dla wszystkich zbiorów szybko działa operacja contains
System.out.println(hasz.contains("ela"));
}
}
src/main/java/p12_kolekcje/teoria/PorownanieSzybkosciList.java 0 → 100644
package p12_kolekcje.teoria;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class PorownanieSzybkosciList {
public static void testujListe(List<Integer> lista) {
long start, koniec;
int suma;
System.out.print("Wstawianie 250 tys. na koniec listy (add)... ");
start = System.currentTimeMillis();
for(int i=0; i<250000; i++) {
lista.add(i);
}
koniec = System.currentTimeMillis();
System.out.println(koniec - start + " ms");
lista.clear(); // usuwa całą zawartość
System.out.print("Wstawianie 500 tys. na koniec listy (add)... ");
start = System.currentTimeMillis();
for(int i=0; i<500000; i++) {
lista.add(i);
}
koniec = System.currentTimeMillis();
System.out.println(koniec - start + " ms");
System.out.println("\nDodawanie na początek... ");
start = System.currentTimeMillis();
Integer nowyElement = 333;
for(int i=0; i < 10000; i++) {
lista.add(0, nowyElement);
// Szybko dla LinkedList, wolno dla ArrayList
}
koniec = System.currentTimeMillis();
System.out.println(koniec - start + " ms");
System.out.println("\nWybieranie po indeksie... ");
start = System.currentTimeMillis();
suma = 0;
for(int i=0; i < 5000; i++) {
suma += lista.get(i * 100);
// Szybkie dla ArrayList, wolne dla LinkedList
}
koniec = System.currentTimeMillis();
System.out.println(koniec - start + " ms");
System.out.println("wynik="+suma);
System.out.println("\nOdczytanie wszystkich elementów foreach");
start = System.currentTimeMillis();
suma = 0;
for(int x : lista) {
suma += x;
}
koniec = System.currentTimeMillis();
System.out.println(koniec - start + " ms");
System.out.println("wynik="+suma);
}
public static void main(String[] args) {
List<Integer> linked = new LinkedList<>();
List<Integer> tablicowa = new ArrayList<>();
System.out.println("LinkedList:");
testujListe(linked);
System.out.println("\n\n================");
System.out.println("ArrayList:");
testujListe(tablicowa);
}
}
src/main/java/p12_kolekcje/teoria/Slowniki.java 0 → 100644
package p12_kolekcje.teoria;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class Slowniki {
public static void main(String[] args) {
Map<String, Integer> hasz = new HashMap<>();
Map<String, Integer> linkedHasz = new LinkedHashMap<>();
Map<String, Integer> drzewo = new TreeMap<>();
hasz.put("ala", 20); drzewo.put("ala", 20); linkedHasz.put("ala", 20);
hasz.put("ola", 30); drzewo.put("ola", 20); linkedHasz.put("ola", 30);
hasz.put("ela", 20); drzewo.put("ela", 20); linkedHasz.put("ela", 20);
hasz.put("ula", 55); drzewo.put("ula", 55); linkedHasz.put("ula", 55);
System.out.println(hasz.get("ela")); //20
System.out.println(hasz.get("ewa")); //null
System.out.println(hasz.containsKey("ela")); // szybkie
System.out.println(hasz.containsValue(55)); // wolne
System.out.println("\nTreeMap: "+drzewo);
System.out.println("HashMap: "+hasz);
System.out.println("LinkedHashMap: "+linkedHasz);
System.out.println("====================================\n");
hasz.put("ola", 31); drzewo.put("ola", 31); linkedHasz.put("ola", 31);
System.out.println("TreeMap: "+drzewo);
System.out.println("HashMap: "+hasz);
System.out.println("LinkedHashMap: "+linkedHasz);
System.out.println("\nWszystkie wpisy:");
for(Map.Entry<String, Integer> entry : drzewo.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}
System.out.println("\nWszystkie klucze:");
for(String s : drzewo.keySet()) {
System.out.println(s);
}
System.out.println("\nWszystkie wartości:");
for(Integer i : drzewo.values()) {
System.out.println(i);
}
// Można też przypisać na zmienne:
Set<Map.Entry<String, Integer>> zbiorWpisow = hasz.entrySet();
Set<String> klucze = hasz.keySet();
Collection<Integer> wartosci = hasz.values();
// Jak zrobić listę kluczy?
List<String> kluczel = new ArrayList<>(hasz.keySet());
}
}
src/main/java/p12_kolekcje/zbieranie_danych/P1_Tablica.java 0 → 100644
package p12_kolekcje.zbieranie_danych;
import java.util.Arrays;
import java.util.Scanner;
public class P1_Tablica {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Podczas tworzenia tablicy musimy wiedzieć, ile elementów ma mieć.
System.out.print("Ile imion podasz? ");
int size = scanner.nextInt();
scanner.nextLine(); // ingorujemy resztę linii, co ma znaczenie nawet, jeśli jest pusta
String[] tablica = new String[size];
for(int i = 0; i < tablica.length; i++) {
System.out.print("Podaj imię nr " + i + ": ");
String imie = scanner.nextLine();
tablica[i] = imie;
}
System.out.println(Arrays.toString(tablica));
System.out.println();
// Drugi etap: użytkownik podaje numer, a program odczytuje wartość z podanej pozycji.
// -1 kończy
while(true) {
System.out.print("Podaj nr pozycji: ");
int pozycja = scanner.nextInt();
scanner.nextLine();
if(pozycja == -1) {
break;
}
try {
String imie = tablica[pozycja];
System.out.println("Osoba nr " + pozycja + " to " + imie);
} catch (Exception e) {
System.out.println(e);
}
}
}
}
src/main/java/p12_kolekcje/zbieranie_danych/P2_Lista.java 0 → 100644
package p12_kolekcje.zbieranie_danych;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import javax.print.attribute.standard.Sides;
public class P2_Lista {
// Listy:
// - mogą zawierać duplikaty (tę wartość kilka razy),
// - przechowują elementy na określonych pozycjach od 0 do size-1,
// za pomocą get(i) można odczytać, a za pomocą set(i, nowaWartosc) zmienić konkretny element listy
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Gdy używamy listy nie musimy z wyprzedzeniem znać jej rozmiaru.
// Do listy zawsze można dodać kolejny element na końcu (*)
// (*) - realnymi ograniczeniami są: 1) rozmiar int, 2) dostępna pamięć
List<String> lista = new ArrayList<>();
while(true) {
System.out.print("Podaj imię: ");
// pusty String oznacza koniec
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
lista.add(imie);
}
System.out.println("Liczba odczytanych elementów: " + lista.size());
System.out.println(lista);
System.out.println();
// Drugi etap: użytkownik podaje numer, a program odczytuje wartość z podanej pozycji.
// -1 kończy
while(true) {
System.out.print("Podaj nr pozycji: ");
int pozycja = scanner.nextInt();
scanner.nextLine();
if(pozycja == -1) {
break;
}
try {
String imie = lista.get(pozycja);
System.out.println("Osoba nr " + pozycja + " to " + imie);
} catch (Exception e) {
System.out.println(e);
}
}
}
}
src/main/java/p12_kolekcje/zbieranie_danych/P2_Lista_Sortowanie.java 0 → 100644
package p12_kolekcje.zbieranie_danych;
import java.text.Collator;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import javax.print.attribute.standard.Sides;
public class P2_Lista_Sortowanie {
// Listy:
// - mogą zawierać duplikaty (tę wartość kilka razy),
// - przechowują elementy na określonych pozycjach od 0 do size-1,
// za pomocą get(i) można odczytać, a za pomocą set(i, nowaWartosc) zmienić konkretny element listy
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Gdy używamy listy nie musimy z wyprzedzeniem znać jej rozmiaru.
// Do listy zawsze można dodać kolejny element na końcu (*)
// (*) - realnymi ograniczeniami są: 1) rozmiar int, 2) dostępna pamięć
List<String> lista = new ArrayList<>();
while(true) {
System.out.print("Podaj imię: ");
// pusty String oznacza koniec
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
lista.add(imie);
}
System.out.println("Liczba odczytanych elementów: " + lista.size());
System.out.println(lista);
System.out.println("Sortowanie...");
lista.sort(Collator.getInstance());
System.out.println(lista);
System.out.println();
// Drugi etap: użytkownik podaje numer, a program odczytuje wartość z podanej pozycji.
// -1 kończy
while(true) {
System.out.print("Podaj nr pozycji: ");
int pozycja = scanner.nextInt();
scanner.nextLine();
if(pozycja == -1) {
break;
}
try {
String imie = lista.get(pozycja);
System.out.println("Osoba nr " + pozycja + " to " + imie);
} catch (Exception e) {
System.out.println(e);
}
}
}
}
src/main/java/p12_kolekcje/zbieranie_danych/P3_HashSet.java 0 → 100644
package p12_kolekcje.zbieranie_danych;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class P3_HashSet {
// Zbiory:
// - nie zawierają duplikatów (dodanie kolejny raz tej samej wartości nie zmienia już zbioru),
// - mają prawo zmienić kolejność elementów
// → HashSet zmienia kolejność (wg własnych zasad w oparciu o haszkody, na co nie mamy wpływu)
// → LinkedHashSet nie zmienia kolejności (zachowuje początkową kolejność, w jakiej elementy były dodawane)
// → TreeSet samoczynnie sortuje elementy
// Podstawową (i wydajną) operacją dla zbioru jest sprawdzenie czy element należy do zbioru.
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Set<String> zbior = new HashSet<>();
while(true) {
System.out.print("Podaj imię: ");
// pusty String oznacza koniec
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
zbior.add(imie);
}
System.out.println(zbior);
System.out.println();
// Drugi etap: użytkownik podaje imię, a program sprawdza, czy takie imię istnieje - to jest najbardziej podstawowa operacja dla zbiorów.
// pusty string kończy
while(true) {
System.out.print("Podaj imię: ");
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
if(zbior.contains(imie)) {
System.out.println("TAK");
} else {
System.out.println("NIE");
}
}
}
}
src/main/java/p12_kolekcje/zbieranie_danych/P4_TreeSet.java 0 → 100644
package p12_kolekcje.zbieranie_danych;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class P4_TreeSet {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Set<String> zbior = new TreeSet<>();
while(true) {
System.out.print("Podaj imię: ");
// pusty String oznacza koniec
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
zbior.add(imie);
}
System.out.println(zbior);
System.out.println();
// Drugi etap: użytkownik podaje imię, a program sprawdza, czy takie imię istnieje - to jest najbardziej podstawowa operacja dla zbiorów.
// pusty string kończy
while(true) {
System.out.print("Podaj imię: ");
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
if(zbior.contains(imie)) {
System.out.println("TAK");
} else {
System.out.println("NIE");
}
}
}
}
src/main/java/p12_kolekcje/zbieranie_danych/P5_HashMap.java 0 → 100644
package p12_kolekcje.zbieranie_danych;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class P5_HashMap {
// Słowniki (mapy):
// - zawierają pary klucz → wartość
// - klucze nie mogą się powtarzać, wartości mogą
// - wydajne są operacje dodawanie elementu i pobierania/wyszukiwania poprzez klucz
// - niewydaje jest wyszukiwanie poprzez wartość
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// W tym słowniku dla imienia osoby pamiętamy wiek tej osoby.
// String (mię) jest kluczem, Integer (wiek) jest wartością.
Map<String, Integer> slownik = new HashMap<>();
while(true) {
System.out.print("Podaj imię: ");
// pusty String oznacza koniec
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
System.out.print("Podaj wiek: ");
int wiek = scanner.nextInt();
scanner.nextLine();
slownik.put(imie, wiek);
}
System.out.println(slownik);
System.out.println();
// Drugi etap: użytkownik podaje imię, a program odczytuje wartość ze słownika (czyli wiek tej osoby)
while(true) {
System.out.print("Podaj imię: ");
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
// podstawową operacją do odczytywania danych ze słownika jest get(klucz)
// jeśli istnieje wpis o podanym kluczu, to wynikiem jest wartość spod tego klucza
// jeśli nie istnieje, to wynikiem jest null
// w związku z tym gdy czytamy dane ze słownika bez wcześniejszego sprawdzenia, czy klucz istnieje,
// trzeba użyć zmiennej typu obiektowego (tutaj Integer, a nie int)
Integer wiek = slownik.get(imie);
if(wiek == null) {
System.out.println("W słowniku nie osoby " + imie);
} else {
System.out.println("Osoba " + imie + " ma " + wiek + " lat");
}
// Można też użyć operacji containsKey do sprawdzenia, czy słownik zawiera podany klucz
// if(slownik.containsKey(imie)) {
// System.out.println("Osoba " + imie + " ma " + slownik.get(imie) + " lat.");
// } else {
// System.out.println("W słowniku nie osoby " + imie);
// }
}
}
}
src/main/java/p12_kolekcje/zbieranie_danych/P6_TreeMap.java 0 → 100644
package p12_kolekcje.zbieranie_danych;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class P6_TreeMap {
// Podobnie, jak w przypadku zbiorów (Set), dla słowników (Map) mamy takie implementacje,
// które róznią się kolejnością danych:
// - HashMap - kolejność techniczna / chaotyczna
// - LinkedHashMap - kolejność, w jakiej elementy były dodawane po raz pierwszy
// - TreeMap - dane posortowane wg kluczy
// W zaawansowanych zastosowaniach ważną implementacją słowników jest ConcurrentHashMap,
// która poprawnie i wydajnie działa w aplikacjach wielowątkowych (rózne wątki mogą korzytać jednocześnie).
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// W tym słowniku dla imienia osoby pamiętamy wiek tej osoby.
// String (mię) jest kluczem, Integer (wiek) jest wartością.
Map<String, Integer> slownik = new TreeMap<>();
while(true) {
System.out.print("Podaj imię: ");
// pusty String oznacza koniec
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
System.out.print("Podaj wiek: ");
int wiek = scanner.nextInt();
scanner.nextLine();
slownik.put(imie, wiek);
}
System.out.println(slownik);
System.out.println();
// Drugi etap: użytkownik podaje imię, a program odczytuje wartość ze słownika (czyli wiek tej osoby)
while(true) {
System.out.print("Podaj imię: ");
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
// podstawową operacją do odczytywania danych ze słownika jest get(klucz)
// jeśli istnieje wpis o podanym kluczu, to wynikiem jest wartość spod tego klucza
// jeśli nie istnieje, to wynikiem jest null
// w związku z tym gdy czytamy dane ze słownika bez wcześniejszego sprawdzenia, czy klucz istnieje,
// trzeba użyć zmiennej typu obiektowego (tutaj Integer, a nie int)
Integer wiek = slownik.get(imie);
if(wiek == null) {
System.out.println("W słowniku nie osoby " + imie);
} else {
System.out.println("Osoba " + imie + " ma " + wiek + " lat");
}
// Można też użyć operacji containsKey do sprawdzenia, czy słownik zawiera podany klucz
// if(slownik.containsKey(imie)) {
// System.out.println("Osoba " + imie + " ma " + slownik.get(imie) + " lat.");
// } else {
// System.out.println("W słowniku nie osoby " + imie);
// }
}
}
}
src/main/java/p12_kolekcje/zbieranie_danych/P7_Queue.java 0 → 100644
package p12_kolekcje.zbieranie_danych;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class P7_Queue {
// Kolejka to struktura danych zoptymalizowana pod kątem dostępu do "następnego elementu"
// (operacja poll() lub get()).
// * Kolejka prosta (FIFO) zachowuje kolejność elementów i następnym elementem do pobrania jest ten,
// który został najdawniej w kolejce umieszczony.
// Jak "sprawiedliwa" kolejna do kasy w sklepie.
// Najczęściej jest to jednocześnie kolejka dwukońcowa (Dequeue) z możliwością dostepu do obu jej końców.
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Queue<String> kolejka = new LinkedList<>(); // albo ArrayDequeue; - to są "kolejki proste"
System.out.println(kolejka);
System.out.println("Podawaj kolejne elementy, aby dodać do kolejki.\nWpisz '?', aby pobrać element z kolejki, a Enter aby zakończyć program");
while(true) {
System.out.println("Kolejka: " + kolejka);
System.out.print("> ");
String napis = scanner.nextLine();
if(napis.isEmpty()) break;
if(napis.equals("?")) {
String pobrane = kolejka.poll();
System.out.println("Pobrany element: " + pobrane);
} else {
System.out.println("Dodany element: " + napis);
kolejka.add(napis);
}
}
System.out.println("Końcowy rozmiar kolejki " + kolejka.size());
System.out.println(kolejka);
System.out.println("Koniec programu");
}
}
src/main/java/p12_kolekcje/zbieranie_danych/P8_PriorityQueue.java 0 → 100644
package p12_kolekcje.zbieranie_danych;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
public class P8_PriorityQueue {
// * Kolejka priorytetowa może nie zachowywać kolejności (możliwe jest tzw. "zagłodzenie").
// Następnym elementem do pobranie jest element o najwyższym priorytecie
// - w Javie jest to element o najmniejszej wartości (np. napis najwcześniejszy alfabetycznie).
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Queue<String> kolejka = new PriorityQueue<>();
System.out.println(kolejka);
System.out.println("Podawaj kolejne elementy, aby dodać do kolejki.\nWpisz '?', aby pobrać element z kolejki, a Enter aby zakończyć program");
while(true) {
System.out.println("Kolejka: " + kolejka);
System.out.print("> ");
String napis = scanner.nextLine();
if(napis.isEmpty()) break;
if(napis.equals("?")) {
String pobrane = kolejka.poll();
System.out.println("Pobrany element: " + pobrane);
} else {
System.out.println("Dodany element: " + napis);
kolejka.add(napis);
}
}
System.out.println("Końcowy rozmiar kolejki " + kolejka.size());
System.out.println(kolejka);
System.out.println("Koniec programu");
}
}
src/main/java/p13_gotowe/a_list/DeklaracjeGeneryczne.java 0 → 100644
package p13_gotowe.a_list;
import java.util.ArrayList;
import java.util.List;
public class DeklaracjeGeneryczne {
public static void main(String[] args) {
List l1 = new ArrayList();
ArrayList l2 = new ArrayList();
List<String> l3 = new ArrayList<String>();
List<String> l4 = new ArrayList<>(); // diamond operator od Javy 7
List<String> l5 = new ArrayList();
List l6 = new ArrayList<>(); // lista Object-ów
//NK List<> l7 = new ArrayList<String>();
List<List<Integer>> l8 = new ArrayList<>();
//NK List<List<Integer>> l9 = new ArrayList<<>>();
//NK List<List<Integer>> l10 = new ArrayList<List<>>();
List<List<Integer>> l11 = new ArrayList<List<Integer>>();
//NK List<int> l12 = new ArrayList<>();
List<int[]> l13 = new ArrayList<>();
// "lista nie wiadomo czego"
// w praktyce takiej listy mogę używać tylko do odczytu, nie mogę w niej niczego zapisać
List<?> l14 = new ArrayList<>();
List<?> l15 = new ArrayList<String>();
// l15.add("ala");
// to nie to samo, co lista Objectów, bo np lista Stringów nie jest tym samym co lista Objectów, i nie można wpisać
//NK List<Object> l16 = new ArrayList<String>();
}
}
src/main/java/p13_gotowe/a_list/ListaLiczb.java 0 → 100644
package p13_gotowe.a_list;
import java.util.ArrayList;
import java.util.List;
public class ListaLiczb {
public static void main(String[] args) {
//NK List<int> lista = new ArrayList<>();
List<Integer> lista = new ArrayList<>();
lista.add(5);
lista.add(6);
lista.add(7);
lista.add(8);
lista.add(9);
lista.add(10);
System.out.println(lista);
System.out.println("rozmiar: " + lista.size());
// if(lista.remove(5)) {
// }
Integer element = lista.remove(5); // wg indeksu
System.out.println("Usunięty element: " + element);
System.out.println(lista);
Integer x = 9;
if(lista.remove(x)) { // wg wartości
System.out.println("usunąłem wartość 9");
}
boolean b = lista.remove((Integer)5); // OK, wg wartości
// boolean b = lista.remove((Object)5); // wg wartości
System.out.println("Czy usunięto? " + b);
System.out.println(lista);
}
}
src/main/java/p13_gotowe/a_list/Listy.java 0 → 100644
package p13_gotowe.a_list;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class Listy {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
System.out.println(lista);
// dodaje na koniec
lista.add("ola");
lista.add("ala");
boolean coSieStalo = lista.add("ela");
System.out.println(coSieStalo);
if(lista.add("iza")) {
System.out.println("Iza też");
}
System.out.println(lista);
System.out.println();
// odczyt z określonej pozycji, numeracja od 0 jak w tablicach
String x = lista.get(0); // lista[0] - tak się nie da
System.out.println(x);
x = lista.get(2);
System.out.println(x);
//EXN x = lista.get(lista.size());
// System.out.println(x);
// dodaje na okreslona pozycje, przesuwa dotychczasowe elementy w prawo
// tu może być od 0 do 4, ale już nie 5 (IOOBExn)
lista.add(2, "ewa");
lista.add(lista.size(), "ostatnia"); // OK
System.out.println(lista);
// nadpisuje element na podanej pozycji nowym elementem
lista.set(2, "ula");
System.out.println(lista);
System.out.println();
lista.add(0, "ala");
System.out.println(lista);
// usuwa z określonej pozycji, zwraca obiekt
String wynik = lista.remove(3);
System.out.println("usunąłem element : " + wynik);
System.out.println(lista);
// to by usunęło od razu wszystkie wystąpienia elementu "ala"
// boolean b = lista.removeAll(Collections.singleton("ala"));
// to usuwa pierwsze wystąpienie, elementy są porównywane za pomocą equals, wynik boolean mówi czy element został usunięty
boolean b = lista.remove("ala");
System.out.println("bool : " + b);
System.out.println(lista);
b = lista.remove("ala");
System.out.println("bool : " + b);
System.out.println(lista);
b = lista.remove("ala");
System.out.println("bool : " + b);
System.out.println(lista);
System.out.println();
lista.addAll(Arrays.asList("ola", "ela", "ewa", "kasia", "marysia", "aga"));
System.out.println(lista);
System.out.println("indexOf: " + lista.indexOf("ewa"));
System.out.println("contains: " + lista.contains("ewa"));
System.out.println();
System.out.println("indexOf: " + lista.indexOf("Ewa")); // -1
System.out.println("contains: " + lista.contains("Ewa")); // false
System.out.println();
Collections.sort(lista);
System.out.println(lista);
for(String s : lista) {
System.out.println("Kolejny element: " + s);
}
}
}
src/main/java/p13_gotowe/a_list/ListyAll.java 0 → 100644
package p13_gotowe.a_list;
import java.util.ArrayList;
import java.util.List;
public class ListyAll {
public static void main(String[] args) {
List<String> a = new ArrayList<>();
a.add("Ala");
a.add("Ola");
a.add("Ela");
a.add("Ula");
System.out.println("a = " + a);
List<String> b = new ArrayList<>(a);
System.out.println("a = " + b);
List<String> c = new ArrayList<>();
c.add("Ala");
c.add("Ula");
System.out.println("c = " + c);
List<String> d = new ArrayList<>();
d.add("Ala");
d.add("Gosia");
System.out.println("d = " + d);
d.addAll(a);
System.out.println("d = " + d);
System.out.println(a.containsAll(c)); // T
System.out.println(c.containsAll(a)); // F
c.add("Basia"); // nie ma w a
System.out.println("c = " + c);
boolean czy = a.removeAll(c);
System.out.println(czy); // T
System.out.println("a = " + a); // usunął Ala i Ula, a nie przejął się Basią
System.out.println();
a.add("Genowefa");
a.add("Hermenegilda");
a.add("Genowefa");
System.out.println("a = " + a);
System.out.println("b = " + b);
// zostawia w liście a tylko te elementy, które wystepują w b
czy = a.retainAll(b);
System.out.println("retainAll " + b);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
}
src/main/java/p13_gotowe/a_list/NoweOperacjeList.java 0 → 100644
package p13_gotowe.a_list;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
public class NoweOperacjeList {
public static void main(String[] args) {
ArrayList<String> lista = new ArrayList<>();
lista.add("Ala");
lista.add("Ola");
lista.add("Kasia");
lista.add("Ela");
lista.add("Łucja");
lista.add("Ula");
lista.add("Asia");
lista.add("Zosia");
System.out.println(lista);
System.out.println();
lista.sort(null);
// lista.sort(Comparator.reverseOrder());
lista.sort(Collator.getInstance());
// lista.sort(Collator.getInstance(Locale.CHINA));
// lista.sort(Collator.getInstance().reversed());
System.out.println(lista);
System.out.println();
lista.forEach(s -> System.out.print(s + ", "));
System.out.println();
System.out.println();
List<String> lista1 = (List<String>)lista.clone();
System.out.println(lista1);
// predykat; operacja usuwa z listy wszystkie spełaniające warunek
lista1.removeIf(s -> s.length() <= 3);
System.out.println(lista1);
System.out.println();
List<String> lista2 = (List<String>)lista.clone();
System.out.println(lista2);
lista2.replaceAll(s -> s.toUpperCase()); // lambda expression
// lista2.replaceAll(String::toUpperCase); // method reference - w tym przypadku równoważnie
System.out.println(lista2);
System.out.println();
}
}
src/main/java/p13_gotowe/a_list/PorownanieSzybkosciList.java 0 → 100644
package p13_gotowe.a_list;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class PorownanieSzybkosciList {
public static void testujListe(List<Integer> lista) {
long start, koniec;
int suma;
System.out.print("Wstawianie 250 tys. na koniec listy (add)... ");
start = System.currentTimeMillis();
for(int i=0; i<250000; i++) {
lista.add(i);
}
koniec = System.currentTimeMillis();
System.out.println(koniec - start + " ms");
lista.clear(); // usuwa całą zawartość
System.out.print("Wstawianie 500 tys. na koniec listy (add)... ");
start = System.currentTimeMillis();
for(int i=0; i<500000; i++) {
lista.add(i);
}
koniec = System.currentTimeMillis();
System.out.println(koniec - start + " ms");
System.out.println("\nDodawanie na początek... ");
start = System.currentTimeMillis();
for(int i=0; i < 10000; i++) {
lista.add(0, 333); // 333 jest elementem (wartością) a nie indeksem
// Szybko dla LinkedList, wolno dla ArrayList
}
koniec = System.currentTimeMillis();
System.out.println(koniec - start + " ms");
System.out.println("\nWybieranie po indeksie... ");
start = System.currentTimeMillis();
suma = 0;
for(int i=0; i < 5000; i++) {
suma += lista.get(i * 100);
// Szybkie dla ArrayList, wolne dla LinkedList
}
koniec = System.currentTimeMillis();
System.out.println(koniec - start + " ms");
System.out.println("wynik="+suma);
System.out.println("\nOdczytanie wszystkich elementów foreach");
start = System.currentTimeMillis();
suma = 0;
for(int x : lista) {
suma += x;
}
koniec = System.currentTimeMillis();
System.out.println(koniec - start + " ms");
System.out.println("wynik="+suma);
}
public static void main(String[] args) {
List<Integer> linked = new LinkedList<>();
List<Integer> tablicowa = new ArrayList<>();
System.out.println("LinkedList:");
testujListe(linked);
System.out.println("\n\n================");
System.out.println("ArrayList:");
testujListe(tablicowa);
}
}
src/main/java/p13_gotowe/b_set_map/ListyIZbiory.java 0 → 100644
package p13_gotowe.b_set_map;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.TreeSet;
public class ListyIZbiory {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<>();
LinkedList<String> lista = new LinkedList<>();
HashSet<String> hasz = new HashSet<>();
LinkedHashSet<String> linkedHasz = new LinkedHashSet<>();
TreeSet<String> drzewo = new TreeSet<>();
al.add("ala"); lista.add("ala"); drzewo.add("ala"); hasz.add("ala"); linkedHasz.add("ala");
al.add("ola"); lista.add("ola"); drzewo.add("ola"); hasz.add("ola"); linkedHasz.add("ola");
al.add("ela"); lista.add("ela"); drzewo.add("ela"); hasz.add("ela"); linkedHasz.add("ela");
al.add("ula"); lista.add("ula"); drzewo.add("ula"); hasz.add("ula"); linkedHasz.add("ula");
al.add("ola"); lista.add("ola"); drzewo.add("ola"); hasz.add("ola"); linkedHasz.add("ola");
System.out.println("ArrayList: "+al);
System.out.println("LinkedList: "+lista);
System.out.println("TreeSet: "+drzewo);
System.out.println("HashSet: "+hasz);
System.out.println("LinkedHashSet: "+linkedHasz);
System.out.println();
// dla wszystkich list wolno działa operacja contains / indexOf
System.out.println(al.contains("ela"));
// dla wszystkich zbiorów szybko działa operacja contains
System.out.println(hasz.contains("ela"));
}
}
src/main/java/p13_gotowe/b_set_map/NoweOperacjeMap.java 0 → 100644
package p13_gotowe.b_set_map;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeMap;
public class NoweOperacjeMap {
public static void main(String[] args) {
TreeMap<String, Integer> map = new TreeMap<>();
map.put("Ala", 20);
map.put("Ola", 30);
System.out.println(map);
map.putIfAbsent("Ala", 25); // nie wpisuje
map.putIfAbsent("Ela", 45); // wpisuje
System.out.println(map);
map.replace("Ala", 28); // zamienia
map.replace("Ula", 48); // nic się nie dzieje
System.out.println(map);
map.replace("Ala", 40, 41); // jeśli taka była poprzednia wartość - tutaj nic się nie stanie
System.out.println(map);
map.replaceAll((k, v) -> v+1); // zwiększa wszystkie wartości o 1
System.out.println(map);
map.replaceAll((k, v) -> k.startsWith("A") ? v+1 : v); // zwiększa o 1 tylko słowa na literę A
System.out.println(map);
// dodaje nowy wpis z wartością 10, albo dodaje 10 do istniejącej wartości
map.merge("Ola", 10, Math::addExact); // (x,y) -> x+y
map.merge("Ewa", 10, Math::addExact);
System.out.println(map);
System.out.println();
// Zamiast pętli, możena elementy przeglądać w ten sposób:
map.forEach((k, v) -> {
System.out.println("Klucz " + k + " ma wartość " + v);
});
}
}
src/main/java/p13_gotowe/b_set_map/Slowniki.java 0 → 100644
package p13_gotowe.b_set_map;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class Slowniki {
public static void main(String[] args) {
Map<String, Integer> hasz = new HashMap<>();
Map<String, Integer> linkedHasz = new LinkedHashMap<>();
Map<String, Integer> drzewo = new TreeMap<>();
hasz.put("ala", 20); drzewo.put("ala", 20); linkedHasz.put("ala", 20);
hasz.put("ola", 30); drzewo.put("ola", 20); linkedHasz.put("ola", 30);
hasz.put("ela", 20); drzewo.put("ela", 20); linkedHasz.put("ela", 20);
hasz.put("ula", 55); drzewo.put("ula", 55); linkedHasz.put("ula", 55);
System.out.println(hasz.get("ela")); //20
System.out.println(hasz.get("ewa")); //null
System.out.println(hasz.containsKey("ela")); // szybkie
System.out.println(hasz.containsValue(55)); // wolne
System.out.println("\nTreeMap: "+drzewo);
System.out.println("HashMap: "+hasz);
System.out.println("LinkedHashMap: "+linkedHasz);
System.out.println("====================================\n");
hasz.put("ola", 31); drzewo.put("ola", 31); linkedHasz.put("ola", 31);
System.out.println("TreeMap: "+drzewo);
System.out.println("HashMap: "+hasz);
System.out.println("LinkedHashMap: "+linkedHasz);
System.out.println("\nWszystkie wpisy:");
for(Map.Entry<String, Integer> entry : drzewo.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}
System.out.println("\nWszystkie klucze:");
for(String s : drzewo.keySet()) {
System.out.println(s);
}
System.out.println("\nWszystkie wartości:");
for(Integer i : drzewo.values()) {
System.out.println(i);
}
// Można też przypisać na zmienne:
Set<Map.Entry<String, Integer>> zbiorWpisow = hasz.entrySet();
Set<String> klucze = hasz.keySet();
Collection<Integer> wartosci = hasz.values();
// Jak zrobić listę kluczy?
List<String> kluczel = new ArrayList<>(hasz.keySet());
}
}
src/main/java/p13_gotowe/b_set_map/Tree1.java 0 → 100644
package p13_gotowe.b_set_map;
import java.util.Arrays;
import java.util.SortedSet;
import java.util.TreeSet;
public class Tree1 {
public static void main(String[] args) {
// TreeSet implementuje dodatkowe interfejsy:
// SortedSet<String>
// NavigableSet<String>
TreeSet<String> imiona = new TreeSet<>(
Arrays.asList("Ala", "Ola", "Ula", "Ela", "Ewa", "Ania", "Kasia", "Aga", "Iwona", "Magda", "Iza"));
System.out.println(imiona);
SortedSet<String> head1 = imiona.headSet("Iwona");
System.out.println(head1); // obejmuje wszystkie elementy < Iwona
SortedSet<String> head2 = imiona.headSet("Iwona", true);
System.out.println(head2); // obejmuje wszystkie elementy <= Iwona
SortedSet<String> tail1 = imiona.tailSet("Iwona");
System.out.println(tail1); // obejmuje wszystkie elementy >= Iwona
SortedSet<String> tail2 = imiona.tailSet("Iwona", false);
System.out.println(tail2); // obejmuje wszystkie elementy > Iwona
// headSet i tailSet (bez parametru inclusive) dają łącznie cały zbiór
System.out.println();
// Jako granicę można podawać także elementy niewystępujące w kolekcji
SortedSet<String> head3 = imiona.headSet("Jola");
System.out.println(head3);
SortedSet<String> sub1 = imiona.subSet("Ela", "Iwona"); // domyslnie inclusive: true / false
System.out.println(sub1);
SortedSet<String> sub2 = imiona.subSet("Ela", true, "Iwona", true);
System.out.println(sub2);
System.out.println("\n############");
// to są "widoki", a nie kopie - zmiany w zbiorze pierwotnym są od razu widziane przez pobrane obiekty head/tail
System.out.println("Dodaję elementy...");
imiona.add("Julia");
imiona.add("Ewelina");
System.out.println(imiona);
System.out.println(head1);
System.out.println(tail1);
System.out.println();
System.out.println("head.add(Basia)");
head1.add("Basia");
System.out.println(imiona);
System.out.println(head1);
System.out.println(tail1);
System.out.println();
System.out.println("head.remove(Ewa)");
System.out.println("head.remove(Magda)");
head1.remove("Ewa");
head1.remove("Zosia"); // nie ma takiego elementu, nie ma błędu
head1.remove("Magda"); // nie usuwa, nie ma błędu
System.out.println(imiona);
System.out.println(head1);
System.out.println(tail1);
System.out.println();
System.out.println("head.add(Zosia)");
head1.add("Zosia"); // IllegalArgumentException: key out of range
System.out.println(imiona);
System.out.println(head1);
System.out.println(tail1);
System.out.println();
}
}
src/main/java/p13_gotowe/b_set_map/Tree2.java 0 → 100644
package p13_gotowe.b_set_map;
import java.util.Arrays;
import java.util.NavigableSet;
import java.util.TreeSet;
public class Tree2 {
public static void main(String[] args) {
NavigableSet<String> imiona = new TreeSet<>(
Arrays.asList("Ala", "Ola", "Ula", "Ela", "Ewa", "Ania", "Kasia", "Aga", "Iwona", "Magda", "Iza"));
System.out.println(imiona);
System.out.println("first: " + imiona.first());
System.out.println("last : " + imiona.last());
System.out.println(imiona);
System.out.println();
System.out.println("pętla first / higher");
String s = imiona.first();
while(s != null) {
System.out.println(s);
s = imiona.higher(s);
}
System.out.println("========================");
System.out.println("pętla last / lower");
s = imiona.last();
while(s != null) {
System.out.println(s);
s = imiona.lower(s);
}
System.out.println("========================");
System.out.println("pętla poll - usuwanie");
System.out.println("size: " + imiona.size());
while((s = imiona.pollFirst()) != null) {
System.out.println(" # " + s);
}
System.out.println("size: " + imiona.size());
// analogicznie pollLast()
}
}
src/main/java/p13_gotowe/b_set_map/ZbiorDziwnieSortowany.java 0 → 100644
package p13_gotowe.b_set_map;
import java.math.BigDecimal;
import java.text.Collator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class ZbiorDziwnieSortowany {
public static void main(String[] args) {
TreeSet<String> normalny = new TreeSet<>();
TreeSet<String> alfabetyczny = new TreeSet<>(Collator.getInstance());
// TreeSet<String> alfabetyczny = new TreeSet<>(Collator.getInstance(new Locale("fr", "FR")));
TreeSet<String> dziwny = new TreeSet<>((a,b) -> a.length() - b.length());
normalny.add("Ala");
alfabetyczny.add("Ala");
dziwny.add("Ala");
normalny.add("Ącki");
alfabetyczny.add("Ącki");
dziwny.add("Ącki");
normalny.add("Łucja");
alfabetyczny.add("Łucja");
dziwny.add("Łucja");
normalny.add("Wiktor");
alfabetyczny.add("Wiktor");
dziwny.add("Wiktor");
normalny.add("Hermenegilda");
alfabetyczny.add("Hermenegilda");
dziwny.add("Hermenegilda");
normalny.add("Ola");
alfabetyczny.add("Ola");
dziwny.add("Ola");
// Ola jest traktowana jak == Ala, bo comparator zwraca 0 gdy napisy są tej samej długości
// TreeSet i TreeMap nie uzywają equals do sprawdzenia czy elementy sa równe, ograniczają się do użycia compare albo compareTo
System.out.println(normalny);
System.out.println(alfabetyczny);
System.out.println(dziwny);
System.out.println();
System.out.println("Sprawa BigDecimal:");
BigDecimal[] liczby = {
new BigDecimal("123.00"),
new BigDecimal("123.0"),
new BigDecimal("123"),
new BigDecimal("124"),
};
Set<BigDecimal> t = new TreeSet<>();
Set<BigDecimal> h = new HashSet<>();
for(BigDecimal b : liczby) {
t.add(b);
h.add(b);
}
System.out.println("Tree: " + t);
System.out.println("Hash: " + h);
}
}
src/main/java/p13_gotowe/b_set_map/ZmianaKolejnosciWHaszSecie.java 0 → 100644
package p13_gotowe.b_set_map;
import java.util.Arrays;
import java.util.HashSet;
public class ZmianaKolejnosciWHaszSecie {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.addAll(Arrays.asList("Ala", "Ola", "Ula", "Ela", "Ewa", "Ania", "Kasia", "Aga", "Iwona", "Magda", "Iza"));
System.out.println(set.size());
System.out.println(set);
set.add("Julia");
System.out.println(set.size());
System.out.println(set);
set.add("Ewelina");
System.out.println(set.size());
System.out.println(set);
// for (String s : set) {
// int hash = s.hashCode();
// System.out.printf("%10s : hash = %10d , h%%16 = %2d , h%%32 = %2d\n",
// s, hash, hash%16, hash%32);
// }
}
}
src/main/java/p13_gotowe/c_queue/KolejkaJakoStos.java 0 → 100644
package p13_gotowe.c_queue;
import java.util.ArrayDeque;
public class KolejkaJakoStos {
public static void main(String[] args) {
ArrayDeque<Integer> stos = new ArrayDeque<>();
System.out.println(stos);
for(int i = 1; i < 10; i++) {
System.out.println(i*i);
stos.push(i*i);
}
System.out.println();
System.out.println(stos);
System.out.println();
while(! stos.isEmpty()) {
Integer liczba = stos.pop();
System.out.println(liczba);
}
}
}
src/main/java/p13_gotowe/c_queue/Kolejki.java 0 → 100644
package p13_gotowe.c_queue;
import java.util.ArrayDeque;
import java.util.PriorityQueue;
import java.util.Queue;
public class Kolejki {
public static void main(String[] args) {
Queue<String> kolejka; // ewentualnie Deque<String>
String elem;
System.out.println("Kolejka prosta:"); // FIFO
kolejka = new ArrayDeque<>();
// kolejka = new LinkedList<>();
kolejka.add("ala");
kolejka.add("ola");
kolejka.add("ela");
kolejka.add("ula");
System.out.println("Cała: " + kolejka);
System.out.println("Dodaję aaa");
kolejka.add("aaa");
System.out.println(kolejka);
System.out.println("Wyjmuję w pętli:");
while((elem = kolejka.poll()) != null ) {
System.out.println(elem);
}
System.out.println("\nKolejka priorytetowa:");
kolejka = new PriorityQueue<>();
kolejka.add("ala");
kolejka.add("ola");
kolejka.add("ela");
kolejka.add("ula");
System.out.println("Cała: " + kolejka);
System.out.println("Dodaję aaa");
kolejka.add("aaa");
System.out.println(kolejka);
// jako pierwszy element w PriorityQueue występuje najmniejszy
System.out.println("Wyjmuję w pętli:");
while((elem = kolejka.poll()) != null) {
System.out.println(elem);
}
}
}
src/main/java/p13_gotowe/c_queue/Kolejki_Operacje.java 0 → 100644
package p13_gotowe.c_queue;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
public class Kolejki_Operacje {
public static void main(String[] args) {
Deque<String> kolejka = new ArrayDeque<String>(
Arrays.asList("Ala", "Ula", "Ola", "Kasia"));
System.out.println(kolejka);
// odczyt bez usuwania, zwracają null jeśli kolejka jest pusta
System.out.println("peek / peekFirst / peekLast");
System.out.println(kolejka.peek());
System.out.println(kolejka.peekFirst());
System.out.println(kolejka.peekLast());
System.out.println();
// odczyt bez usuwania, wyrzucają wyjątek jeśli kolejka jest pusta
System.out.println("element / getFirst / getLast");
System.out.println(kolejka.element());
System.out.println(kolejka.getFirst());
System.out.println(kolejka.getLast());
System.out.println();
// dodawanie na końcu i na początku
kolejka.add("Zosia");
kolejka.addLast("Zuzia");
kolejka.addFirst("Ania");
System.out.println(kolejka);
kolejka.offer("Zosia 2");
kolejka.offerLast("Zuzia 2");
kolejka.offerFirst("Ania 2");
System.out.println(kolejka);
System.out.println();
// usuwanie - poll zwracają null jeśli kolejka jest pusta
String s;
s = kolejka.poll(); // pobiera i usuwa pierwszy element
System.out.println(s);
s = kolejka.pollFirst();
System.out.println(s);
s = kolejka.pollLast();
System.out.println(s);
System.out.println();
// usuwanie - remove wyrzucają wyjątek jeśli kolejka jest pusta
s = kolejka.remove();
System.out.println(s);
s = kolejka.removeFirst();
System.out.println(s);
s = kolejka.removeLast();
System.out.println(s);
System.out.println();
kolejka.add("Zosia");
kolejka.add("Ola");
System.out.println(kolejka);
// [Ola, Kasia, Zosia, Zuzia, Zosia, Ola]
boolean b;
b = kolejka.remove("Ola"); // usuwa jedno wystąpienie, równoważne removeFirstOccurrence
System.out.println(kolejka);
kolejka.removeLastOccurrence("Zosia");
System.out.println(kolejka);
}
}
src/main/java/p13_gotowe/e_iterator/Iteratory.java 0 → 100644
package p13_gotowe.e_iterator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class Iteratory {
// Kod jest napisany tak, jak pisało się w Javie 1.4
// Nie było generyków (trzeba rzutować)
// Nie było pętli for-each - trzeba używać iteratorów
public static void main(String[] args) {
List lista = new LinkedList();
lista.add("ala");
lista.add("ola");
lista.add("ela");
lista.add("ula");
System.out.println("Na początku: " + lista);
Iterator it = lista.iterator();
while(it.hasNext()) {
String element = (String)it.next();
System.out.println(element);
if("ela".equals(element)) {
it.remove();
}
}
System.out.println("Na koniec: " + lista);
}
}
src/main/java/p13_gotowe/e_iterator/IteratoryListowe.java 0 → 100644
package p13_gotowe.e_iterator;
import java.util.ListIterator;
import java.util.LinkedList;
import java.util.List;
public class IteratoryListowe {
// Iteratory wciąż mogą się przydać, najbardziej gdy używamy klasy LinkedList,
// bo w niej nie ma "random access" i właśnie za pomocą iteratora możemy
// przeglądać listę i ją modyfikować "w locie"
public static void main(String[] args) {
List<String> lista = new LinkedList<>();
lista.add("ala");
lista.add("ola");
lista.add("ela");
lista.add("ula");
System.out.println("Na początku: " + lista);
ListIterator<String> it = lista.listIterator();
while(it.hasNext()) {
String element = it.next();
System.out.println(element);
if("ela".equals(element)) {
it.add("maja"); // za element bieżący, ale nowowstawione elementy nie będą odwiedzone przez ten iterator
it.add("gucio");
} else if("ola".equals(element)) {
it.set("Aleksandra");
} else if("ula".equals(element)) {
it.remove();
}
}
System.out.println();
it = lista.listIterator(3);
while(it.hasPrevious()) {
System.out.println(it.previousIndex() + " " + it.previous());
}
System.out.println("Na koniec: " + lista);
}
}
src/main/java/p13_gotowe/e_iterator/Konkurencja1.java 0 → 100644
package p13_gotowe.e_iterator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Konkurencja1 {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("ala");
lista.add("ola");
lista.add("ela");
lista.add("ula");
System.out.println("Na początku: " + lista);
// można używać wielu iteratorów do odczytu kolekcji - to jest OK
Iterator<String> it1 = lista.iterator();
while(it1.hasNext()) {
String element = it1.next();
System.out.print(element);
Iterator<String> it2 = lista.iterator();
while(it2.hasNext()) {
System.out.print(" " + it2.next().length());
}
System.out.println();
}
}
}
src/main/java/p13_gotowe/e_iterator/Konkurencja2.java 0 → 100644
package p13_gotowe.e_iterator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Konkurencja2 {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("ala");
lista.add("ola");
lista.add("ela");
lista.add("ula");
System.out.println("Na początku: " + lista);
Iterator<String> it1 = lista.iterator();
while(it1.hasNext()) {
String element = it1.next();
System.out.print(element);
Iterator<String> it2 = lista.iterator();
while(it2.hasNext()) {
String elem2 = it2.next();
System.out.print(" " + elem2.length());
if(elem2.charAt(0) == 'o') {
it2.remove();
}
}
System.out.println();
}
// Jesli uzywamy iterator (it1) a w tym czasie w inny sposób zmienimy kolekcję
// (np. innym iteratorem), to kolejna operacja na tym pierwszym iteratorze skończy sie wjątkiem ConcurrectModificationEx
}
}
src/main/java/p13_gotowe/e_iterator/Konkurencja3.java 0 → 100644
package p13_gotowe.e_iterator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Konkurencja3 {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("ala");
lista.add("ola");
lista.add("ela");
lista.add("ula");
System.out.println("Na początku: " + lista);
// wyjątek pojawia się także gdy modyfikujemy listę metodami add/remove
// w trakcie przeglądania jej jakimś iteratorem
Iterator<String> it = lista.iterator();
while(it.hasNext()) {
String element = it.next();
System.out.println(element);
if(element.charAt(0) == 'o') {
// lista.set(3, "Agata"); // to nie spowodowało błędu
lista.remove(2); // to psuje działanie pętli for-each
// lista.add("ewa"); // to też psuje
System.out.println("już usunąłem");
//break;
}
}
System.out.println("koniec");
}
}
src/main/java/p13_gotowe/e_iterator/Konkurencja4.java 0 → 100644
package p13_gotowe.e_iterator;
import java.util.ArrayList;
import java.util.List;
public class Konkurencja4 {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("ala");
lista.add("ola");
lista.add("ela");
lista.add("ula");
System.out.println("Na początku: " + lista);
// wyjątek pojawia się także gdy modyfikujemy listę metodami add/remove
// w trakcie przeglądania jej jakimś iteratorem
// pętla for-each ma w sobie zaszyty niejawny iterator
for (String element : lista) {
System.out.println(element);
if(element.charAt(0) == 'o') {
// lista.set(3, "Agata"); // to nie spowodowało błędu
lista.remove(2); // to psuje działanie pętli for-each
// lista.add("ewa"); // to też psuje
System.out.println("już usunąłem");
}
}
}
}
src/main/java/p13_gotowe/e_iterator/Konkurencja6.java 0 → 100644
package p13_gotowe.e_iterator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Konkurencja6 {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("Ala");
lista.add("Ola");
lista.add("Ela");
lista.add("Ula");
System.out.println(lista);
String a, b, c;
Iterator<String> it1 = lista.iterator();
a = it1.next();
System.out.println("it1 jest na pozycji " + a);
ListIterator<String> it2 = lista.listIterator();
it2.next();
b = it2.next();
System.out.println("it2 jest na pozycji " + b);
a = it1.next();
a = it1.next();
System.out.println("it1 jest na pozycji " + a);
// dopóki tylko odczytujemy elementy kolekcji, można używać wielu iteratorów jednocześnie
System.out.println();
it2.add("Jola");
// it2.remove();
// lista.add("Fasola");
System.out.println("dodałem nowy element za pomocą it2");
System.out.println(lista);
try {
// Kolekcja została zmodyfikowana nie poprzez iterator it1.
// Teraz próba wykonania operacji poprzed it1 kończy się wyjątkiem.
System.out.println("przesuwam it1");
a = it1.next();
System.out.println("it1 jest na pozycji " + a);
} catch (Exception e) {
System.out.println("Wyjątek " + e);
}
}
}
src/main/java/p13_gotowe/e_iterator/Konkurencja7a.java 0 → 100644
package p13_gotowe.e_iterator;
import java.util.ArrayList;
import java.util.List;
public class Konkurencja7a {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("Ala");
lista.add("Ola");
lista.add("Ela");
lista.add("Ula");
System.out.println(lista);
for (String s : lista) {
System.out.println(s);
if(s.equals("Ela")) {
lista.add("Nowy"); // EXN
}
}
}
}
src/main/java/p13_gotowe/e_iterator/Konkurencja7b.java 0 → 100644
package p13_gotowe.e_iterator;
import java.util.ArrayList;
import java.util.List;
public class Konkurencja7b {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("Ala");
lista.add("Ola");
lista.add("Ela");
lista.add("Ula");
System.out.println(lista);
for (String s : lista) {
System.out.println(s);
if(s.equals("Ela")) {
lista.set(3, "Urszula"); // nie powoduje błędu
}
}
}
}
src/main/java/p13_gotowe/s_sortowanie/KomparatorDlugosciNapisow.java 0 → 100644
package p13_gotowe.s_sortowanie;
import java.util.Comparator;
public class KomparatorDlugosciNapisow implements Comparator<String> {
public int compare(String s1, String s2) {
/* Jeśli zwracam <0 to znaczy że s1 uważam za mniejsze.
* Jeśli zwracam >0 to znaczy że s1 uważam za większe.
* Jeśli zwracam 0 to znaczy, że są równe.
*/
return s1.length() - s2.length();
}
}
src/main/java/p13_gotowe/s_sortowanie/Sortowanie1.java 0 → 100644
package p13_gotowe.s_sortowanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Sortowanie1 {
public static void main(String[] args) {
String[] imiona = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(imiona));
System.out.println(lista);
// dostępne "od początku" kolekcji w Javie
System.out.println("\nCollections.sort");
Collections.sort(lista);
System.out.println(lista);
// Domyślnie porównywanie Stringów bazuje na kodach Unicode poszczególnych znaków
System.out.println("\nCollections.shuffle");
Collections.shuffle(lista);
System.out.println(lista);
// Od Javy 8 można też tak:
System.out.println("\nlista.sort(null)");
lista.sort(null);
System.out.println(lista);
}
}
src/main/java/p13_gotowe/s_sortowanie/Sortowanie2.java 0 → 100644
package p13_gotowe.s_sortowanie;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
public class Sortowanie2 {
public static void main(String[] args) {
String[] imiona = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "ala", "Agnieszka", "Łucja", "Julia", "Julitta", "Ela", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(imiona));
System.out.println(lista);
// Pierwszy sposób utworzenia komparatora: oddzielna klasa
System.out.println("\nlista.sort( komparator )");
// Collections.shuffle(lista);
KomparatorDlugosciNapisow komparator = new KomparatorDlugosciNapisow();
lista.sort(komparator);
System.out.println(lista);
System.out.println("\nCollections.sort( lista, komparator )");
Collections.sort(lista, komparator);
System.out.println(lista);
// Drugi sposób utworzenia komparatora: klasa anonimowa
// Składnia dostepna od początków Javy
System.out.println("\nlista.sort( klasa anonimowa )");
lista.sort(new Comparator<String>() {
public int compare(String s1, String s2) {
return s2.length() - s1.length();
}
});
System.out.println(lista);
// Trzeci sposób utworzenia komparatora:
// wyrażenie lambda (od Javy 8)
System.out.println("\nlista.sort( lambda )");
lista.sort((s1, s2) -> s1.length() - s2.length());
System.out.println(lista);
System.out.println("\nCollator");
lista.sort(Collator.getInstance()); // wg bieżących ustawień językowych w systemie
System.out.println(lista);
lista.sort(Collator.getInstance(Locale.CANADA_FRENCH));
System.out.println(lista);
lista.sort(Collator.getInstance(new Locale("pl", "PL")));
System.out.println(lista);
}
}
src/main/java/p13_gotowe/s_sortowanie/Sortowanie3.java 0 → 100644
package p13_gotowe.s_sortowanie;
import java.text.Collator;
import java.util.Arrays;
public class Sortowanie3 {
public static void main(String[] args) {
String[] imiona = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
System.out.println("Sortowanie tablicy");
System.out.println(Arrays.toString(imiona));
Arrays.sort(imiona);
System.out.println(Arrays.toString(imiona));
Arrays.sort(imiona, Collator.getInstance()); // jako Comparator
System.out.println(Arrays.toString(imiona));
Arrays.sort(imiona, (s1, s2) -> s1.length() - s2.length());
System.out.println(Arrays.toString(imiona));
}
}
src/main/java/p14_napisy/BudowanieNapisow_PomiarCzasu.java 0 → 100644
package p14_napisy;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class BudowanieNapisow_PomiarCzasu {
static String kolejneLiczby(int n) {
String napis = "";
for(int i = 1; i <= n; i++) {
napis += i + " ";
}
return napis;
}
static String kolejneLiczbyConcat(int n) {
String napis = "";
for(int i = 1; i <= n; i++) {
napis = napis.concat(i + " ");
}
return napis;
}
static String kolejneLiczbyCollector(int n) {
return IntStream.rangeClosed(1, n)
.mapToObj(Integer::toString)
.collect(Collectors.joining(" "));
}
static String kolejneLiczbySB(int n) {
StringBuilder s = new StringBuilder();
for(int i = 1; i <= n; i++) {
s.append(i).append(' ');
}
return s.toString();
}
public static void main(String[] args) {
// sprawdzanie czasu wykonania
int[] dane1 = {25000, 50000, 100_000};
int[] dane2 = {25000, 50000, 100_000, 1_000_000, 10_000_000};
int[] dane3 = {25000, 50000, 100_000, 1_000_000, 10_000_000, 100_000_000};
System.out.println("Wersja String +=");
System.out.println(kolejneLiczby(10));
for(int n : dane1) {
System.out.println("n = " + n + "...");
long start = System.currentTimeMillis();
String wynik = kolejneLiczby(n);
long koniec = System.currentTimeMillis();
System.out.println(" Dla n = " + n + " trwało " + (koniec - start) + "ms");
System.out.println(" Napis ma długość " + wynik.length());
}
System.out.println();
System.out.println("Wersja String concat");
System.out.println(kolejneLiczbyConcat(10));
for(int n : dane1) {
System.out.println("n = " + n + "...");
long start = System.currentTimeMillis();
// start = System.nanoTime();
String wynik = kolejneLiczbyConcat(n);
long koniec = System.currentTimeMillis();
System.out.println(" Dla n = " + n + " trwało " + (koniec - start) + "ms");
System.out.println(" Napis ma długość " + wynik.length());
}
System.out.println();
System.out.println("Wersja Stream / collector");
System.out.println(kolejneLiczbyCollector(10));
for(int n : dane2) {
System.out.println("n = " + n + "...");
long start = System.currentTimeMillis();
String wynik = kolejneLiczbyCollector(n);
long koniec = System.currentTimeMillis();
System.out.println(" Dla n = " + n + " trwało " + (koniec - start) + "ms");
System.out.println(" Napis ma długość " + wynik.length());
}
System.out.println();
System.out.println("Wersja StringBuilder");
System.out.println(kolejneLiczbySB(10));
for(int n : dane3) {
System.out.println("n = " + n + "...");
long start = System.currentTimeMillis();
String wynik = kolejneLiczbySB(n);
long koniec = System.currentTimeMillis();
System.out.println(" Dla n = " + n + " trwało " + (koniec - start) + "ms");
System.out.println(" Napis ma długość " + wynik.length());
}
System.out.println();
}
}
src/main/java/p14_napisy/InnaKlasa.java 0 → 100644
package p14_napisy;
public class InnaKlasa {
public static String dajStringaZKodu() {
return "Ala ma kota";
}
public static String dajStringaNowego() {
return new String("Ala ma kota");
}
}
src/main/java/p14_napisy/OperacjeNaStringach.java 0 → 100644
package p14_napisy;
public class OperacjeNaStringach {
public static void main(String[] args) {
String napis = "Ala ma kota";
System.out.println(napis);
napis.concat(" Filemona");
napis.replace("Ala", "Alicja");
System.out.println(napis); // napis się nie zmienił
System.out.println();
napis = napis.concat(" Bonifacego");
System.out.println(napis); // teraz zmieniony
System.out.println("\nMetody informacyjne");
System.out.println(napis.length());
System.out.println(napis.charAt(2)); // numeracja od 0
//EXN System.out.println(napis.charAt(30));
System.out.println(napis.codePointAt(2)); // kod Unicode
System.out.println("\nSprawdzanie czy zawiera fragment");
// istotna jest też wielkośc liter
System.out.println(napis.contains("kot"));
System.out.println(napis.startsWith("Ala"));
System.out.println(napis.endsWith("kot"));
System.out.println(napis.equals("ala ma kota bonifacego")); // F
// a to nie patrzy na wielkość liter
System.out.println(napis.equalsIgnoreCase("ala ma kota bOnIfAcEgO")); // T
System.out.println("\nWyszukiwanie");
System.out.println(napis.indexOf("ma"));
System.out.println(napis.indexOf("pies")); // -1
System.out.println(napis.indexOf('a')); //2
System.out.println(napis.indexOf('a', 3)); //5 bo szukam litery a od pozycji nr 3
System.out.println(napis.lastIndexOf('a')); // ostatnie a w napisie
System.out.println("\nMetody zwracające zmieniony napis");
System.out.println(napis.concat(" i jeszcze psa Reksia"));
System.out.println("|"+napis.substring(7, 15)+"|"); // od 7 włącznie, do 15 wyłączając; 15-7 = 8, 8 to jest długość wynikowego słowa
System.out.println("|"+napis.substring(7)+"|"); // od 7 do końca
System.out.println(napis.toLowerCase());
System.out.println(napis.toUpperCase());
// replace zamienia wszystkie wystąpienia
System.out.println(napis.replace(' ', '_'));
System.out.println(napis.replace("ma", "posiada"));
// Działa na wyrażeniach regularnych.
// Ten przykład zamienia pierwsze litery słów (po spacjach)
System.out.println(napis.replaceAll(" .", " X"));
}
}
src/main/java/p14_napisy/ParametryString.java 0 → 100644
package p14_napisy;
public class ParametryString {
public static void main(String[] args) {
String a = "Ala";
System.out.println("a1 = " + a);
m(a);
System.out.println("a2 = " + a);
// String is immutable
}
static void m(String c) {
System.out.println("c1 = " + c);
c += " ma kota";
System.out.println("c2 = " + c);
// tak naprawdę jest tworzony nowy obiekt String: c = new String("Ala" + " ma kota")
// a oryginalny obiekt, na który wskazuje zmienna a, nie zmienia się
}
}
src/main/java/p14_napisy/Porownywanie.java 0 → 100644
package p14_napisy;
import java.util.Objects;
public class Porownywanie {
public static void main(String[] args) {
String ala = "Ala";
final String final_ala = "Ala";
String a = "Ala ma kota";
String b = "Ala ma kota";
String c = "Ala" + " ma kota";
String d = final_ala + " ma kota";
String e = InnaKlasa.dajStringaZKodu();
String f = new String(a);
String g = ala + " ma kota";
// tak samo jest dla danych wczytywanych z zewnętrznych źródeł: konsola, plik, baza danych
System.out.println("==");
System.out.println(a == "Ala ma kota");
System.out.println(a == a);
System.out.println(a == b);
System.out.println(a == c);
System.out.println(a == d);
System.out.println(a == e);
System.out.println(a == f);
System.out.println(a == g);
System.out.println();
System.out.println("intern");
// intern zwraca referencję do stringa o takiej samej treści, ale pochodzącego z puli stringów
// jeśli w puli jeszcze go nie było, to dodawany
System.out.println(a.intern() == f.intern());
System.out.println();
System.out.println("equals");
System.out.println(a.equals(a));
System.out.println(a.equals(b));
System.out.println(a.equals(c));
System.out.println(a.equals(d));
System.out.println(a.equals(e));
System.out.println(a.equals(f));
System.out.println(a.equals(g));
System.out.println("Ala ma kota".equals(g));
System.out.println(Objects.equals(a, g));
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment