Skip to content

2
20250520
Commit 7f33d441 by Patryk Czarnik
Options

refaktor

parent cc969fc5
Showing with 567 additions and 0 deletions
src/p12_enkapsulacja/Student.java 0 → 100644
package p12_enkapsulacja;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
public class Student extends Osoba {
private String kierunek;
private int rok;
// Ukrywamy szczegóły implementacji - klient nie musi wiedzieć, w jaki sposób przechowujemy oceny studenta ("to nasza prywatna sprawa")
// Żadna inna klasa nie może odwoływać się bezpośrednio do tej tablicy.
private List<Double> oceny = new ArrayList<>();
public Student(String imie, String nazwisko, LocalDate dataUrodzenia, String kierunek, int rok) {
super(imie, nazwisko, dataUrodzenia);
this.kierunek = kierunek;
this.rok = rok;
}
public String getKierunek() {
return kierunek;
}
public void setKierunek(String kierunek) {
this.kierunek = kierunek;
}
public int getRok() {
return rok;
}
public void setRok(int rok) {
this.rok = rok;
}
public void dodajOcene(double ocena) {
oceny.add(ocena);
}
public double sredniaOcen() {
return oceny.stream().mapToDouble(x->x).average().orElse(0.0);
}
public void przedstawSie() {
System.out.println("Hej tu " + getImie() + " " + getNazwisko() + ", jestem studentem " + rok + " roku kierunku " + kierunek);
}
}
src/p15_kolekcje/z_zbierz_dane/P1_Tablica.java 0 → 100644
package p15_kolekcje.z_zbierz_dane;
import java.util.Arrays;
import java.util.Scanner;
// Program pobiera od użytkownika wiele imion i zapisuje w pamięci, aby później wypisać...
// W tej wersji imiona zapamiętujemy w tablicy.
// Tworząc tablicę musimy podać jej rozmiar.
// Tablice nie są tak elastyczne, jak listy i inne kolekcje,
public class P1_Tablica {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Ile imion podasz? ");
int size = scanner.nextInt();
scanner.nextLine(); // ignorujemy resztę tej linii, a "kursor przechodzi do następnej"
String[] tablica = new String[size];
for(int i = 0; i < size; i++) {
System.out.print("Podaj imię nr " + i + ": ");
tablica[i] = scanner.nextLine();
}
System.out.println("Wszystkie imiona:");
System.out.println(Arrays.toString(tablica));
// Tablica i wszystkie typy kolekcji pozwalają na używanie pętli "for-each".
for(String imie : tablica) {
System.out.print("; witaj " + imie);
}
System.out.println();
// Najbardziej oczywistym (i wydajnym) sposobem dostepu do elementów tablicy
// jest dostęp po numerze pozycji za pomocą []
// Użytkownik podaje numer, a program odczytuje wartość z podanej pozycji.
// -1 kończy
while(true) {
System.out.print("Podaj nr pozycji: ");
int pozycja = scanner.nextInt();
scanner.nextLine();
if(pozycja == -1) {
break;
}
try {
String imie = tablica[pozycja];
System.out.println("Osoba nr " + pozycja + " to " + imie);
} catch (Exception e) {
System.out.println(e);
}
}
}
}
src/p15_kolekcje/z_zbierz_dane/P2_TablicaDynamiczna.java 0 → 100644
package p15_kolekcje.z_zbierz_dane;
import java.util.Arrays;
import java.util.Scanner;
public class P2_TablicaDynamiczna {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Na początku tworzymy tablicę, która ma 4 miejsca,
// ale zanim zaczniemy pobierać imiona, to liczba imion wynosi 0.
String[] tablica = new String[4];
int n = 0;
for(;;) {
System.out.print("Podaj imię nr " + n + ": ");
String imie = scanner.nextLine();
if(imie.isEmpty()) break;
if(n == tablica.length) {
// w tej wersji kopiowanie danych ze starej do nowej tablicy piszemy samodzielnie
System.out.println("powiększanie tablicy");
String[] nowaTablica = new String[2*n];
for(int i=0; i<n; i++) {
nowaTablica[i] = tablica[i];
}
tablica = nowaTablica;
}
tablica[n] = imie;
n++;
}
System.out.println("Wszystkie imiona:");
System.out.println(Arrays.toString(tablica));
for(String imie : tablica) {
System.out.print("; witaj " + imie);
}
System.out.println();
while(true) {
System.out.print("Podaj nr pozycji: ");
int pozycja = scanner.nextInt();
scanner.nextLine();
if(pozycja == -1) {
break;
}
try {
String imie = tablica[pozycja];
System.out.println("Osoba nr " + pozycja + " to " + imie);
} catch (Exception e) {
System.out.println(e);
}
}
}
}
src/p15_kolekcje/z_zbierz_dane/P2_TablicaDynamiczna_Copy.java 0 → 100644
package p15_kolekcje.z_zbierz_dane;
import java.util.Arrays;
import java.util.Scanner;
public class P2_TablicaDynamiczna_Copy {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Na początku tworzymy tablicę, która ma 4 miejsca,
// ale zanim zaczniemy pobierać imiona, to liczba imion wynosi 0.
String[] tablica = new String[4];
int n = 0;
while(true) {
System.out.print("Podaj imię nr " + n + ": ");
String imie = scanner.nextLine();
if(imie.isEmpty()) break;
if(n == tablica.length) {
// w tej wersji kopiowanie danych wykonujemy za pomocą metody copy
System.out.println("powiększanie tablicy");
tablica = Arrays.copyOf(tablica, 2*n);
}
tablica[n] = imie;
n++;
}
System.out.println("Wszystkie imiona:");
System.out.println(Arrays.toString(tablica));
for(String imie : tablica) {
System.out.print("; witaj " + imie);
}
System.out.println();
while(true) {
System.out.print("Podaj nr pozycji: ");
int pozycja = scanner.nextInt();
scanner.nextLine();
if(pozycja == -1) {
break;
}
try {
String imie = tablica[pozycja];
System.out.println("Osoba nr " + pozycja + " to " + imie);
} catch (Exception e) {
System.out.println(e);
}
}
}
}
src/p15_kolekcje/z_zbierz_dane/P3_Lista.java 0 → 100644
package p15_kolekcje.z_zbierz_dane;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
// Lista:
// - zachowuje kolejność elementów i jest sens mówić o indeksach (numerach pozycji)
// - może zawierać powtórzenia
// - nie wymaga deklarowania z góry liczby elementów; operacja add prawie zawsze potrafi dodać kolejny element na końcu
// - List jest interfejsem; istnieje wiele implementacji listy,
// z czego zdecydowanie najczęściej używaną jest ArrayList
public class P3_Lista {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
List<String> lista = new ArrayList<>();
// Jeśli ma zawierać od razu elementy, to od Javy 9 pisze się tak
// (gdy chcemy mieć listę zdolną do późniejszych modyfikacji)
// List<String> lista = new ArrayList<>(List.of("Ala", "Ela", "Ola"));
// List<String> lista = new ArrayList<>(List.of(tablica));
// a w starszych wersjach:
// List<String> lista = new ArrayList<>(Arrays.toList("Ala", "Ela", "Ola"));
// List<String> lista = new ArrayList<>(Arrays.toList(tablica));
// Takie coś: List<String> lista = List.of("Ala", "Ela", "Ola");
// utworzy listę "niemutowalną", tylko do odczytu.
while(true) {
System.out.print("Podaj kolejne imię: ");
String imie = scanner.nextLine();
if(imie.isEmpty()) break;
lista.add(imie);
// jbc, to tak można wywołać metodę a poziomu AL: ((ArrayList<String>)lista).ensureCapacity(50);
}
System.out.println("Liczba elementów: " + lista.size());
System.out.println("Wszystkie imiona:");
System.out.println(lista);
// Tablica i wszystkie typy kolekcji pozwalają na używanie pętli "for-each".
for(String imie : lista) {
System.out.print("; witaj " + imie);
}
System.out.println();
// Podobnie, jak w przypadku tablic, elementy list także mają ustalony numer pozycji
// od 0 do size-1. Za pomocą get można odczytać element o podanym numerze,
// a set(i, nowa_wartosc) zmienia wartość elementu na nową.
// - ArrayList daje szybki dostęp do elementów o określonym numerze
// - ale ogólnie nie wszystkie listy mają ten dostęp szybki; dla LinkedList operacje get/set działają wolno
while(true) {
System.out.print("Podaj nr pozycji: ");
int pozycja = scanner.nextInt();
scanner.nextLine();
if(pozycja == -1) {
break;
}
try {
String imie = lista.get(pozycja);
System.out.println("Osoba nr " + pozycja + " to " + imie);
} catch (Exception e) {
System.out.println(e);
}
}
}
}
src/p15_kolekcje/z_zbierz_dane/P4_HashSet.java 0 → 100644
package p15_kolekcje.z_zbierz_dane;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
// Zbiór (Set):
// - nie zawiera powtórzeń
// - nie wymaga deklarowania z góry liczby elementów;
// - operacja add w wyniku zwraca true, gdy element został dodany,
// false, gdy element nie został dodany, bo już był
// kończy się wyjątkiem w razie innych problemów
// - Set jest interfejsem; istnieje wiele implementacji zbioru,
// z czego najczęściej używaną jest HashSet
// - HashSet działa w oparciu o metody hashCode i equals
// - zazwyczaj jest najszybszą implementacją (szczególnie dla elementów typu String tak jest)
// - zmienia kolejność elementów
// - LinkedHashSet działa odrobinkę wolniej podczas dodawania, a równie szybko przy odczycie,
// ale za to zachowuje kolejność elementów
public class P4_HashSet {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Set<String> zbior = new HashSet<>();
while(true) {
System.out.print("Podaj kolejne imię: ");
String imie = scanner.nextLine();
if(imie.isEmpty()) break;
zbior.add(imie);
}
System.out.println("Liczba elementów: " + zbior.size());
System.out.println("Wszystkie imiona:");
System.out.println(zbior);
// Tablica i wszystkie typy kolekcji pozwalają na używanie pętli "for-each".
for(String imie : zbior) {
System.out.print("; witaj " + imie);
}
System.out.println();
// Drugi etap: użytkownik podaje imię, a program sprawdza, czy takie imię istnieje
// to jest najbardziej podstawowa operacja dla zbiorów.
// Niezależnie od implementacji ta operacja działa szybko (chociaż dla dużych zbiorów wersje Hash są trochę szybsze niż Tree)
while(true) {
System.out.print("Podaj imię: ");
// pusty string kończy
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
if(zbior.contains(imie)) {
System.out.println("TAK");
} else {
System.out.println("NIE");
}
}
}
}
src/p15_kolekcje/z_zbierz_dane/P5_TreeSet.java 0 → 100644
package p15_kolekcje.z_zbierz_dane;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
// - TreeSet przechowuje elementy w kolejności posortowanej
public class P5_TreeSet {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Set<String> zbior = new TreeSet<>();
// Jeśli ma zawierać od razu elementy, to od Javy 9 pisze się tak:
// Set<String> zbior = new TreeSet<>(Set.of("Ala", "Ela", "Ola"));
while(true) {
System.out.print("Podaj kolejne imię: ");
String imie = scanner.nextLine();
if(imie.isEmpty()) break;
zbior.add(imie);
}
System.out.println("Liczba elementów: " + zbior.size());
System.out.println("Wszystkie imiona:");
System.out.println(zbior);
// Tablica i wszystkie typy kolekcji pozwalają na używanie pętli "for-each".
for(String imie : zbior) {
System.out.print("; witaj " + imie);
}
System.out.println();
// Drugi etap: użytkownik podaje imię, a program sprawdza, czy takie imię istnieje.
// To jest najbardziej podstawowa operacja dla zbiorów.
// Niezależnie od implementacji ta operacja działa szybko (chociaż dla dużych zbiorów wersje Hash są trochę szybsze niż Tree)
while(true) {
System.out.print("Podaj imię: ");
// pusty string kończy
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
if(zbior.contains(imie)) {
System.out.println("TAK");
} else {
System.out.println("NIE");
}
// to nie Java: if(imie in zbior)
}
}
}
src/p15_kolekcje/z_zbierz_dane/P6_Slownik.java 0 → 100644
package p15_kolekcje.z_zbierz_dane;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class P6_Slownik {
// Słownik służy do przechowywania par klucz→wartość
// Przy czym klucze muszą być unikalne. Dostęp po kluczu jest wygodny i wydajny.
// Typ klucza powinien być łatwy do porównania.
// Dobre typy dla klucza: Integer, Long, String, LocalDate
// Podobnie, jak w przypadku zbiorów (Set), dla słowników (Map) mamy takie implementacje,
// które różnią się kolejnością danych:
// - HashMap - kolejność techniczna / chaotyczna
// - LinkedHashMap - kolejność, w jakiej elementy były dodawane po raz pierwszy
// - TreeMap - dane posortowane wg kluczy
// W zaawansowanych zastosowaniach ważną implementacją słowników jest ConcurrentHashMap,
// która poprawnie i wydajnie działa w aplikacjach wielowątkowych (rózne wątki mogą korzytać jednocześnie).
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Dla osoby o podanym imieniu pamiętamy, ile ma lat.
Map<String, Integer> slownik = new HashMap<>();
while(true) {
System.out.print("Podaj kolejne imię: ");
String imie = scanner.nextLine();
if(imie.isEmpty()) break;
System.out.print("Podaj wiek osoby " + imie + ": ");
int wiek = scanner.nextInt();
scanner.nextLine();
slownik.put(imie, wiek);
}
System.out.println("Liczba elementów: " + slownik.size());
System.out.println("Wszystkie imiona:");
System.out.println(slownik);
System.out.println();
// Iteracja po elementach słownika.
// Same klucze:
for(String imie : slownik.keySet()) {
System.out.print("; " + imie);
}
System.out.println();
// Same wartości:
for(Integer wiek : slownik.values()) {
System.out.print(". " + wiek);
}
System.out.println();
System.out.println();
// Klucze wraz z wartościami:
for(Map.Entry<String, Integer> osoba : slownik.entrySet()) {
System.out.println("Osoba " + osoba.getKey() + " ma " + osoba.getValue() + " lat.");
}
System.out.println();
// Od Java 8 można też pisać tak:
slownik.forEach((imie, wiek) -> {
System.out.println(" * " + imie + " → " + wiek);
});
System.out.println();
while(true) {
System.out.print("Podaj imię: ");
// pusty string kończy
String imie = scanner.nextLine();
if(imie.isEmpty()) {
break;
}
if(slownik.containsKey(imie)) {
int wiek = slownik.get(imie);
System.out.println("Osoba " + imie + " ma " + wiek + " lat.");
} else {
System.out.println("Nie znam osoby " + imie);
}
// Podstawową operacją do odczytywania danych ze słownika jest get(klucz).
// Jeśli spróbujemy odczytać element spod nieistniejącego klucza, to wynikiem będzie null.
// Pamiętajmy, by przy takim podejściu zapisywać wynik do zmiennej obiektowej.
// Czyli nie tak: int wiek = slownik.get(imie);
// A raczej tak: Integer wiek = slownik.get(imie);
// if(wiek != null) { ... }
}
}
}
src/p15_kolekcje/z_zbierz_dane/P7_Queue.java 0 → 100644
package p15_kolekcje.z_zbierz_dane;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class P7_Queue {
// Kolejka to struktura danych zoptymalizowana pod kątem dostępu do "następnego elementu"
// (operacja poll() lub get()).
// * Kolejka prosta (FIFO) zachowuje kolejność elementów i następnym elementem do pobrania jest ten,
// który został najdawniej w kolejce umieszczony.
// Jak "sprawiedliwa" kolejna do kasy w sklepie.
// Najczęściej jest to jednocześnie kolejka dwukońcowa (Dequeue) z możliwością dostepu do obu jej końców.
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Queue<String> kolejka = new LinkedList<>(); // albo ArrayDequeue; - to są "kolejki proste"
System.out.println(kolejka);
System.out.println("Podawaj kolejne elementy, aby dodać do kolejki.\nWpisz '?', aby pobrać element z kolejki, a Enter aby zakończyć program");
while(true) {
System.out.println("Kolejka: " + kolejka);
System.out.print("> ");
String napis = scanner.nextLine();
if(napis.isEmpty()) break;
if(napis.equals("?")) {
String pobrane = kolejka.poll();
System.out.println("Pobrany element: " + pobrane);
} else {
System.out.println("Dodany element: " + napis);
kolejka.add(napis);
}
}
System.out.println("Końcowy rozmiar kolejki " + kolejka.size());
System.out.println(kolejka);
System.out.println("Koniec programu");
}
}
src/p15_kolekcje/z_zbierz_dane/P8_PriorityQueue.java 0 → 100644
package p15_kolekcje.z_zbierz_dane;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
public class P8_PriorityQueue {
// * Kolejka priorytetowa może nie zachowywać kolejności (możliwe jest tzw. "zagłodzenie").
// Następnym elementem do pobranie jest element o najwyższym priorytecie
// - w Javie jest to element o najmniejszej wartości (np. napis najwcześniejszy alfabetycznie).
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Queue<String> kolejka = new PriorityQueue<>();
System.out.println(kolejka);
System.out.println("Podawaj kolejne elementy, aby dodać do kolejki.\nWpisz '?', aby pobrać element z kolejki, a Enter aby zakończyć program");
while(true) {
System.out.println("Kolejka: " + kolejka);
System.out.print("> ");
String napis = scanner.nextLine();
if(napis.isEmpty()) break;
if(napis.equals("?")) {
String pobrane = kolejka.poll();
System.out.println("Pobrany element: " + pobrane);
} else {
System.out.println("Dodany element: " + napis);
kolejka.add(napis);
}
}
System.out.println("Końcowy rozmiar kolejki " + kolejka.size());
System.out.println(kolejka);
System.out.println("Koniec programu");
}
}
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