Skip to content

J
java_weekendowa_20221008
Commit 238ebbed by Patryk Czarnik
Options

różne gotowe przykłady

parent 015f2fb3
Showing with 4310 additions and 1 deletions
PC22-PrzetwarzanieDanych/.gitignore
...@@ -2,4 +2,4 @@ ...@@ -2,4 +2,4 @@
/.settings/ /.settings/
/sprzedaz_*.csv /sprzedaz_*.csv
/emps_big.csv
PC22-PrzetwarzanieDanych/src/alx/p17_enum/DzienTygodnia1.java 0 → 100644
package alx.p17_enum;
public enum DzienTygodnia1 {
PON, WTO, SRO, CZW, PIA(), SOB, NIE
}
// Deklaracja enuma określa wszystkie obiekty,
// poza tym miejscem nie da się utworzyć nowych obiektów klasy enumowej.
PC22-PrzetwarzanieDanych/src/alx/p17_enum/DzienTygodnia2.java 0 → 100644
package alx.p17_enum;
public enum DzienTygodnia2 implements AutoCloseable {
// Wartości mogą być tworzone poprzez wywołanie odpowiedniego konstruktora:
DODATKOWY(13L),
PON("poniedziałek"),
WTO("wtorek"),
SRO("środa"),
CZW("czwartek"),
PIA("piątek"),
SOB("sobota"),
NIE("niedziela");
// Enum, jak zwykła klasa, może zawierać:
// * pola
private String nazwa;
public int dlugoscTekstu;
// * Konstruktory (są prywatne, bo są używane tylko wewnątrz "klasy"!)
// można napisać poziom widoczności private, ale nawet jak nie napiszemy, to i tak będzie private
// nie wolno podać innego poziomu widoczności
DzienTygodnia2(String jakaNazwa) {
nazwa = jakaNazwa;
dlugoscTekstu = jakaNazwa.length();
}
private DzienTygodnia2(Number numer) {
}
//NK public DzienTygodnia2(int numer) { }
// * Metody (i mogą implementować interfejsy)
public void wypiszSie() {
System.out.println("Jestem sobie " + this.nazwa + " i mam kod " + this.name() + " oraz numer " + this.ordinal());
}
public void close() {
System.out.println("się zamykam...");
}
@Override
public String toString() {
return nazwa;
}
// Można też definiować zmienne i metody statyczne
static String napisStatyczny = "Ala ma kota";
static void metodaStatyczna() {
System.out.println(napisStatyczny);
}
}
PC22-PrzetwarzanieDanych/src/alx/p17_enum/DzienTygodnia3.java 0 → 100644
package alx.p17_enum;
public enum DzienTygodnia3 {
// Wartości mogą być tworzone poprzez wywołanie odpowiedniego konstruktora:
PON("poniedziałek"),
WTO("wtorek"),
SRO("środa"),
CZW("czwartek"),
PIA("piątek"),
SOB("sobota"),
// Możliwość nadpisania metody dla wybranych wartości (technicznie: powstaje podklasa)
NIE("niedziela") {
@Override
public boolean handelDozwolony() {
return false;
}
public void nowaMetoda() { }
};
// Enum, jak zwykła klasa, może zawierać:
// * pola
private String nazwa;
// * Konstruktory (mogą być prywatne, bo sa używane tylko wewnątrz "klasy"!)
private DzienTygodnia3(String jakaNazwa) {
nazwa = jakaNazwa;
}
// * Metody
@Override
public String toString() {
return nazwa;
}
public boolean handelDozwolony() {
return true;
}
}
PC22-PrzetwarzanieDanych/src/alx/p17_enum/Test1.java 0 → 100644
package alx.p17_enum;
import java.util.Arrays;
public class Test1 {
static String tekst(DzienTygodnia1 dt) {
// można użyć switch, nie wolno prefiksować wartości nazwą klasy
switch (dt) {
//case DzienTygodnia1.PON: return "poniedziałek";
case PON: return "poniedziałek";
case WTO: return "wtorek";
case SRO: return "środa";
case CZW: return "czwartek";
case PIA: return "piątek";
case SOB: return "sobota";
case NIE: return "niedziela";
// ale mimo wyczerpania wszystkich wartości potrzebny default
default : return "???";
}
}
public static void main(String[] args) {
DzienTygodnia1 dt = DzienTygodnia1.WTO;
String zmienna = "WTO";
DzienTygodnia1 wczytany = DzienTygodnia1.valueOf(zmienna);
//EXN DzienTygodnia1a wczytany = DzienTygodnia1.valueOf("nie ma takiego dnia");
// IllegalArgumentException
if(dt == wczytany) {
System.out.println("równe");
} else {
System.out.println("nierówne");
}
if(dt.equals(wczytany)) {
System.out.println("równe");
} else {
System.out.println("nierówne");
}
// == równoważne equals; dla każdej wartości enuma istnieje dokładnie jeden obiekt
System.out.println();
// Standardowo dostępne informacje dla pojedynczej wartości:
System.out.println(dt);
System.out.println(dt.toString());
System.out.println(dt.name());
System.out.println(dt.ordinal()); // od 0
//NK System.out.println(dt < wczytany);
System.out.println(dt.compareTo(wczytany)); // OK
System.out.println(tekst(dt));
System.out.println();
// Standardowo dostępne rzeczy dla klasy enuma:
DzienTygodnia1 dt4 = DzienTygodnia1.valueOf("PIA");
System.out.println(dt4);
DzienTygodnia1[] values = DzienTygodnia1.values();
System.out.println(Arrays.toString(values));
System.out.println(DzienTygodnia1.class.getSuperclass());
}
}
PC22-PrzetwarzanieDanych/src/alx/p17_enum/Test1_import_static.java 0 → 100644
package alx.p17_enum;
import static alx.p17_enum.DzienTygodnia1.*;
import java.util.Arrays;
public class Test1_import_static {
static String tekst(DzienTygodnia1 dt) {
// można użyć switch, nie wolno prefiksować wartości nazwą klasy
switch (dt) {
case PON: return "poniedziałek";
case WTO: return "wtorek";
case SRO: return "środa";
case CZW: return "czwartek";
case PIA: return "piątek";
case SOB: return "sobota";
case NIE: return "niedziela";
// ale mimo wyczerpania wszystkich wartości potrzebny default
default : return "???";
}
}
public static void main(String[] args) {
// dzięki static import mogę używać krótkich nazw z enuma także poza switch
DzienTygodnia1 dt = WTO;
DzienTygodnia1 wczytany = DzienTygodnia1.valueOf("WTO");
//EXN DzienTygodnia1a wczytany = DzienTygodnia1.valueOf("nie ma takiego dnia");
// IllegalArgumentException
if(dt == wczytany) {
System.out.println("równe");
} else {
System.out.println("nierówne");
}
if(dt.equals(wczytany)) {
System.out.println("równe");
} else {
System.out.println("nierówne");
}
// == równoważne equals; dla każdej wartości enuma istnieje dokładnie jeden obiekt
System.out.println();
// Standardowo dostępne informacje dla pojedynczej wartości:
System.out.println(dt);
System.out.println(dt.toString());
System.out.println(dt.name());
System.out.println(dt.ordinal()); // od 0
//NK System.out.println(dt < wczytany);
System.out.println(dt.compareTo(wczytany)); // OK
System.out.println(tekst(dt));
System.out.println();
// Standardowo dostępne rzeczy dla klasy enuma:
DzienTygodnia1 dt4 = DzienTygodnia1.valueOf("PIA");
System.out.println(dt4);
DzienTygodnia1[] values = DzienTygodnia1.values();
System.out.println(Arrays.toString(values));
System.out.println(DzienTygodnia1.class.getSuperclass());
}
}
PC22-PrzetwarzanieDanych/src/alx/p17_enum/Test2.java 0 → 100644
package alx.p17_enum;
public class Test2 {
public static void main(String[] args) {
DzienTygodnia2 dt = DzienTygodnia2.WTO;
// mogę odwoływać się do zmiennych nie-prywatnych z obiektu enum, nawet je modyfikować
System.out.println(dt.dlugoscTekstu);
dt.dlugoscTekstu += 100;
System.out.println(dt.dlugoscTekstu);
System.out.println(DzienTygodnia2.WTO.dlugoscTekstu);
dt.wypiszSie();
}
}
PC22-PrzetwarzanieDanych/src/alx/p17_enum/Test3.java 0 → 100644
package alx.p17_enum;
public class Test3 {
public static void main(String[] args) {
DzienTygodnia3 wtorek = DzienTygodnia3.WTO;
System.out.print(wtorek + " ");
System.out.println(wtorek.handelDozwolony());
System.out.println(wtorek.name() + " " + wtorek.ordinal());
System.out.println(wtorek.getClass());
System.out.println(wtorek.getClass().getSuperclass());
System.out.println(wtorek.getClass().getSuperclass().getSuperclass());
System.out.println(wtorek.getClass().getSuperclass().getSuperclass().getSuperclass());
System.out.println();
DzienTygodnia3 niedziela = DzienTygodnia3.NIE;
System.out.print(niedziela + " ");
System.out.println(niedziela.handelDozwolony());
System.out.println(niedziela.name() + " " + niedziela.ordinal());
System.out.println(niedziela.getClass());
System.out.println(niedziela.getClass().getSuperclass());
System.out.println(niedziela.getClass().getSuperclass().getSuperclass());
System.out.println(niedziela.getClass().getSuperclass().getSuperclass().getSuperclass());
}
}
PC22-PrzetwarzanieDanych/src/alx/p17_enum/Zagniezdzanie.java 0 → 100644
package alx.p17_enum;
import alx.p17_enum.E4.KlasaIntancyjna;
class Zagniezdzanie1 {
int instancyjna = 10;
static int statyczna = 20;
enum E1 {A, B, C,}
static enum E2 {A, B, C;}
// Nawet jeżeli nie napiszemy static, to enum zagnieżdżony w klasie jest static
enum E3 {A, B, C;
public void metoda() {
System.out.println(statyczna);
// enum jest w kontekście statycznym
//NK System.out.println(instancyjna);
}
}
}
// W enumie mogę też zagnieździć klasę lub enuma
enum E4 {
A, B, C;
static class KlasaStatyczna {
void print() {
System.out.println("aaa");
//NK System.out.println("bbb " + name());
}
}
class KlasaIntancyjna {
void print() {
// name() to będzie nazwa tewartości (jednej z A B C),
// z której został pobrany obiekt tej klasy
System.out.println("bbb " + name());
}
}
interface III {
void test();
}
enum E5 {
}
}
public class Zagniezdzanie {
public static void main(String[] args) {
Zagniezdzanie1.E1 x = Zagniezdzanie1.E1.A;
E4.KlasaStatyczna y = new E4.KlasaStatyczna();
y.print();
KlasaIntancyjna z = E4.C.new KlasaIntancyjna();
z.print();
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/finalizacja/Konto.java 0 → 100644
package alx.p21_metody_klasy_object.finalizacja;
public class Konto {
final int numer;
int saldo;
Osoba wlasciciel;
public Konto(int numer, int saldo, Osoba wlasciciel) {
this.numer = numer;
this.saldo = saldo;
this.wlasciciel = wlasciciel;
}
@Override
public String toString() {
return "Konto nr " + numer + ", " + saldo + ", wł." + wlasciciel;
}
void wplata(int kwota) {
saldo += kwota;
}
void wyplata(int kwota) {
saldo -= kwota;
}
static void przelew(Konto nadawca, Konto odbiorca, int kwota) {
nadawca.saldo -= kwota;
odbiorca.saldo += kwota;
}
void przelew(Konto odbiorca, int kwota) {
this.saldo -= kwota;
odbiorca.saldo += kwota;
}
@Override
protected void finalize() {
// to co tu wpiszemy, zostanie uruchomione tuż przed usunięciem obiektu przez GC
System.out.println("finalize Konto nr " + numer);
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/finalizacja/Osoba.java 0 → 100644
package alx.p21_metody_klasy_object.finalizacja;
import java.time.LocalDate;
import java.time.Period;
public class Osoba {
// zmienne przechowywane w obiektach: pola (field), atrybuty (attribute), zmienne instancyjne (instance variable)
String imie, nazwisko;
LocalDate dataUrodzenia;
Osoba() {
}
Osoba(String imie, String nazwisko, LocalDate data) {
this.imie = imie;
this.nazwisko = nazwisko;
dataUrodzenia = data;
}
Osoba(String imie, String nazwisko, String data) {
this(imie, nazwisko, LocalDate.parse(data));
}
// metody - operacje, które "potrafi" wykonać obiekt
void przedstawSie() {
System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + getWiek() + " lat.");
}
public String toString() {
return imie + " " + nazwisko + " ur." + dataUrodzenia;
}
public int getWiek() {
if(dataUrodzenia == null) {
return -1;
}
Period czasZycia = Period.between(dataUrodzenia, LocalDate.now());
return czasZycia.getYears();
}
@Override
protected void finalize() {
System.out.println("finalize Osoba " + imie);
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/finalizacja/Usuwanie1.java 0 → 100644
package alx.p21_metody_klasy_object.finalizacja;
public class Usuwanie1 {
public static void main(String[] args) {
System.out.println("Tworzymy dużo obiektów");
Osoba osoba = new Osoba("Ala", "Kowalska", "1993-04-05");
for(int i = 0; i < 100; i++) {
Konto k = new Konto(i, 1000+i, osoba);
// od tego miejsca już z tego Konta nie korzystam
}
osoba = null;
System.out.println("Gotowe...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
// nie zobaczymy finalize
System.out.println("Koniec programu");
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/finalizacja/Usuwanie2_OutOfMemory.java 0 → 100644
package alx.p21_metody_klasy_object.finalizacja;
public class Usuwanie2_OutOfMemory {
public static void main(String[] args) {
System.out.println("Tworzymy dużo obiektów");
Osoba osoba = new Osoba("Ala", "Kowalska", "1993-04-05");
for(int i = 0; i < 100; i++) {
Konto k = new Konto(i, 1000+i, osoba);
// od tego miejsca już z tego Konta nie korzystam
}
osoba = null;
System.out.println("Gotowe...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
System.out.println("Alokuję dużą tablicę");
try {
long[] t = new long[1000000000]; // 8G pamięci
System.out.println("mam tablicę");
} catch (OutOfMemoryError e) {
System.out.println("brak pamięci");
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
System.out.println("Koniec programu");
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/finalizacja/Usuwanie3_gc.java 0 → 100644
package alx.p21_metody_klasy_object.finalizacja;
public class Usuwanie3_gc {
public static void main(String[] args) {
System.out.println("Tworzymy dużo obiektów");
for(int i = 0; i < 100; i++) {
Konto k = new Konto(i, 1000+i, null);
// od tego miejsca już z tego Konta nie korzystam
}
System.out.println("Gotowe...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
System.out.println("Wywołuję System.gc()");
System.gc();
System.out.println("wywołałem");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
System.out.println("Koniec programu");
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/finalizacja/Usuwanie4_Lista.java 0 → 100644
package alx.p21_metody_klasy_object.finalizacja;
import java.util.LinkedList;
import java.util.List;
public class Usuwanie4_Lista {
public static void main(String[] args) {
Osoba osoba = new Osoba("Ala", "Kowalska", "1993-04-05");
List<Konto> lista = new LinkedList<>();
for(int i = 1; i <= 100; i++) {
Konto k = new Konto(i, 100*i, osoba);
lista.add(k);
}
System.out.println("Konta utworzone");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
osoba = null;
System.out.println("Odpalam GC");
System.gc();
System.out.println("GC odpalone");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println(lista.get(50));
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
}
System.out.println("Zapominam o liście i ponownie robię GC");
lista = null;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
System.gc();
System.out.println("GC odpalone");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("koniec");
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/finalizacja/Usuwanie5_Weak.java 0 → 100644
package alx.p21_metody_klasy_object.finalizacja;
import java.lang.ref.WeakReference;
import java.util.LinkedList;
import java.util.List;
public class Usuwanie5_Weak {
public static void main(String[] args) {
Osoba osoba = new Osoba("Ala", "Kowalska", "1993-04-05");
List<WeakReference<Konto>> lista = new LinkedList<>();
for(int i = 1; i <= 100; i++) {
Konto k = new Konto(i, 100*i, osoba);
lista.add(new WeakReference<Konto>(k));
}
System.out.println("Konta utworzone");
System.out.println("przykładowe konto: " + lista.get(50).get());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
osoba = null;
System.out.println("Odpalam GC");
System.gc();
System.out.println("GC odpalone\n");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("teraz odczyt konta: " + lista.get(50).get());
System.out.println("koniec");
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie1/Konto.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie1;
public class Konto implements Cloneable {
final int numer;
int saldo;
Osoba wlasciciel;
public Konto(int numer, int saldo, Osoba wlasciciel) {
this.numer = numer;
this.saldo = saldo;
this.wlasciciel = wlasciciel;
}
@Override
public String toString() {
return "Konto nr " + numer + ", " + saldo + ", wł." + wlasciciel;
}
void wplata(int kwota) {
saldo += kwota;
}
void wyplata(int kwota) {
saldo -= kwota;
}
static void przelew(Konto nadawca, Konto odbiorca, int kwota) {
nadawca.saldo -= kwota;
odbiorca.saldo += kwota;
}
void przelew(Konto odbiorca, int kwota) {
this.saldo -= kwota;
odbiorca.saldo += kwota;
}
/* W tej wersji korzystam z domyślnej implementacji clone(), tylko ją upubliczniam.
*/
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie1/Osoba.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie1;
import java.time.LocalDate;
import java.time.Period;
public class Osoba implements Cloneable {
// zmienne przechowywane w obiektach: pola (field), atrybuty (attribute), zmienne instancyjne (instance variable)
String imie, nazwisko;
LocalDate dataUrodzenia;
Osoba() {
}
Osoba(String imie, String nazwisko, LocalDate data) {
this.imie = imie;
this.nazwisko = nazwisko;
dataUrodzenia = data;
}
Osoba(String imie, String nazwisko, String data) {
this(imie, nazwisko, LocalDate.parse(data));
}
// metody - operacje, które "potrafi" wykonać obiekt
void przedstawSie() {
System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + getWiek() + " lat.");
}
public String toString() {
return imie + " " + nazwisko + " ur." + dataUrodzenia;
}
public int getWiek() {
if(dataUrodzenia == null) {
return -1;
}
Period czasZycia = Period.between(dataUrodzenia, LocalDate.now());
return czasZycia.getYears();
}
@Override
public Osoba clone() {
try {
return (Osoba) super.clone();
} catch (CloneNotSupportedException e) {
// should never happen
throw new RuntimeException(e);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie1/TestKlonowania.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie1;
public class TestKlonowania {
public static void main(String[] args) {
// Użycie domyślnej wersji clone wymaga rzutowania obiektu na właściwy typ i obsłużenia wyjątku CloneNotSupportedException
try {
Osoba ala = new Osoba("Ala", "Kowalska", "2001-02-03");
Konto konto = new Konto(1, 1000, ala);
Konto klon;
klon = (Konto) konto.clone();
System.out.println("oryginał: " + konto);
System.out.println("klon : " + klon);
System.out.println();
klon.wplata(300);
klon.wlasciciel.imie = "Alicja";
System.out.println("oryginał: " + konto);
System.out.println("klon : " + klon);
System.out.println();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie2/Konto.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie2;
public class Konto implements Cloneable {
final int numer;
int saldo;
Osoba wlasciciel;
public Konto(int numer, int saldo, Osoba wlasciciel) {
this.numer = numer;
this.saldo = saldo;
this.wlasciciel = wlasciciel;
}
@Override
public String toString() {
return "Konto nr " + numer + ", " + saldo + ", wł." + wlasciciel;
}
void wplata(int kwota) {
saldo += kwota;
}
void wyplata(int kwota) {
saldo -= kwota;
}
static void przelew(Konto nadawca, Konto odbiorca, int kwota) {
nadawca.saldo -= kwota;
odbiorca.saldo += kwota;
}
void przelew(Konto odbiorca, int kwota) {
this.saldo -= kwota;
odbiorca.saldo += kwota;
}
/* W tej wersji korzystam z domyślnej implementacji clone()
* upubliczniając ją i dostosowując do łatwiego używania (zmiana typu, bez deklarowanego wyjątku).
* Domyślnie tworzy to płytką kopię.
* Wg mnie wygląda to paskudnie.
*/
@Override
public Konto clone() {
try {
return (Konto)super.clone();
} catch (CloneNotSupportedException e) {
// should never happen
throw new RuntimeException(e);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie2/Osoba.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie2;
import java.time.LocalDate;
import java.time.Period;
public class Osoba implements Cloneable {
// zmienne przechowywane w obiektach: pola (field), atrybuty (attribute), zmienne instancyjne (instance variable)
String imie, nazwisko;
LocalDate dataUrodzenia;
Osoba() {
}
Osoba(String imie, String nazwisko, LocalDate data) {
this.imie = imie;
this.nazwisko = nazwisko;
dataUrodzenia = data;
}
Osoba(String imie, String nazwisko, String data) {
this(imie, nazwisko, LocalDate.parse(data));
}
// metody - operacje, które "potrafi" wykonać obiekt
void przedstawSie() {
System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + getWiek() + " lat.");
}
public String toString() {
return imie + " " + nazwisko + " ur." + dataUrodzenia;
}
public int getWiek() {
if(dataUrodzenia == null) {
return -1;
}
Period czasZycia = Period.between(dataUrodzenia, LocalDate.now());
return czasZycia.getYears();
}
@Override
public Osoba clone() {
try {
return (Osoba) super.clone();
} catch (CloneNotSupportedException e) {
// should never happen
throw new RuntimeException(e);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie2/TestKlonowania.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie2;
public class TestKlonowania {
public static void main(String[] args) {
Osoba ala = new Osoba("Ala", "Kowalska", "2001-02-03");
Konto konto = new Konto(1, 1000, ala);
Konto klon = konto.clone();
System.out.println("oryginał: " + konto);
System.out.println("klon : " + klon);
System.out.println();
klon.wplata(300);
klon.wlasciciel.imie = "Alicja";
System.out.println("oryginał: " + konto);
System.out.println("klon : " + klon);
System.out.println();
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie3/Konto.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie3;
public class Konto implements Cloneable {
final int numer;
int saldo;
Osoba wlasciciel;
public Konto(int numer, int saldo, Osoba wlasciciel) {
this.numer = numer;
this.saldo = saldo;
this.wlasciciel = wlasciciel;
}
@Override
public String toString() {
return "Konto nr " + numer + ", " + saldo + ", wł." + wlasciciel;
}
void wplata(int kwota) {
saldo += kwota;
}
void wyplata(int kwota) {
saldo -= kwota;
}
static void przelew(Konto nadawca, Konto odbiorca, int kwota) {
nadawca.saldo -= kwota;
odbiorca.saldo += kwota;
}
void przelew(Konto odbiorca, int kwota) {
this.saldo -= kwota;
odbiorca.saldo += kwota;
}
/* W tej wersji korzystam z domyślnej implementacji clone()
* upubliczniając ją i dostosowując do łatwiego używania (zmiana typu, bez deklarowanego wyjątku).
* Ponadto staram się, aby clone() tworzył głęboką kopię - zmieniam pole wlasciciel.
* Nie ma natomiast potrzeby klonować pól, które są klas niemutowalnych (String, LocalDate itp.).
*/
@Override
public Konto clone() {
try {
Konto klon = (Konto) super.clone();
klon.wlasciciel = wlasciciel.clone();
return klon;
} catch (CloneNotSupportedException e) {
// should never happen
throw new RuntimeException(e);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie3/Osoba.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie3;
import java.time.LocalDate;
import java.time.Period;
public class Osoba implements Cloneable {
// zmienne przechowywane w obiektach: pola (field), atrybuty (attribute), zmienne instancyjne (instance variable)
String imie, nazwisko;
LocalDate dataUrodzenia;
Osoba() {
}
Osoba(String imie, String nazwisko, LocalDate data) {
this.imie = imie;
this.nazwisko = nazwisko;
dataUrodzenia = data;
}
Osoba(String imie, String nazwisko, String data) {
this(imie, nazwisko, LocalDate.parse(data));
}
// metody - operacje, które "potrafi" wykonać obiekt
void przedstawSie() {
System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + getWiek() + " lat.");
}
public String toString() {
return imie + " " + nazwisko + " ur." + dataUrodzenia;
}
public int getWiek() {
if(dataUrodzenia == null) {
return -1;
}
Period czasZycia = Period.between(dataUrodzenia, LocalDate.now());
return czasZycia.getYears();
}
@Override
public Osoba clone() {
try {
return (Osoba) super.clone();
} catch (CloneNotSupportedException e) {
// should never happen
throw new RuntimeException(e);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie3/TestKlonowania.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie3;
public class TestKlonowania {
public static void main(String[] args) {
Osoba ala = new Osoba("Ala", "Kowalska", "2001-02-03");
Konto konto = new Konto(1, 1000, ala);
Konto klon = konto.clone();
System.out.println("oryginał: " + konto);
System.out.println("klon : " + klon);
System.out.println();
klon.wplata(300);
klon.wlasciciel.imie = "Alicja";
System.out.println("oryginał: " + konto);
System.out.println("klon : " + klon);
System.out.println();
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie4/Konto.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie4;
public class Konto implements Cloneable {
final int numer;
int saldo;
Osoba wlasciciel;
public Konto(int numer, int saldo, Osoba wlasciciel) {
this.numer = numer;
this.saldo = saldo;
this.wlasciciel = wlasciciel;
}
@Override
public String toString() {
return "Konto nr " + numer + ", " + saldo + ", wł." + wlasciciel;
}
void wplata(int kwota) {
saldo += kwota;
}
void wyplata(int kwota) {
saldo -= kwota;
}
static void przelew(Konto nadawca, Konto odbiorca, int kwota) {
nadawca.saldo -= kwota;
odbiorca.saldo += kwota;
}
void przelew(Konto odbiorca, int kwota) {
this.saldo -= kwota;
odbiorca.saldo += kwota;
}
/* W tej wersji tworzę własną implementację clone() za pomocą konstruktora.
* Wg mnie wygląda to znacznie lepiej.
* W tej wersji od razu głęboka kopia.
*/
@Override
public Konto clone() {
return new Konto(this.numer, this.saldo, this.wlasciciel.clone());
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie4/Osoba.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie4;
import java.time.LocalDate;
import java.time.Period;
public class Osoba implements Cloneable {
// zmienne przechowywane w obiektach: pola (field), atrybuty (attribute), zmienne instancyjne (instance variable)
String imie, nazwisko;
LocalDate dataUrodzenia;
Osoba() {
}
Osoba(String imie, String nazwisko, LocalDate data) {
this.imie = imie;
this.nazwisko = nazwisko;
dataUrodzenia = data;
}
Osoba(String imie, String nazwisko, String data) {
this(imie, nazwisko, LocalDate.parse(data));
}
// metody - operacje, które "potrafi" wykonać obiekt
void przedstawSie() {
System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + getWiek() + " lat.");
}
public String toString() {
return imie + " " + nazwisko + " ur." + dataUrodzenia;
}
public int getWiek() {
if(dataUrodzenia == null) {
return -1;
}
Period czasZycia = Period.between(dataUrodzenia, LocalDate.now());
return czasZycia.getYears();
}
@Override
protected Osoba clone() {
return new Osoba(imie, nazwisko, dataUrodzenia);
// String i LocalDate nie trzeba już klonować, ponieważ są to klasy immutable
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/klonowanie4/TestKlonowania.java 0 → 100644
package alx.p21_metody_klasy_object.klonowanie4;
public class TestKlonowania {
public static void main(String[] args) {
Osoba ala = new Osoba("Ala", "Kowalska", "2001-02-03");
Konto konto = new Konto(1, 1000, ala);
Konto klon = konto.clone();
System.out.println("oryginał: " + konto);
System.out.println("klon : " + klon);
System.out.println();
klon.wplata(300);
klon.wlasciciel.imie = "Alicja";
System.out.println("oryginał: " + konto);
System.out.println("klon : " + klon);
System.out.println();
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/porownywanie/Porownywanie1.java 0 → 100644
package alx.p21_metody_klasy_object.porownywanie;
class A {
int x, y;
public A(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "( " + x + "," + y +")";
}
}
public class Porownywanie1 {
public static void main(String[] args) {
A a1 = new A(10, 20);
A a2 = new A(10, 20);
A a3 = new A(10, 30);
System.out.println(a1 == a2);
System.out.println(a1 == a3);
System.out.println();
System.out.println(a1.equals(a2));
System.out.println(a1.equals(a3));
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/porownywanie/Porownywanie2.java 0 → 100644
package alx.p21_metody_klasy_object.porownywanie;
import java.util.HashSet;
// Ta wersja nie nadpisuje equals! Tylko dodaje inną metodę
class B {
int x, y;
public B(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "(" + x + "," + y +")";
}
public boolean equals(B that) {
return this.x == that.x && this.y == that.y;
}
public int hashCode() {
return 0;
}
}
public class Porownywanie2 {
public static void main(String[] args) {
B b1 = new B(10, 20);
B b2 = new B(10, 20);
B b3 = new B(10, 30);
System.out.println(b1.toString());
System.out.println(b2.toString());
System.out.println(b3.toString());
System.out.println(b1 == b2);
System.out.println(b1 == b3);
System.out.println();
// chociaż nieprawidłowo zaimplementowałem equals w klasie B, to ten test działa
System.out.println(b1.equals(b2));
System.out.println(b1.equals(b3));
System.out.println();
Object o1 = b1;
Object o2 = b2;
Object o3 = b3;
System.out.println(o1.equals(o2)); // tu działa wersja z Object
System.out.println(o1.equals(o3));
System.out.println();
HashSet<B> zbior = new HashSet<>();
zbior.add(b1);
zbior.add(b2);
zbior.add(b3);
System.out.println(zbior.size());
System.out.println(zbior);
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/porownywanie/Porownywanie3.java 0 → 100644
package alx.p21_metody_klasy_object.porownywanie;
import java.util.HashSet;
class C {
int x, y;
public C(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "(" + x + "," + y +")";
}
@Override
public boolean equals(Object o) {
if(o instanceof C) {
C that = (C)o;
return this.x == that.x && this.y == that.y;
} else {
return false;
}
}
@Override
public int hashCode() {
// taki hashCode jest poprawny, w tym sensie, że spełnia minimalne wymagania kontraktu
// zazwyczaj taka implementacja jest niewydajna i w praktyce tak się nie robi
return 0;
}
}
public class Porownywanie3 {
public static void main(String[] args) {
C c1 = new C(10, 20);
C c2 = new C(10, 20);
C c3 = new C(10, 30);
System.out.println(c1.toString());
System.out.println(c2.toString());
System.out.println(c3.toString());
System.out.println(c1 == c2);
System.out.println(c1 == c3);
System.out.println();
// chociaż nieprawidłowo zaimplementowałem equals w klasie B, to ten test działa
System.out.println(c1.equals(c2));
System.out.println(c1.equals(c3));
System.out.println();
Object o1 = c1;
Object o2 = c2;
Object o3 = c3;
System.out.println(o1.equals(o2)); // tu działa wersja z Object
System.out.println(o1.equals(o3));
System.out.println();
HashSet<C> zbior = new HashSet<>();
zbior.add(c1);
zbior.add(c2);
zbior.add(c3);
System.out.println(zbior.size());
System.out.println(zbior);
}
}
PC22-PrzetwarzanieDanych/src/alx/p21_metody_klasy_object/porownywanie/Porownywanie4.java 0 → 100644
package alx.p21_metody_klasy_object.porownywanie;
import java.util.HashSet;
class D {
int x, y;
public D(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "(" + x + "," + y +")";
}
@Override
public boolean equals(Object o) {
if(o instanceof D) {
D that = (D)o;
return this.x == that.x && this.y == that.y;
} else {
return false;
}
}
@Override
public int hashCode() {
// poprawnym hashCode będzie każdy, który do uzyskania wyniku używa wyłącznie wartości porównywanych w equals
return x*y;
}
}
public class Porownywanie4 {
public static void main(String[] args) {
D d1 = new D(10, 20);
D d2 = new D(10, 20);
D d3 = new D(10, 30);
System.out.println(d1.toString());
System.out.println(d2.toString());
System.out.println(d3.toString());
System.out.println(d1 == d2);
System.out.println(d1 == d3);
System.out.println();
// chociaż nieprawidłowo zaimplementowałem equals w klasie B, to ten test działa
System.out.println(d1.equals(d2));
System.out.println(d1.equals(d3));
System.out.println();
Object o1 = d1;
Object o2 = d2;
Object o3 = d3;
System.out.println(o1.equals(o2)); // tu działa wersja z Object
System.out.println(o1.equals(o3));
System.out.println();
HashSet<D> zbior = new HashSet<>();
zbior.add(d1);
zbior.add(d2);
zbior.add(d3);
System.out.println(zbior.size());
System.out.println(zbior);
}
}
PC22-PrzetwarzanieDanych/src/alx/p22_wrappery/Parametry.java 0 → 100644
package alx.p22_wrappery;
import java.util.concurrent.atomic.AtomicInteger;
public class Parametry {
static void test(int i, Integer j, AtomicInteger k) {
i += 5;
j += 6; // to nie zmienia wartości wewnątrz obiektu, tylko tworzy nowy obiekt
// tak jakby: j = new Integer(j.intValue() + 6);
k.addAndGet(7);
System.out.println("i: " + i + " , j: " + j + " , k: " + k);
}
public static void main(String[] args) {
int x = 100;
Integer y = 200;
// Integer y = new Integer(200); // zadziała tak samo
AtomicInteger z = new AtomicInteger(300);
System.out.println("x: " + x + " , y: " + y + " , z: " + z);
test(x, y, z);
System.out.println("x: " + x + " , y: " + y + " , z: " + z);
}
}
PC22-PrzetwarzanieDanych/src/alx/p22_wrappery/Wrappery1_Podstawy.java 0 → 100644
package alx.p22_wrappery;
public class Wrappery1_Podstawy {
public static void main(String[] args) {
// Dla każdego z 8 typów prostych istnieje odpowiadająca mu klasa ("opakowaniowa"?), tzw. "wrapper".
// Obiekt klasy wrapper zawiera w sobie wartość danego typu.
// Wszystkie klasy wrapperów są NIEMUTOWALNE, tzn. wartość w obiekcie nigdy nie ulega zmianie; /na zmienną typu wrapper można wpisać nowy obiekt, ale to nie to samo./
int i = 103;
// Obiekt klasy opakowaniowej na podstawie wartości można utworzyć:
// - za pomocą konstruktora (obecnie niezalecane)
Integer ii1 = new Integer(i);
// - za pomocą metody valueOf
Integer ii2 = Integer.valueOf(i);
// - za pomocą automatycznej konwersji (autoboxing, od Javy 5); wewnętrznie jest to realizowane za pomocą valueOf
Integer ii3 = i;
byte y = 15;
Byte yy1 = new Byte(y);
Byte yy2 = Byte.valueOf(y);
Byte yy3 = y;
short s = 10_000;
Short ss1 = new Short(s);
Short ss2 = Short.valueOf(s);
Short ss3 = s;
long l = 4_000_000L;
Long ll1 = new Long(l);
Long ll2 = Long.valueOf(l);
Long ll3 = l;
float f = 3.14F;
Float ff1 = new Float(f);
Float ff2 = Float.valueOf(f);
Float ff3 = f;
double d = 1.4142;
Double dd1 = new Double(d);
Double dd2 = Double.valueOf(d);
Double dd3 = d;
char c = 'A';
Character cc1 = new Character(c);
Character cc2 = Character.valueOf(c);
Character cc3 = c;
boolean b = true;
Boolean bb1 = new Boolean(b);
Boolean bb2 = Boolean.valueOf(b);
Boolean bb3 = b;
// Dodatkowo istnieje klasa Void, odpowiadająca typowi void.
// Nie da się utworzyć obiektu tej klasy.
Void v = null;
}
}
PC22-PrzetwarzanieDanych/src/alx/p22_wrappery/Wrappery2_Zastosowania.java 0 → 100644
package alx.p22_wrappery;
import java.util.ArrayList;
import java.util.List;
public class Wrappery2_Zastosowania {
public static void main(String[] args) {
// Zastosowania wrapperów.
// 1) Stałe i metody statyczne zdefiniowane w klasie
String liczbaTekstowo = "12345";
int liczba = Integer.parseInt(liczbaTekstowo);
Integer obiekt = Integer.valueOf(liczbaTekstowo);
System.out.println(liczba * 2);
System.out.printf("Typ %s ma %d bajty, czyli %d bity, minimalna wartość to %d, a maksymalna %d\n",
Integer.TYPE.getSimpleName(), Integer.BYTES, Integer.SIZE, Integer.MIN_VALUE, Integer.MAX_VALUE);
// 2) Obiekt jako "wartość opcjonalna".
// Zmienna/funkcja typu int MUSI mieć/zwracać jakąś wartość. Każdy ciąg bitów w zmiennej typu prostego oznacza jakąś konkretną wartość.
// Zmienna typu obiektowego może wskazywać na obiekt LUB mieć wartość null. null może być traktowany jako dodatkowa wartość oznaczająca brak danych/brak wyniku
// Współcześnie bardziej zalecane do tego celu jest używanie klas Optional (np. OptionalInt), ale tradycyjnie używało się wrapperów i w wielu miejscach to pozostało.
int[] a = {13, 7, 14, 3, 12};
int[] b = {13, 7, 3, 9, -5};
Integer wynik1 = pierwszaParzysta(a);
if(wynik1 != null) {
System.out.println("pierwszy wynik: " + wynik1);
} else {
System.out.println("brak pierwszego wyniku");
}
Integer wynik2 = pierwszaParzysta(b);
if(wynik2 != null) {
System.out.println("drugi wynik: " + wynik2);
} else {
System.out.println("brak drugiego wyniku");
}
// 3) Kolekcje i bardziej ogólnie deklaracje typów generycznych.
// nie da rady: List<int> listaLiczb1 = new ArrayList<>();
List<Integer> listaLiczb = new ArrayList<>();
for(int x : a) {
listaLiczb.add(x);
}
System.out.println(listaLiczb);
}
public static Integer pierwszaParzysta(int[] tab) {
for(int x : tab) {
if(x % 2 == 0) {
return x;
}
}
return null;
}
}
PC22-PrzetwarzanieDanych/src/alx/p22_wrappery/Wrappery3_Wydajnosc.java 0 → 100644
package alx.p22_wrappery;
// Integer i Long są dużo wolniejsze niż int i long
// z tego powodu używanie List<Integer> jest dużo wolniejsze niż int[]
// Gdy w Javie 8 wymyślano Streamy, stworzono osobne wersje IntStream, DoubleStream, LongStream
// i lepiej ich używać zamiast Stream<Integer> itd.
public class Wrappery3_Wydajnosc {
static Long suma1(int n) {
Long wynik = 0L;
for(Integer i = 1; i <= n; i++) {
wynik += i;
}
return wynik;
}
static long suma2(int n) {
long wynik = 0L;
for(int i = 1; i <= n; i++) {
wynik += i;
}
return wynik;
}
public static void main(String[] args) {
int n = 1_000_000_000;
long p, k;
System.out.println("v1 start");
p = System.currentTimeMillis();
Long wynik1 = suma1(n);
k = System.currentTimeMillis();
System.out.println("v1 wynik: " + wynik1);
System.out.println("czas: " + (k - p));
System.out.println();
System.out.println("v2 start");
p = System.currentTimeMillis();
long wynik2 = suma2(n);
k = System.currentTimeMillis();
System.out.println("v2 wynik: " + wynik2);
System.out.println("czas: " + (k - p));
}
}
PC22-PrzetwarzanieDanych/src/alx/p22_wrappery/Wrappery4_WielkaCiekawostka.java 0 → 100644
package alx.p22_wrappery;
public class Wrappery4_WielkaCiekawostka {
public static void main(String[] args) {
Integer x, y;
x = 100;
y = 100;
System.out.println(x == y);
x = 200;
y = 200;
System.out.println(x == y);
System.out.println();
// wyjasnienie: automatyczny boxing jest robiony za pomocą valueOf:
x = Integer.valueOf(100);
y = Integer.valueOf(100);
System.out.println(x == y);
System.out.println(x.equals(y));
System.out.println();
x = Integer.valueOf(200);
y = Integer.valueOf(200);
System.out.println(x == y);
System.out.println(x.equals(y));
}
}
PC22-PrzetwarzanieDanych/src/alx/p22_wrappery/Wrappery5_Null.java 0 → 100644
package alx.p22_wrappery;
import java.util.HashMap;
import java.util.Map;
public class Wrappery5_Null {
static int pomnoz(Integer a) {
return 2*a;
}
static int dodaj(int a) {
return 2*a;
}
public static void main(String[] args) {
Integer x, y;
x = 55;
y = null;
System.out.println(pomnoz(x));
System.out.println(pomnoz(y)); // NPE w środku metody
System.out.println(dodaj(x));
System.out.println(dodaj(y)); // NPE przy przekazywaniu parametru
int z = y; // NPE przy przypisaniu
System.out.println(z);
// bo tak naprawde
int z2 = y.intValue();
// Szczególnie trzeba uważać przy korzystaniu z map:
Map<String, Integer> mapa = new HashMap<>();
mapa.put("Ala", 30);
mapa.put("Ola", 40);
// typy błąd programisty:
// NullPointerException, bo mapa.get zwraca null, a my wpisujemy to na zmienną int
// int wiek = mapa.get("Ula");
// System.out.println(wiek);
Integer wiek2 = mapa.get("Ula");
System.out.println(wiek2);
// teraz operacje liczbowe będą powodowały błedy:
// System.out.println(wiek2 + 1);
}
}
PC22-PrzetwarzanieDanych/src/alx/p22_wrappery/Wrappery6_Number.java 0 → 100644
package alx.p22_wrappery;
public class Wrappery6_Number {
public static void main(String[] args) {
Number n = 777;
System.out.println(n.byteValue());
System.out.println(n.shortValue());
System.out.println(n.intValue());
System.out.println(n.longValue());
System.out.println(n.floatValue());
System.out.println(n.doubleValue());
}
}
PC22-PrzetwarzanieDanych/src/alx/p22_wrappery/Wrappery7_Parsowanie.java 0 → 100644
package alx.p22_wrappery;
public class Wrappery7_Parsowanie {
public static void main(String[] args) {
String tekst = "1234";
// typ wyniku int
int x = Integer.parseInt(tekst);
System.out.println(2*x);
// typ wyniku Integer
Integer y = Integer.valueOf(tekst);
// skompiluje się też, ale mnie wydajne:
int xx = Integer.valueOf(tekst);
Integer yy = Integer.parseInt(tekst);
double d = Double.parseDouble(tekst);
System.out.println(d);
}
}
PC22-PrzetwarzanieDanych/src/alx/p22_wrappery/Wrappery8_Lista.java 0 → 100644
package alx.p22_wrappery;
import java.util.ArrayList;
import java.util.List;
public class Wrappery8_Lista {
public static void main(String[] args) {
List<String> napisy = new ArrayList<>();
napisy.add("Ala");
napisy.add("Ola");
napisy.add("Ela");
napisy.add("Ula");
System.out.println(napisy);
napisy.remove(2); // usuwa według indeksu, zwraca referencję do usuwanego obiektu
System.out.println(napisy);
napisy.remove("Ala"); // usuwa wg wartości, zwraca boolean mówiący czy element został usunięty
System.out.println(napisy);
System.out.println();
List<Integer> liczby = new ArrayList<>();
liczby.add(4);
liczby.add(8);
liczby.add(1);
liczby.add(5);
liczby.add(13);
liczby.add(12);
liczby.add(5);
liczby.add(1);
System.out.println(liczby);
// liczby.remove(12); // traktowane jako pozycja
Integer co = liczby.remove(0); // traktowane jako pozycja
// System.out.println(liczby);
// traktowane jako obiekt - czyli wartość wpisu
boolean czy = liczby.remove((Object)13);
liczby.remove(new Integer(12));
liczby.remove(Integer.valueOf(5));
System.out.println(liczby);
}
}
PC22-PrzetwarzanieDanych/src/alx/p22_wrappery/Wrappery9_WydajnoscList.java 0 → 100644
package alx.p22_wrappery;
import java.util.ArrayList;
import java.util.Locale;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
public class Wrappery9_WydajnoscList {
// wiekość tablicy
private static final int N = 100_000_000;
// ilość powtórzeń odczytu
private static final int K = 20;
private static void zmierzCzas(String tytul, Runnable procedura) {
System.out.println("\nZaczynam " + tytul);
long start = System.nanoTime();
procedura.run();
long koniec = System.nanoTime();
double czas = (koniec - start) * 1e-9;
System.out.printf(Locale.US, "%s: %10.6f s\n", tytul, czas);
}
private static void wyczysc() {
try {
System.gc();
Thread.sleep(2000);
} catch (InterruptedException e) {
}
}
private static void petla() {
long suma = 0L;
for(int k = 0; k < K; k++) {
for(int i = 0; i < N; i++) {
suma += i;
}
}
System.out.println(suma);
}
private static void tablica() {
int[] t = new int[N];
for(int i = 0; i < N; i++) {
t[i] = i;
}
long suma = 0L;
for(int k = 0; k < K; k++) {
for(int x : t) {
suma += x;
}
}
System.out.println(suma);
}
private static void array_list() {
ArrayList<Integer> l = new ArrayList<>();
for(int i = 0; i < N; i++) {
l.add(i);
}
long suma = 0L;
for(int k = 0; k < K; k++) {
for(int x : l) {
suma += x;
}
}
System.out.println(suma);
}
private static void stream_range() {
long suma = 0L;
for(int k = 0; k < K; k++) {
suma += LongStream.range(0, N).sum();
}
System.out.println(suma);
}
private static void stream_tablica() {
int[] t = IntStream.range(0, N).toArray();
long suma = 0L;
for(int k = 0; k < K; k++) {
suma += IntStream.of(t).asLongStream().sum();
}
System.out.println(suma);
}
public static void main(String[] args) {
System.out.println("Startujemy...");
zmierzCzas("Pętla bez kolekcji", Wrappery9_WydajnoscList::petla);
wyczysc();
zmierzCzas("Tablica", Wrappery9_WydajnoscList::tablica);
wyczysc();
zmierzCzas("ArrayList", Wrappery9_WydajnoscList::array_list);
wyczysc();
zmierzCzas("Stream (range)", Wrappery9_WydajnoscList::stream_range);
wyczysc();
zmierzCzas("Stream (tablica)", Wrappery9_WydajnoscList::stream_tablica);
wyczysc();
System.out.println("Koniec");
}
}
PC22-PrzetwarzanieDanych/src/alx/p23_tablice/FunkcjaNaTablicy_Przyklad.java 0 → 100644
package alx.p23_tablice;
public class FunkcjaNaTablicy_Przyklad {
static int suma(int[] t) {
int wynik = 0;
for (int el : t) {
wynik += el;
}
return wynik;
}
public static void main(String[] args) {
int[] a = {1, 3, 5, 7};
int[] b = {10, -5, 15, -20, 0};
int[] e = {};
System.out.println("suma a: " + suma(a));
System.out.println("suma b: " + suma(b));
System.out.println("suma e: " + suma(e));
}
}
PC22-PrzetwarzanieDanych/src/alx/p23_tablice/KlasaArrays.java 0 → 100644
package alx.p23_tablice;
import java.util.Arrays;
public class KlasaArrays {
public static void main(String[] args) {
// Klasa narzędziowa Arrays definiuje różne gotowe operacje na tablicach
int[] liczby = new int[100];
String[] napisy = new String[10];
System.out.println(liczby);
System.out.println(Arrays.toString(liczby));
System.out.println(napisy);
System.out.println(Arrays.toString(napisy));
System.out.println();
Arrays.fill(liczby, 33);
System.out.println(Arrays.toString(liczby));
Arrays.sort(liczby);
System.out.println(Arrays.toString(liczby));
}
}
PC22-PrzetwarzanieDanych/src/alx/p23_tablice/Kopiowanie1.java 0 → 100644
package alx.p23_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));
}
}
PC22-PrzetwarzanieDanych/src/alx/p23_tablice/Kopiowanie2.java 0 → 100644
package alx.p23_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();
}
}
PC22-PrzetwarzanieDanych/src/alx/p23_tablice/Kopiowanie3.java 0 → 100644
package alx.p23_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));
}
}
PC22-PrzetwarzanieDanych/src/alx/p23_tablice/SredniaLiczb.java 0 → 100644
package alx.p23_tablice;
import java.util.Arrays;
import java.util.OptionalDouble;
import java.util.stream.DoubleStream;
public class SredniaLiczb {
public static void main(String[] args) {
// Tablica zawiera liczby.
// Przyjmijmy, że są to temperatury zmierzone w kolejne dni tygodnia... :)
double[] t = {5.5, 6.7, 9.1, 7.0, 4.0, 6.7, 10};
System.out.println(Arrays.toString(t));
// Zadanie: oblicz średnią z tych liczb
// sposób prosty, ale nieprofesjonalny - "nie skaluje się", tzn. nie da się zastosować dla dużo większych tablic
// każda zmiana ilości liczb wymaga zmian w kodzie
double srednia1 = (t[0] + t[1] + t[2] + t[3] + t[4] + t[5] + t[6]) / 7;
System.out.println(srednia1);
// wersja przejściowa, tylko żeby znowu wytłumaczyć "schemat ze skarbonką"
double suma2 = 0;
suma2 += t[0];
suma2 += t[1];
suma2 += t[2];
suma2 += t[3];
suma2 += t[4];
suma2 += t[5];
suma2 += t[6];
double srednia2 = suma2 / t.length;
System.out.println(srednia2);
// zamiast 7 raz pisać podobną linię kodu, mogę raz umieścić ją w pętli
// Ta wersja już zadziała dla tablic dowolnej wielkości.
double suma3 = 0;
for(int i = 0; i < t.length; i++) {
suma3 += t[i];
}
double srednia3 = suma3 / t.length;
System.out.println(srednia3);
// wersja z pętlą "for-each"
double suma4 = 0;
for (double liczba : t) {
suma4 += liczba;
}
double srednia4 = suma4 / t.length;
System.out.println(srednia4);
// istnieją gotowe rozwiązania
OptionalDouble srednia5 = DoubleStream.of(t).average();
if(srednia5.isPresent()) {
System.out.println(srednia5.getAsDouble());
} else {
System.out.println("nie ma średniej, bo pusta tablica");
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p23_tablice/Tablice1_Motywacja.java 0 → 100644
package alx.p23_tablice;
import java.util.Arrays;
public class Tablice1_Motywacja {
public static void main(String[] args) {
// Motywacja:
// Gdybym potrzebował zapamiętać nie jedną wartość, ale kilka, co mogę zrobić?
// 1) Zdefiniować kilka zmiennych
String imie1, imie2, imie3;
imie1 = "Ala";
imie2 = "Ola";
imie3 = "Ela";
// Mogę odwołać się do pojedynczych wartości
System.out.println("Pierwsza osoba to " + imie1);
System.out.println("Druga osoba to " + imie2);
System.out.println("Trzecia osoba to " + imie3);
System.out.println();
// Ale nie mam jak wykonać operacji "na raz dla wszystkich wartości". Trzeba instrukcję pisać osobno dla każdej zmiennej.
// Poza tym to się "nie skaluje" - nie obsłużymy w ten sposób dużych ilości danych.
// 2) Użyć tablicy lub kolekcji.
String[] imiona = new String[5];
imiona[1] = "Ala";
imiona[2] = "Ola";
imiona[3] = "Ela";
// Nadal mogę odwołać się do pojedynczych wartości
System.out.println("Pierwsza osoba to " + imiona[1]);
System.out.println("Druga osoba to " + imiona[2]);
System.out.println("Trzecia osoba to " + imiona[3]);
System.out.println();
// Ale teraz na różne sposoby mogę wykonywać operacje na całej tablicy.
// Można też tworzyć tablice dużych rozmiarów (technicznie: w zakresie int, czyli do 2mld+, o ile wystarczy pamięci).
// Podstawowa technika przeglądania wszystkich elementów tablicy - pętla.
System.out.println("Wszystkie elementy tablicy:");
for(String imie : imiona) {
System.out.println(" * " + imie);
}
System.out.println();
// Są też dostępne gotowe operacje dla tablic, głównie w klasie narzędziowej Arrays.
// Aby zobaczyć elementy, używamy Arrays.toString
System.out.println(Arrays.toString(imiona));
// Długość tablicy
System.out.println(imiona.length);
// Widzimy teraz, że
// 1) w miejscach, na które nie wpisaliśmy żadenj wartości, są null-e
// 2) pozycje w tablicy są numerowane od 0. Poprawne numery to zawsze od 0 do length-1 (length to długość tablicy)
// próba odwołania się poza zakresem (odczyt i zapis) kończy się wyjątkiem
// System.out.println(imiona[20]); // wyjątek
// Można tworzyć tablice obiektów (np. String), ale także typów prostych (np. int)
// Początkową wartością elementów jest null dla obiektów, a 0 lub false dla tablic typu prostego.
int[] liczby = new int[10];
System.out.println(Arrays.toString(liczby));
}
}
PC22-PrzetwarzanieDanych/src/alx/p23_tablice/Tablice2_Tworzenie.java 0 → 100644
package alx.p23_tablice;
import java.util.Arrays;
public class Tablice2_Tworzenie {
public static void main(String[] args) {
int[] a;
// tylko deklaracja zmiennej, zmienna jest niezainicjowana
// Poniższe linie się nie kompilują:
// System.out.println(a);
// System.out.println(a[1]);
// a[1] = 10; // to jest tak naprawdę ODCZYT zmiennej a (bo a jest referencją)
// System.out.println(a[1]);
a = null;
System.out.println(a);
int rozmiar = 10;
// utworzenie tablicy i wpisanie do zmiennej a
// Tak tworzona tablica ma określony rozmiar i jest inicjalizaowana wartościami null, 0 lub false
a = new int[rozmiar];
a[1] = 133;
a[3] = 150;
System.out.println(Arrays.toString(a));
// Istniejącej tablicy nie da się rozszerzać, można najwyżej utowrzyć nową tablicę i wpisać na dotychczasową zmienną - ale to będzie utrata danych.
// do zmiennej a można wpisać inną (np. nową) tablicę - dotychczasowa jest zapominana
a = new int[2*rozmiar];
System.out.println(Arrays.toString(a));
System.out.println();
// można deklaracje i inicjalizacje zapisać w jednej linii:
double[] wspolrzedne = new double[3];
System.out.println(Arrays.toString(wspolrzedne));
// takiej składni nie ma w Javie
//NK int[20] c;
//NK int c[20];
// to jest poprawna składnia:
int d[] = new int[13];
int d1[], d2[], d3;
d1 = new int[1];
d3 = 15;
// Tablic, ani innych obiektów, się w Javie nie usuwa z pamięci - Java robi to automatycznie.
// long[] duza = new long[1000000000]; // OutOfMemory
// Można też tworzyć tablice od razu podając ich zawartość:
int piecdziesiat = 50;
// deklaracje nowych zmiennych:
// mogę użyć najkrószej składni: nawiasy klamrowe i wartości w środku,
int[] e = {10, 20, 30, 40, piecdziesiat};
int[] f = {10, 20, 30, 40, piecdziesiat, 60, };
// mogę też użyć składni new int[] {elementy}
int[] g = new int[] {10, 20, 30, 40, 50};
// Jeśli to już nie jest deklaracja nowej zmiennej, tylko przypisanie do starej zmiennej lub inne sytuacje
// to nie mogę już używać najkrótszej składni
// f = {44, 55, 66, 77, 88};
// tylko muszę pisać new
f = new int[] {44, 55, 66, 77};
int wynik = suma(e);
System.out.println(wynik);
// tej składni można też użyć, gdy tablica jest parametrem funkcji
wynik = suma(new int[] {1,3,5,7});
System.out.println(wynik);
// wynik = suma({1,3,5,7});
// System.out.println(wynik);
// Tablice utworzone za pomocą {} też można modyfikować.
// Zarowno zawartośc, jak i same zmienne
System.out.println(e); // [I@6d06d69c
System.out.println(Arrays.toString(e)); // zawartość
e[1] = 24;
e[2]++;
System.out.println(Arrays.toString(e));
e = new int[5]; // zmienna e wskazuje na inną tablicę
System.out.println(Arrays.toString(e));
}
static int suma(int[] a) {
int suma =0;
for (int x : a) {
suma += x;
}
return suma;
}
}
PC22-PrzetwarzanieDanych/src/alx/p23_tablice/Tablice3_Petle.java 0 → 100644
package alx.p23_tablice;
import java.util.Arrays;
public class Tablice3_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 koli 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
}
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.
}
}
PC22-PrzetwarzanieDanych/src/alx/p23_tablice/Tablice4_2D.java 0 → 100644
package alx.p23_tablice;
import java.util.Arrays;
public class Tablice4_2D {
public static void main(String[] args) {
// Tablice wielowymiarowe... To tak naprawdę tablice tablic.
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));
}
}
PC22-PrzetwarzanieDanych/src/alx/p24_napisy/BudowanieNapisow_PomiarCzasu.java 0 → 100644
package alx.p24_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();
}
}
PC22-PrzetwarzanieDanych/src/alx/p24_napisy/InnaKlasa.java 0 → 100644
package alx.p24_napisy;
public class InnaKlasa {
public static String dajStringaZKodu() {
return "Ala ma kota";
}
public static String dajStringaNowego() {
return new String("Ala ma kota");
}
}
PC22-PrzetwarzanieDanych/src/alx/p24_napisy/OperacjeNaStringach.java 0 → 100644
package alx.p24_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"));
}
}
PC22-PrzetwarzanieDanych/src/alx/p24_napisy/ParametryString.java 0 → 100644
package alx.p24_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ę
}
}
PC22-PrzetwarzanieDanych/src/alx/p24_napisy/Porownywanie.java 0 → 100644
package alx.p24_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));
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/a_list/DeklaracjeGeneryczne.java 0 → 100644
package alx.p25_kolekcje.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>();
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/a_list/ListaLiczb.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/a_list/Listy.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/a_list/ListyAll.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/a_list/NoweOperacjeList.java 0 → 100644
package alx.p25_kolekcje.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();
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/a_list/PorownanieSzybkosciList.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/b_set_map/ListyIZbiory.java 0 → 100644
package alx.p25_kolekcje.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"));
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/b_set_map/NoweOperacjeMap.java 0 → 100644
package alx.p25_kolekcje.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);
});
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/b_set_map/Slowniki.java 0 → 100644
package alx.p25_kolekcje.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());
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/b_set_map/Tree1.java 0 → 100644
package alx.p25_kolekcje.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();
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/b_set_map/Tree2.java 0 → 100644
package alx.p25_kolekcje.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()
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/b_set_map/ZbiorDziwnieSortowany.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/b_set_map/ZmianaKolejnosciWHaszSecie.java 0 → 100644
package alx.p25_kolekcje.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);
// }
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/c_queue/KolejkaJakoStos.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/c_queue/Kolejki.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/c_queue/Kolejki_Operacje.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/e_iterator/Iteratory.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/e_iterator/IteratoryListowe.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/e_iterator/Konkurencja1.java 0 → 100644
package alx.p25_kolekcje.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();
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/e_iterator/Konkurencja2.java 0 → 100644
package alx.p25_kolekcje.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
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/e_iterator/Konkurencja3.java 0 → 100644
package alx.p25_kolekcje.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");
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/e_iterator/Konkurencja4.java 0 → 100644
package alx.p25_kolekcje.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");
}
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/e_iterator/Konkurencja6.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/e_iterator/Konkurencja7a.java 0 → 100644
package alx.p25_kolekcje.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
}
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/e_iterator/Konkurencja7b.java 0 → 100644
package alx.p25_kolekcje.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
}
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/s_sortowanie/KomparatorDlugosciNapisow.java 0 → 100644
package alx.p25_kolekcje.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();
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/s_sortowanie/Sortowanie1.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/s_sortowanie/Sortowanie2.java 0 → 100644
package alx.p25_kolekcje.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);
}
}
PC22-PrzetwarzanieDanych/src/alx/p25_kolekcje/s_sortowanie/Sortowanie3.java 0 → 100644
package alx.p25_kolekcje.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));
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v1_brak_equals/HaszKody.java 0 → 100644
package alx.p26_porownywanie.v1_brak_equals;
public class HaszKody {
public static void main(String[] args) {
Osoba a = new Osoba("Ala", "Kowalska", 20);
Osoba r = a;
Osoba b = new Osoba("Ala", "Kowalska", 20);
Osoba c = new Osoba("Ola", "Kowalska", 30);
// Jeśli w klasie nie nadpiszemy metody hashCode, to działa domyślna implementacja
// wyliczająca hashcode na podstawie adresu.
// Daje to efekt, że haszkody różnych obiektów są różne.
// Dopóki nie tworzymy miliardów obiektów, to hashcody będą unikalne.
System.out.println("hasz a " + a.hashCode());
System.out.println("hasz r " + r.hashCode());
System.out.println("hasz b " + b.hashCode());
System.out.println("hasz c " + c.hashCode());
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v1_brak_equals/Osoba.java 0 → 100644
package alx.p26_porownywanie.v1_brak_equals;
public class Osoba {
String imie, nazwisko;
int wiek;
public Osoba(String imie, String nazwisko, int wiek) {
this.imie = imie;
this.nazwisko = nazwisko;
this.wiek = wiek;
}
@Override
public String toString() {
return "Osoba [imie=" + imie + ", nazwisko=" + nazwisko + ", wiek=" + wiek + "]";
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v1_brak_equals/Porownywanie.java 0 → 100644
package alx.p26_porownywanie.v1_brak_equals;
import java.util.Objects;
public class Porownywanie {
// Jeśli w klasie nie zdefiniujemy metody equals, to używana jest domyślna implementacja pochodząca z klasy Object,
// która porównuje adresy (działa jak ==).
public static void main(String[] args) {
Osoba a = new Osoba("Ala", "Kowalska", 20);
Osoba r = a;
Osoba b = new Osoba("Ala", "Kowalska", 20);
Osoba c = new Osoba("Ola", "Kowalska", 30);
// == sprawdza cz yto jest ten sam adres
System.out.println("a == a " + (a == a));
System.out.println("a == r " + (a == r));
System.out.println("a == b " + (a == b));
System.out.println("a == c " + (a == c));
System.out.println();
System.out.println("a.equals(a) " + (a.equals(a)));
System.out.println("a.equals(r) " + (a.equals(r)));
System.out.println("a.equals(b) " + (a.equals(b)));
System.out.println("a.equals(c) " + (a.equals(c)));
System.out.println();
System.out.println("Obj a a " + Objects.equals(a, a));
System.out.println("Obj a r " + Objects.equals(a, r));
System.out.println("Obj a b " + Objects.equals(a, b));
System.out.println("Obj a c " + Objects.equals(a, c));
System.out.println();
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v1_brak_equals/ZbiorDrzewowy.java 0 → 100644
package alx.p26_porownywanie.v1_brak_equals;
import java.util.Set;
import java.util.TreeSet;
public class ZbiorDrzewowy {
public static void main(String[] args) {
Osoba a = new Osoba("Ala", "Kowalska", 20);
Osoba r = a;
Osoba b = new Osoba("Ala", "Kowalska", 20);
Osoba c = new Osoba("Ola", "Kowalska", 30);
// TreeSet oraz TreeMap w działaniu korzystają z metody compareTo (ewentualnie z komparatora).
// Ten program kończy sie błedem, bo Osoba nie jest Comparable
boolean wynik;
Set<Osoba> zbior = new TreeSet<>();
wynik = zbior.add(a);
System.out.println("a " + wynik);
wynik = zbior.add(r);
System.out.println("r " + wynik);
wynik = zbior.add(b);
System.out.println("b " + wynik);
wynik = zbior.add(c);
System.out.println("c " + wynik);
System.out.println();
System.out.println("Ilośc elementów: " + zbior.size());
for (Osoba osoba : zbior) {
System.out.println(osoba);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v1_brak_equals/ZbiorHaszowy.java 0 → 100644
package alx.p26_porownywanie.v1_brak_equals;
import java.util.HashSet;
import java.util.Set;
public class ZbiorHaszowy {
public static void main(String[] args) {
Osoba a = new Osoba("Ala", "Kowalska", 20);
Osoba r = a;
Osoba b = new Osoba("Ala", "Kowalska", 20);
Osoba c = new Osoba("Ola", "Kowalska", 30);
// HashSet oraz HashMap w działaniu korzystają z metod hashCode i equals.
// 1) patrzy jaki jest hashcode i jeśli różny, to traktuje jak różne obiekty
// 2) jeśli hc jest równy, to wtedy porówuje za pomocą equals
boolean wynik; // wynik operacji add: jeśli element został dodany to true, a jeśli nie to false
Set<Osoba> zbior = new HashSet<>();
wynik = zbior.add(a);
System.out.println("a " + wynik);
wynik = zbior.add(r);
System.out.println("r " + wynik);
wynik = zbior.add(b);
System.out.println("b " + wynik);
wynik = zbior.add(c);
System.out.println("c " + wynik);
System.out.println();
System.out.println("Ilość elementów: " + zbior.size());
for (Osoba osoba : zbior) {
System.out.println(osoba);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v2_bledny_equals/HaszKody.java 0 → 100644
package alx.p26_porownywanie.v2_bledny_equals;
public class HaszKody {
public static void main(String[] args) {
Osoba a = new Osoba("Ala", "Kowalska", 20);
Osoba r = a;
Osoba b = new Osoba("Ala", "Kowalska", 20);
Osoba c = new Osoba("Ola", "Kowalska", 30);
// Jeśli w klasie nie nadpiszemy metody hashCode, to działa domyślna implementacja
// wyliczająca hashcode na podstawie adresu.
// Daje to efekt, że haszkody różnych obiektów są różne.
// Dopóki nie tworzymy miliardów obiektów, to hashcody będą unikalne.
System.out.println("hasz a " + a.hashCode());
System.out.println("hasz r " + r.hashCode());
System.out.println("hasz b " + b.hashCode());
System.out.println("hasz c " + c.hashCode());
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v2_bledny_equals/Osoba.java 0 → 100644
package alx.p26_porownywanie.v2_bledny_equals;
import java.util.Objects;
public class Osoba {
String imie, nazwisko;
int wiek;
public Osoba(String imie, String nazwisko, int wiek) {
this.imie = imie;
this.nazwisko = nazwisko;
this.wiek = wiek;
}
@Override
public String toString() {
return "Osoba [imie=" + imie + ", nazwisko=" + nazwisko + ", wiek=" + wiek + "]";
}
// To nie jest "overriding" tylko "overloading".
// Nie nadpisuję "prawdziwej" metody equals pochodzącej z Object, tylko towrzę nową dodatkową metodę odstepną tylko w klasie Osoba.
// Ten equals zadziała tylko jeśli bezpośrednio go wywołamy na obiekcie Osoba,
// ale to nie jest "ten prawdziwy" equals, i Java (np. HashSet) nie będzie brać tej definicji pod uwagę.
public boolean equals(Osoba inna) {
return inna != null
&& Objects.equals(this.imie, inna.imie)
&& Objects.equals(this.nazwisko, inna.nazwisko)
&& this.wiek == inna.wiek;
}
public int hashCode() {
// to jest niewydajne, ale poprawne i muszę to dopisać, aby "oszukać" hashset
return 0;
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v2_bledny_equals/Porownywanie.java 0 → 100644
package alx.p26_porownywanie.v2_bledny_equals;
import java.util.Objects;
public class Porownywanie {
// Jeśli w klasie nie zdefiniujemy metody equals, to używana jest domyślna implementacja pochodząca z klasy Object,
// która porównuje adresy (działa jak ==).
public static void main(String[] args) {
Osoba a = new Osoba("Ala", "Kowalska", 20);
Osoba r = a;
Osoba b = new Osoba("Ala", "Kowalska", 20);
Osoba c = new Osoba("Ola", "Kowalska", 30);
// == sprawdza cz yto jest ten sam adres
System.out.println("a == a " + (a == a));
System.out.println("a == r " + (a == r));
System.out.println("a == b " + (a == b));
System.out.println("a == c " + (a == c));
System.out.println();
System.out.println("a.equals(a) " + (a.equals(a)));
System.out.println("a.equals(r) " + (a.equals(r)));
System.out.println("a.equals(b) " + (a.equals(b)));
System.out.println("a.equals(c) " + (a.equals(c)));
System.out.println();
System.out.println("Obj a a " + Objects.equals(a, a));
System.out.println("Obj a r " + Objects.equals(a, r));
System.out.println("Obj a b " + Objects.equals(a, b));
System.out.println("Obj a c " + Objects.equals(a, c));
System.out.println();
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v2_bledny_equals/ZbiorDrzewowy.java 0 → 100644
package alx.p26_porownywanie.v2_bledny_equals;
import java.util.Set;
import java.util.TreeSet;
public class ZbiorDrzewowy {
public static void main(String[] args) {
Osoba a = new Osoba("Ala", "Kowalska", 20);
Osoba r = a;
Osoba b = new Osoba("Ala", "Kowalska", 20);
Osoba c = new Osoba("Ola", "Kowalska", 30);
// TreeSet oraz TreeMap w działaniu korzystają z metody compareTo (ewentualnie z komparatora).
// Ten program kończy sie błedem, bo Osoba nie jest Comparable
boolean wynik;
Set<Osoba> zbior = new TreeSet<>();
wynik = zbior.add(a);
System.out.println("a " + wynik);
wynik = zbior.add(r);
System.out.println("r " + wynik);
wynik = zbior.add(b);
System.out.println("b " + wynik);
wynik = zbior.add(c);
System.out.println("c " + wynik);
System.out.println();
System.out.println("Ilośc elementów: " + zbior.size());
for (Osoba osoba : zbior) {
System.out.println(osoba);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v2_bledny_equals/ZbiorHaszowy.java 0 → 100644
package alx.p26_porownywanie.v2_bledny_equals;
import java.util.HashSet;
import java.util.Set;
public class ZbiorHaszowy {
public static void main(String[] args) {
Osoba a = new Osoba("Ala", "Kowalska", 20);
Osoba r = a;
Osoba b = new Osoba("Ala", "Kowalska", 20);
Osoba c = new Osoba("Ola", "Kowalska", 30);
// HashSet oraz HashMap w działaniu korzystają z metod hashCode i equals.
boolean wynik; // wynik operacji add: jeśli element został dodany to true, a jeśli nie to false
Set<Osoba> zbior = new HashSet<>();
wynik = zbior.add(a);
System.out.println("a " + wynik);
wynik = zbior.add(r);
System.out.println("r " + wynik);
wynik = zbior.add(b);
System.out.println("b " + wynik);
wynik = zbior.add(c);
System.out.println("c " + wynik);
System.out.println();
System.out.println("Ilośc elementów: " + zbior.size());
for (Osoba osoba : zbior) {
System.out.println(osoba);
}
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v3_equals/HaszKody.java 0 → 100644
package alx.p26_porownywanie.v3_equals;
public class HaszKody {
public static void main(String[] args) {
Osoba a = new Osoba("Ala", "Kowalska", 20);
Osoba r = a;
Osoba b = new Osoba("Ala", "Kowalska", 20);
Osoba c = new Osoba("Ola", "Kowalska", 30);
// Jeśli w klasie nie nadpiszemy metody hashCode, to działa domyślna implementacja
// wyliczająca hashcode na podstawie adresu.
// Daje to efekt, że haszkody różnych obiektów są różne.
// Dopóki nie tworzymy miliardów obiektów, to hashcody będą unikalne.
System.out.println("hasz a " + a.hashCode());
System.out.println("hasz r " + r.hashCode());
System.out.println("hasz b " + b.hashCode());
System.out.println("hasz c " + c.hashCode());
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v3_equals/Osoba.java 0 → 100644
package alx.p26_porownywanie.v3_equals;
import java.util.Objects;
public class Osoba {
String imie, nazwisko;
int wiek;
public Osoba(String imie, String nazwisko, int wiek) {
this.imie = imie;
this.nazwisko = nazwisko;
this.wiek = wiek;
}
public String toString() {
return "Osoba [imie=" + imie + ", nazwisko=" + nazwisko + ", wiek=" + wiek + "]";
}
public boolean equals(Object obj) {
if(obj == null || ! (obj instanceof Osoba)) {
return false;
}
Osoba inna = (Osoba)obj;
return Objects.equals(this.imie, inna.imie)
&& Objects.equals(this.nazwisko, inna.nazwisko)
&& this.wiek == inna.wiek;
}
// Formalnym wymaganiem wobec hashCode jest:
// jeśli dwa obiekty są równe (equals), to hashcode'y muszą być równe
// Natomiast dla zwiększenia wydajności jeśli obiekty są różne,
// to z dużym pradopodobieństwem hashcody powinny być różne.
public int hashCode() {
return 0;
}
}
PC22-PrzetwarzanieDanych/src/alx/p26_porownywanie/v3_equals/Porownywanie.java 0 → 100644
package alx.p26_porownywanie.v3_equals;
import java.util.Objects;
public class Porownywanie {
// Jeśli w klasie nie zdefiniujemy metody equals, to używana jest domyślna implementacja pochodząca z klasy Object,
// która porównuje adresy (działa jak ==).
public static void main(String[] args) {
Osoba a = new Osoba("Ala", "Kowalska", 20);
Osoba r = a;
Osoba b = new Osoba("Ala", "Kowalska", 20);
Osoba c = new Osoba("Ola", "Kowalska", 30);
// == sprawdza cz yto jest ten sam adres
System.out.println("a == a " + (a == a));
System.out.println("a == r " + (a == r));
System.out.println("a == b " + (a == b));
System.out.println("a == c " + (a == c));
System.out.println();
System.out.println("a.equals(a) " + (a.equals(a)));
System.out.println("a.equals(r) " + (a.equals(r)));
System.out.println("a.equals(b) " + (a.equals(b)));
System.out.println("a.equals(c) " + (a.equals(c)));
System.out.println();
System.out.println("Obj a a " + Objects.equals(a, a));
System.out.println("Obj a r " + Objects.equals(a, r));
System.out.println("Obj a b " + Objects.equals(a, b));
System.out.println("Obj a c " + Objects.equals(a, c));
System.out.println();
}
}
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