Skip to content

J
javab_20230617
Commit f82196b5 by Patryk Czarnik
Options

Dużo gotowych przyładów "zwykłej Javy"

parent 428cc39e
Showing with 3515 additions and 0 deletions
PC21-JavaUzupelnienia/src/emps/Employee.java 0 → 100644
package emps;
import java.time.LocalDate;
import java.util.Objects;
public class Employee {
private int id;
private String firstName;
private String lastName;
private String jobTitle;
private int salary;
private LocalDate hireDate;
private String departmentName;
private String address;
private String postalCode;
private String city;
private String country;
public Employee(int id, String firstName, String lastName, String jobTitle, int salary, LocalDate hireDate, String departmentName, String address, String postalCode, String city, String country) {
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
this.jobTitle = jobTitle;
this.salary = salary;
this.hireDate = hireDate;
this.departmentName = departmentName;
this.address = address;
this.postalCode = postalCode;
this.city = city;
this.country = country;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getJobTitle() {
return jobTitle;
}
public void setJobTitle(String jobTitle) {
this.jobTitle = jobTitle;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public LocalDate getHireDate() {
return hireDate;
}
public void setHireDate(LocalDate hireDate) {
this.hireDate = hireDate;
}
public String getDepartmentName() {
return departmentName;
}
public void setDepartmentName(String departmentName) {
this.departmentName = departmentName;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPostalCode() {
return postalCode;
}
public void setPostalCode(String postalCode) {
this.postalCode = postalCode;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return id == employee.id && salary == employee.salary && Objects.equals(firstName, employee.firstName) && Objects.equals(lastName, employee.lastName) && Objects.equals(jobTitle, employee.jobTitle) && Objects.equals(hireDate, employee.hireDate) && Objects.equals(departmentName, employee.departmentName) && Objects.equals(address, employee.address) && Objects.equals(postalCode, employee.postalCode) && Objects.equals(city, employee.city) && Objects.equals(country, employee.country);
}
@Override
public int hashCode() {
return Objects.hash(id, firstName, lastName, jobTitle, salary, hireDate, departmentName, address, postalCode, city, country);
}
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
", jobTitle='" + jobTitle + '\'' +
", salary=" + salary +
", hireDate=" + hireDate +
", departmentName='" + departmentName + '\'' +
", address='" + address + '\'' +
", postalCode='" + postalCode + '\'' +
", city='" + city + '\'' +
", country='" + country + '\'' +
'}';
}
}
PC21-JavaUzupelnienia/src/emps/F0_WypiszObiekty.java 0 → 100644
package emps;
import java.util.List;
public class F0_WypiszObiekty {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
// Zamiast pisać pętlę for(Employee emp : emps)
// można użyć metody forEach:
// emps.forEach(emp -> System.out.println(emp.getFirstName() + " " + emp.getLastName()));
// Do forEach przekazuje się operację, którą chcemy wykonać dla każdego elemetu listy.
// Można podać wyrażenie lambda ↑
// Można też refrencję do metody ↓
emps.forEach(System.out::println);
// forEach może być uruchamiany bezpośrednio na listach, ale można też wprowadzić pośredni krok
// pobrania strumienia. To by miało większy sens, gdybyśmy chcieli wykonać operacje pośrednie (od programu nr 2)
// emps.stream().forEach(System.out::println);
}
}
PC21-JavaUzupelnienia/src/emps/F1_WypiszWybranePola.java 0 → 100644
package emps;
import java.util.List;
public class F1_WypiszWybranePola {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
// podejście 1: forEach bezpośrednio na liście
// emps.forEach(emp -> System.out.printf("%s %s (%s) zarabia %d%n",
// emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary()));
// podejście 2: najpierw mapujemy obiekty Employee na obiekty String, a następnie wypisujemy w prosty sposób
emps.stream()
.map(emp -> String.format("%s %s (%s) zarabia %d",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary()))
.forEach(System.out::println);
}
}
PC21-JavaUzupelnienia/src/emps/F2_WypiszBogatych.java 0 → 100644
package emps;
import java.util.List;
public class F2_WypiszBogatych {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.stream()
.filter(emp -> emp.getSalary() >= 10_000)
.forEach(emp -> System.out.printf("%s %s (%s) zarabia %d%n",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary()));
// Można też najpierw zmapować na Stringi, a potem wypisać
// emps.stream()
// .filter(emp -> emp.getSalary() >= 10_000)
// .map(emp -> String.format("%s %s (%s) zarabia %d",
// emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary()))
// .forEach(System.out::println);
}
}
PC21-JavaUzupelnienia/src/emps/F3_SredniaWszystkich.java 0 → 100644
package emps;
import java.util.List;
import java.util.stream.Collectors;
public class F3_SredniaWszystkich {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
double avg = emps.stream()
.mapToInt(Employee::getSalary)
.average()
.orElse(0);
System.out.println(avg);
// zamiast Employee::getSalary można też napisać emp -> emp.getSalary()
// Można też użyć dedykowanego Collectora
Double avg2 = emps.stream().collect(Collectors.averagingInt(Employee::getSalary));
System.out.println(avg2);
}
}
PC21-JavaUzupelnienia/src/emps/F4a_SredniaProgramistow.java 0 → 100644
package emps;
import java.util.List;
import java.util.stream.Collectors;
public class F4a_SredniaProgramistow {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
double avg = emps.stream()
.filter(emp -> "Programmer".equals(emp.getJobTitle()))
.mapToInt(Employee::getSalary)
.average()
.orElse(0);
System.out.println(avg);
}
}
PC21-JavaUzupelnienia/src/emps/F4b_SredniaJob.java 0 → 100644
package emps;
import javax.swing.*;
import java.util.List;
import java.util.OptionalDouble;
public class F4b_SredniaJob {
public static void main(String[] args) {
String szukanyJob = JOptionPane.showInputDialog("Podaj nazwę stanowiska", "Programmer");
if(szukanyJob == null) {
return;
}
List<Employee> emps = ObslugaCSV.wczytaj();
OptionalDouble avg = emps.stream()
.filter(emp -> szukanyJob.equalsIgnoreCase(emp.getJobTitle()))
.mapToInt(Employee::getSalary)
.average();
if(avg.isPresent()) {
JOptionPane.showMessageDialog(null,
"Średnia pracowników typu " + szukanyJob + " wynosi " + avg.getAsDouble());
} else {
JOptionPane.showMessageDialog(null,
"Nie ma pracowników typu " + szukanyJob, "Brak danych", JOptionPane.WARNING_MESSAGE);
}
}
}
PC21-JavaUzupelnienia/src/emps/F5_MinMax_Liczby.java 0 → 100644
package emps;
import java.util.List;
import java.util.stream.Collectors;
public class F5_MinMax_Liczby {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
int min = emps.stream()
.mapToInt(Employee::getSalary)
.min()
.orElse(0);
int max = emps.stream()
.mapToInt(Employee::getSalary)
.max()
.orElse(0);
System.out.println("Minimalna pensja: " + min);
System.out.println("Maksymalna pensja: " + max);
}
}
PC21-JavaUzupelnienia/src/emps/F5_MinMax_Obiekty.java 0 → 100644
package emps;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
public class F5_MinMax_Obiekty {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Optional<Employee> min = emps.stream().min(Comparator.comparingInt(Employee::getSalary));
if(min.isPresent()) {
Employee emp = min.get();
System.out.println("Najmniej czyli " + emp.getSalary() + " zarabia " + emp.getFirstName() + " " + emp.getLastName());
}
Optional<Employee> max = emps.stream().max(Comparator.comparingInt(Employee::getSalary));
if(max.isPresent()) {
Employee emp = max.get();
System.out.println("Najwięcej czyli " + emp.getSalary() + " zarabia " + emp.getFirstName() + " " + emp.getLastName());
}
// Inne podejścia do korzystania z Optionali będą w przykładach "sprzedaz"
}
}
PC21-JavaUzupelnienia/src/emps/F6_Sortowanie.java 0 → 100644
package emps;
import java.util.Comparator;
import java.util.List;
public class F6_Sortowanie {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.stream()
.sorted(Comparator.comparingInt(Employee::getSalary).reversed())
.map(emp -> String.format("%s %s (%s) zarabia %d",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary()))
.forEach(System.out::println);
}
}
PC21-JavaUzupelnienia/src/emps/F7_UnikalneMiasta.java 0 → 100644
package emps;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class F7_UnikalneMiasta {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
// podejście 1 - tworzymy Set
Set<String> miasta = emps.stream()
.map(Employee::getCity)
.collect(Collectors.toSet());
System.out.println("Mam zbiór o rozmiarze " + miasta.size());
miasta.forEach(m -> System.out.println("- " + m));
System.out.println();
// podejście 2 - usuwanie duplikatów i wypisywanie "w locie"
emps.stream()
.map(Employee::getCity)
.distinct()
.forEach(m -> System.out.println("* " + m));
}
}
PC21-JavaUzupelnienia/src/emps/F9_Partycje.java 0 → 100644
package emps;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class F9_Partycje {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
// Podział rekordów na dwie części i zapisanie w słowniku,
// w którym kluczem są wartości true/false
Map<Boolean, List<Employee>> grupy = emps.stream()
.collect(Collectors.partitioningBy(emp -> emp.getSalary() >= 10_000));
System.out.println("Bogaci:");
grupy.get(true).forEach(emp -> {
System.out.printf(" * %s %s (%s), pensja: %s\n", emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
});
System.out.println("\nBiedni:");
grupy.get(false).forEach(emp -> {
System.out.printf(" * %s %s (%s), pensja: %s\n", emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
});
}
}
PC21-JavaUzupelnienia/src/emps/FGrupowanie1.java 0 → 100644
package emps;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class FGrupowanie1 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Map<String, List<Employee>> grupy = emps.stream().collect(Collectors.groupingBy(Employee::getJobTitle));
// groupingBy wywołany w najprostszy sposób daje w wyniku słownik, w którym
// dla określonej wartości klucza (np. "Programmer") zapisana jest lista wszystkich rekordów, które należą do tej grupy
// Zawartość słownika przejrzymy w sposób oparty o wyrażenia lambda, operacją forEach
grupy.forEach((job, lista) -> {
System.out.println("Pracownicy typu " + job + ":");
lista.forEach(emp -> {
System.out.println(" * " + emp.getFirstName() + " " + emp.getLastName());
});
System.out.println();
});
}
}
PC21-JavaUzupelnienia/src/emps/FGrupowanie2.java 0 → 100644
package emps;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class FGrupowanie2 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
// Jeśli do groupingBy jako drugi parametr przekażemy kolektor, to mówi on "co zrobić z każdą grupą".
// Przykładowo liczymy średnią pensję pracowników w grupie.
Map<String, Double> grupy = emps.stream()
.collect(Collectors.groupingBy(Employee::getJobTitle,
Collectors.averagingInt(Employee::getSalary)));
grupy.forEach((job, srednia) -> {
System.out.printf("%-32s → %8.2f\n", job, srednia);
});
}
}
PC21-JavaUzupelnienia/src/emps/FGrupowanie3.java 0 → 100644
package emps;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;
public class FGrupowanie3 {
// W tej wersji dla każdej grupy wyliczamy "statystyki".
// Niezależnie od tego do kolektora groupingBy przekazuję też parametr TreeMap::new
// co powoduje użycie TreeMap zamiast HashMap
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Map<String, IntSummaryStatistics> grupy = emps.stream()
.collect(Collectors.groupingBy(Employee::getJobTitle,
TreeMap::new, // () -> new TreeMap()
Collectors.summarizingInt(Employee::getSalary)));
// grupy.forEach((job, statystyki) -> System.out.printf("%-32s → %s\n", job, statystyki));
grupy.forEach((job, stats) -> System.out.printf("| %-32s | %2d | %5d | %8.2f | %5d |%n",
job, stats.getCount(), stats.getMin(), stats.getAverage(), stats.getMax()));
}
}
PC21-JavaUzupelnienia/src/emps/Filtrowanie.java 0 → 100644
package emps;
import java.util.List;
public class Filtrowanie {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.stream()
.filter(emp -> emp.getSalary() >= 10000)
.filter(emp -> emp.getCity().startsWith("S"))
.forEach(emp -> System.out.println(emp.getFirstName()
+ " " + emp.getLastName() + " z miasta " + emp.getCity()
+ " zarabia " + emp.getSalary()));
}
}
PC21-JavaUzupelnienia/src/emps/FiltrowanieMapowanie.java 0 → 100644
package emps;
import java.util.List;
public class FiltrowanieMapowanie {
// Ten zapis to jest tzw. "pipeline", na który składają się:
// - źródło (w tym przypadku emps.stream() - źródłem danych jest lista)
// - operacje pośrednie (intermediate operations) - tutaj najbardziej typowe, czyli filter i map
// - operacja końcowa (terminal operation) - tutaj jest to forEach
// Ważny szczegół: w pewnym miejscu zmienia się typ danych. Najpierw jest to strumień Employees,
// a za pierwszym map pojawia się strumień Stringów
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.parallelStream()
.filter(emp -> emp.getSalary() < 10000)
.map(emp -> emp.getFirstName() + " " + emp.getLastName() +
" z miasta " + emp.getCity() + " zarabia " + emp.getSalary())
.filter(s -> s.contains("K")) // .map(s -> s.toUpperCase())
.map(String::toUpperCase)
//.forEach(System.out::println);
.findAny().ifPresent(System.out::println);
}
}
PC21-JavaUzupelnienia/src/emps/FiltrowanieMapowanie_JakoPetla.java 0 → 100644
package emps;
import java.util.List;
public class FiltrowanieMapowanie_JakoPetla {
// Ta sama logika, co w programie FiltrowanieMapowanie , ale zapisana za pomocą zwykłych pętli i ifów
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
for(Employee emp : emps) {
if(emp.getSalary() >= 10000) {
String s = emp.getFirstName() + " " + emp.getLastName() +
" z miasta " + emp.getCity() + " zarabia " + emp.getSalary();
if(s.contains("K")) {
String s2 = s.toUpperCase();
System.out.println(s2);
}
}
}
}
}
PC21-JavaUzupelnienia/src/emps/Grupowanie1.java 0 → 100644
package emps;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Grupowanie1 {
// W tej wersji najpierw ustalamy, jakie są joby, a następnie dla każdego joba od nowa przeglądamy dane
// To nie jest optymalne pod kątem wydajności.
// Mając 19 jobów i 107 pracowników, tę linię, w której jest if wykonamy aż 19×107 razy.
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
// etap 1: zbieramy nazwy jobów bez powtórzeń
Set<String> jobs = new HashSet<>();
for(Employee emp : emps) {
jobs.add(emp.getJobTitle());
}
// etap 2: dla każdego joba przeglądamy listę empsów i wybieramy tych pracowników, którzy mają taki job
for(String job : jobs) {
double suma = 0;
int ile = 0;
for(Employee emp : emps) {
if(emp.getJobTitle().equals(job)) {
suma += emp.getSalary();
ile++;
}
}
double srednia = suma / ile;
System.out.printf("%-32s | %2d | %8.2f\n", job, ile, srednia);
}
}
}
PC21-JavaUzupelnienia/src/emps/Grupowanie2.java 0 → 100644
package emps;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Grupowanie2 {
// Tutaj mamy pokazany standardowy schemat "grupowania za pomocą słowników".
// Używamy poleceń dostepnych w tej formie od Javy 5.
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Map<String, Integer> sumy = new HashMap<>();
Map<String, Integer> ilosci = new HashMap<>();
for(Employee emp : emps) {
if(sumy.containsKey(emp.getJobTitle())) {
// to jest kolejny pracownik z tego stanowiska → zwiększamy wartość w słowniku
int suma = sumy.get(emp.getJobTitle());
sumy.put(emp.getJobTitle(), suma + emp.getSalary());
int ile = ilosci.get(emp.getJobTitle());
ilosci.put(emp.getJobTitle(), ile + 1);
} else {
// to jest pierwszy pracownik z tego stanowiska → wpisujemy jego pensję jako wartość początkową
sumy.put(emp.getJobTitle(), emp.getSalary());
ilosci.put(emp.getJobTitle(), 1);
}
}
// System.out.println(sumy);
for(String job : sumy.keySet()) {
int ile = ilosci.get(job);
int suma = sumy.get(job);
double srednia = (double)suma / ile;
System.out.printf("%-32s | %2d | %8.2f\n", job, ile, srednia);
}
}
}
PC21-JavaUzupelnienia/src/emps/Grupowanie2a.java 0 → 100644
package emps;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Grupowanie2a {
public static void main(String[] args) {
final List<Employee> emps = ObslugaCSV.wczytaj();
final Map<String, Integer> sumy = new HashMap<>();
final Map<String, Integer> ilosci = new HashMap<>();
for(Employee emp : emps) {
final String jobTitle = emp.getJobTitle();
if(sumy.containsKey(jobTitle)) {
// to jest kolejny pracownik z tego stanowiska → zwiększamy wartość w słowniku
int suma = sumy.get(jobTitle);
sumy.put(jobTitle, suma + emp.getSalary());
int ile = ilosci.get(jobTitle);
ilosci.put(jobTitle, ile + 1);
} else {
// to jest pierwszy pracownik z tego stanowiska → wpisujemy jego pensję jako wartość początkową
sumy.put(jobTitle, emp.getSalary());
ilosci.put(jobTitle, 1);
}
}
for(String job : sumy.keySet()) {
int ile = ilosci.get(job);
int suma = sumy.get(job);
double srednia = (double)suma / ile;
System.out.printf("%-32s | %2d | %8.2f\n", job, ile, srednia);
}
}
}
PC21-JavaUzupelnienia/src/emps/Grupowanie3.java 0 → 100644
package emps;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
public class Grupowanie3 {
// W wersjach 3-5 używamy nowych operacji słowników, które pojawiły się w Javie 8.
// getOrDefault - w razie braku danych zwraca podaną wartość domyślną
// Pzy okazji używamy LinkedHashMap - zachowuje oryginalną kolejność
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Map<String, Integer> sumy = new LinkedHashMap<>();
Map<String, Integer> ilosci = new LinkedHashMap<>();
for(Employee emp : emps) {
int suma = sumy.getOrDefault(emp.getJobTitle(), 0);
sumy.put(emp.getJobTitle(), suma + emp.getSalary());
int ile = ilosci.getOrDefault(emp.getJobTitle(), 0);
ilosci.put(emp.getJobTitle(), ile + 1);
}
for(String job : sumy.keySet()) {
int ile = ilosci.get(job);
int suma = sumy.get(job);
double srednia = (double)suma / ile;
System.out.printf("%-32s | %2d | %8.2f\n", job, ile, srednia);
}
}
}
PC21-JavaUzupelnienia/src/emps/Grupowanie4.java 0 → 100644
package emps;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class Grupowanie4 {
// W wersjach 3-5 używamy nowych operacji słowników, które pojawiły się w Javie 8.
// putIfAbsent / computeIfPresent / compute - operacje, które działają w sposób warunkowy,
// a przekazuje do nich wartość lub funkcję służącą do zmiany wartości
// Ta wersja jest imo gorsza od 3 i 5...
// Pzy okazji używamy TreeMap - sortuje dane wg kluczy
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Map<String, Integer> sumy = new TreeMap<>();
Map<String, Integer> ilosci = new TreeMap<>();
for(Employee emp : emps) {
sumy.putIfAbsent(emp.getJobTitle(), 0);
sumy.computeIfPresent(emp.getJobTitle(), (key, staraSuma) -> staraSuma + emp.getSalary());
ilosci.putIfAbsent(emp.getJobTitle(), 0);
ilosci.computeIfPresent(emp.getJobTitle(), (k, v) -> v+1);
}
for(String job : sumy.keySet()) {
int ile = ilosci.get(job);
int suma = sumy.get(job);
double srednia = (double)suma / ile;
System.out.printf("%-32s | %2d | %8.2f\n", job, ile, srednia);
}
}
}
PC21-JavaUzupelnienia/src/emps/Grupowanie5.java 0 → 100644
package emps;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class Grupowanie5 {
// W wersjach 3-5 używamy nowych operacji słowników, które pojawiły się w Javie 8.
// Tutaj operacja merge
// slownik.merge(KLUCZ, WARTOŚĆ, FUNKCJA)
// Jeśli pod KLUCZem jeszcze niczego nie ma, to wpisywana jest WARTOŚĆ
// Jeśli pod KLUCZem jest już STARA_WARTOŚĆ, to uruchamiana jest FUNKCJA
// NOWA_WARTOŚĆ := FUNKCJA(STARA_WARTOŚĆ, WARTOŚĆ)
// np. jeśli funkcją jest operacja dodawania, to będzie tak:
// NOWA_WARTOŚĆ := STARA_WARTOŚĆ + WARTOŚĆ
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Map<String, Integer> sumy = new TreeMap<>();
Map<String, Integer> ilosci = new TreeMap<>();
for(Employee emp : emps) {
sumy.merge(emp.getJobTitle(), emp.getSalary(), Integer::sum);
ilosci.merge(emp.getJobTitle(), 1, Integer::sum);
// Funkcję aktualizującą można podać w formie wyrażenia lambda:
// sumy.merge(emp.getJobTitle(), emp.getSalary(), (stare, nowe) -> stare+nowe);
// ale dla dodawania mamy gotową operację Integer.sum(nowe, stare)
// i zamiast lambdy używamy referencji do metody (::)
}
for(String job : sumy.keySet()) {
int ile = ilosci.get(job);
int suma = sumy.get(job);
double srednia = (double)suma / ile;
System.out.printf("%-32s | %2d | %8.2f\n", job, ile, srednia);
}
}
}
PC21-JavaUzupelnienia/src/emps/Grupowanie6.java 0 → 100644
package emps;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
public class Grupowanie6 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Map<String, int[]> slownik = new TreeMap<>();
for(Employee emp : emps) {
if(slownik.containsKey(emp.getJobTitle())) {
// to jest kolejny pracownik z tego stanowiska → zwiększamy wartość w słowniku
int[] t = slownik.get(emp.getJobTitle());
t[0]++;
t[1] += emp.getSalary();
// dostaliśmy referencję do tablicy i gdy ją modyfikujemy, to słownik też to "widzi"
} else {
// to jest pierwszy pracownik z tego stanowiska → wpisujemy jego pensję jako wartość początkową
slownik.put(emp.getJobTitle(), new int[] {1, emp.getSalary()});
}
}
// przeglądamy "wpisy" w słowniku, czyli klucze wraz z wartościami
for (Entry<String, int[]> entry : slownik.entrySet()) {
String job = entry.getKey();
int[] t = entry.getValue();
double srednia = (double)t[1] / t[0];
System.out.printf("%-32s | %2d | %8.2f\n", job, t[0], srednia);
}
}
}
PC21-JavaUzupelnienia/src/emps/Grupowanie7.java 0 → 100644
package emps;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
// Podejście obiektowe do grupowania.
public class Grupowanie7 {
public static void main(String[] args) {
final List<Employee> emps = ObslugaCSV.wczytaj();
final Map<String, JobInfo> mapa = new TreeMap<>();
for (Employee emp : emps) {
final String jobTitle = emp.getJobTitle();
JobInfo jobInfo = mapa.get(jobTitle);
if (jobInfo == null) {
jobInfo = new JobInfo(jobTitle);
mapa.put(jobTitle, jobInfo);
}
jobInfo.update(emp);
}
for (JobInfo jobInfo : mapa.values()) {
System.out.println(jobInfo);
}
}
// Klasa zgnieżdżona - tylko dla przykładu.
// Równie dobrze mógłbym tę klase zdefiniować w osobnym pliku.
// Obiekt tej klasy przechowuje statystyki job
private static class JobInfo {
final String jobTitle;
int count = 0;
int sum = 0;
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
JobInfo(String jobTitle) {
this.jobTitle = jobTitle;
}
void update(Employee emp) {
int salary = emp.getSalary();
count++;
sum += salary;
if(salary < min) {
min = salary;
}
if(salary > max) {
max = salary;
}
}
double avg() {
return (double)sum / count;
}
@Override
public String toString() {
return "jobTitle=" + jobTitle + ", count=" + count + ", sum=" + sum + ", min=" + min + ", max="
+ max + ", avg=" + avg();
}
}
}
PC21-JavaUzupelnienia/src/emps/Grupowanie_Switch.java 0 → 100644
package emps;
import java.util.List;
public class Grupowanie_Switch {
// Ta wersja tylko jako wprowadzenie do wersji ze słownikami.
// Gdybyśmy dla każdego joba mieli oddzielną zmienną do liczenia sumy,
// moglibyśmy wszystko policzyć w jednej pętli.
// Problem:
// 1) program powinien czytać dowolne dane; nie powinien z góry zakładać, jakie są joby
// 2) każdy nowy job zwiększa ilość kodu.
// → jesli zamiast oddzielnych zmiennych użyjemy jednego słownika, to zrobimy to samo, ale zwięźlej
// słownik (Map) z kluczami typu String może być traktowany jako namiasta zestawu zmiennych,
// który możemy łatwo rozszerzać gdy pojawiają się nowe wartości
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
double sumaProgrammer = 0;
double sumaAccountant = 0;
double sumaPresident = 0;
// itd....
for (Employee emp : emps) {
switch(emp.getJobTitle()) {
case "Programmer" -> sumaProgrammer += emp.getSalary();
case "Accountant" -> sumaAccountant += emp.getSalary();
case "President" -> sumaPresident += emp.getSalary();
}
}
System.out.println(sumaProgrammer);
System.out.println(sumaAccountant);
System.out.println(sumaPresident);
}
}
PC21-JavaUzupelnienia/src/emps/Nieobiektowo_SredniaWybranych.java 0 → 100644
package emps;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import javax.swing.JOptionPane;
public class Nieobiektowo_SredniaWybranych {
// Średnia pensja pracowników na wybranym stanowisku.
public static void main(String[] args) {
String szukanyJob = JOptionPane.showInputDialog("Podaj nazwę stanowiska", "Programmer");
try(Scanner scanner = new Scanner(new File("pliki/emps.csv"))) {
int suma = 0;
int ile = 0;
while(scanner.hasNextLine()) {
String linia = scanner.nextLine();
String[] t = linia.split(";");
if(t[3].equals(szukanyJob)) {
suma += Integer.parseInt(t[4]);
ile++;
}
}
double srednia = 1. * suma / ile;
JOptionPane.showMessageDialog(null, "Średnia pensja: " + srednia);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
PC21-JavaUzupelnienia/src/emps/Nieobiektowo_WypiszDane.java 0 → 100644
package emps;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class Nieobiektowo_WypiszDane {
// Program czyta plik emps.csv i dla każdego pracownika wypisuje
// imię, nazwisko, salary
// Podejście nieobiektowe. Cały program w main: od czytania linii z pliku, po dostęp do danych.
public static void main(String[] args) {
try(Scanner scanner = new Scanner(new File("pliki/emps.csv"))) {
while(scanner.hasNextLine()) {
String linia = scanner.nextLine();
String[] t = linia.split(";");
// System.out.println(java.util.Arrays.toString(t));
System.out.println("Pracownik " + t[1] + " " + t[2] + " zarabia " + t[4]);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
PC21-JavaUzupelnienia/src/emps/ObslugaCSV.java 0 → 100644
package emps;
import java.io.*;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
public class ObslugaCSV {
public static List<Employee> wczytaj() {
return wczytaj("pliki/emps.csv");
}
public static List<Employee> wczytaj(String sciezka) {
return wczytaj(new File(sciezka));
}
public static List<Employee> wczytaj(File plik) {
List<Employee> emps = new ArrayList<>();
try (BufferedReader reader = new BufferedReader(new FileReader(plik))) {
reader.readLine(); // tylko po to, aby pominąć pierwszą linię
String linia;
while((linia = reader.readLine()) != null) {
String[] t = linia.split(";", -1);
// psucie danych, aby sprawdzić porównania z nullem
// if(t[1].charAt(0) == 'A') {
// t[3] = null;
// }
Employee emp = new Employee(Integer.parseInt(t[0]),
t[1], t[2], t[3], Integer.parseInt(t[4]),
LocalDate.parse(t[5]), t[6], t[7], t[8], t[9], t[10]);
emps.add(emp);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
return emps;
}
}
PC21-JavaUzupelnienia/src/emps/P0_WypiszObiekty.java 0 → 100644
package emps;
import java.util.List;
public class P0_WypiszObiekty {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("pliki/emps.csv");
System.out.println("Liczba rekordów: " + emps.size());
for (Employee emp : emps) {
System.out.println(emp);
}
}
}
PC21-JavaUzupelnienia/src/emps/P1_WypiszWybranePola.java 0 → 100644
package emps;
import java.util.List;
public class P1_WypiszWybranePola {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
for(Employee emp : emps) {
// System.out.println(emp.getFirstName() + " " + emp.getLastName();
System.out.printf("%s %s (%s) zarabia %d%n",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
}
}
}
PC21-JavaUzupelnienia/src/emps/P2_WypiszBogatych.java 0 → 100644
package emps;
import java.util.List;
public class P2_WypiszBogatych {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
int ile = 0;
for(Employee emp : emps) {
if(emp.getSalary() >= 10_000) {
System.out.printf("%s %s (%s) zarabia %d i pracuje w %s.\n",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getCity());
ile++;
}
}
System.out.println(ile);
}
}
PC21-JavaUzupelnienia/src/emps/P3_SredniaWszystkich.java 0 → 100644
package emps;
import java.util.List;
public class P3_SredniaWszystkich {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
int suma = 0;
for(Employee emp : emps) {
suma += emp.getSalary();
}
double srednia = (double)suma / emps.size();
System.out.println("Średnia wszystkich: " + srednia);
}
}
PC21-JavaUzupelnienia/src/emps/P4a_SredniaWybranych.java 0 → 100644
package emps;
import java.util.List;
public class P4a_SredniaWybranych {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
double suma = 0;
int ile = 0;
for(Employee emp : emps) {
if("Programmer".equals(emp.getJobTitle())) {
suma += emp.getSalary();
ile++;
}
}
double srednia = suma / ile;
System.out.println("Średnia programistów: " + srednia);
}
}
PC21-JavaUzupelnienia/src/emps/P4b_SredniaWybranych.java 0 → 100644
package emps;
import java.util.List;
import java.util.Objects;
import javax.swing.JOptionPane;
public class P4b_SredniaWybranych {
public static void main(String[] args) {
String szukanyJob = JOptionPane.showInputDialog("Podaj nazwę stanowiska");
List<Employee> emps = ObslugaCSV.wczytaj();
double suma = 0;
int ile = 0;
for(Employee emp : emps) {
if(Objects.equals(emp.getJobTitle(), szukanyJob)) {
suma += emp.getSalary();
ile++;
}
}
if(ile > 0) {
double srednia = suma / ile;
JOptionPane.showMessageDialog(null, "Średnia na stanowisku " + szukanyJob + " wynosi " + srednia);
} else {
JOptionPane.showMessageDialog(null, "Nikt nie pracuje na stanowisku " + szukanyJob, "Nie znaleziono", JOptionPane.WARNING_MESSAGE);
}
}
}
PC21-JavaUzupelnienia/src/emps/P4c_SredniaInteraktywnie.java 0 → 100644
package emps;
import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.io.File;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.TreeSet;
public class P4c_SredniaInteraktywnie {
public static void main(String[] args) {
JFileChooser chooser = new JFileChooser(".");
chooser.setFileFilter(new FileNameExtensionFilter("pliki CSV", "csv", "txt"));
int coSieStalo = chooser.showOpenDialog(null);
if(coSieStalo != JFileChooser.APPROVE_OPTION) {
// jeśli było Cancel lub wystąpił błąd
return;
}
File plik = chooser.getSelectedFile();
List<Employee> emps = ObslugaCSV.wczytaj(plik);
// zbieram listę stanowisk do wyboru
Set<String> jobs = new TreeSet<>();
for(Employee emp : emps) {
jobs.add(emp.getJobTitle());
}
Object szukanyJob = JOptionPane.showInputDialog(null, "Wybierz stanowisko",
"Pytanie", JOptionPane.QUESTION_MESSAGE, null, jobs.toArray(), null);
int suma = 0;
int ile = 0;
for(Employee emp : emps) {
if(Objects.equals(emp.getJobTitle(), szukanyJob)) {
suma += emp.getSalary();
ile++;
}
}
if(ile == 0) {
JOptionPane.showMessageDialog(null, "Nie ma osób na takim stanowisku", "Brak danych", JOptionPane.WARNING_MESSAGE);
} else {
double srednia = (double)suma / ile;
JOptionPane.showMessageDialog(null, "średnia: " + srednia);
}
}
}
PC21-JavaUzupelnienia/src/emps/P5_MinMax_v1.java 0 → 100644
package emps;
import java.util.List;
public class P5_MinMax_v1 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
int maxSalary = 0;
int minSalary = Integer.MAX_VALUE;
String max = "";
String min = "";
for(Employee emp : emps) {
if(emp.getSalary() > maxSalary) {
maxSalary = emp.getSalary();
max = emp.getFirstName() + " " + emp.getLastName();
}
if(emp.getSalary() < minSalary) {
minSalary = emp.getSalary();
min = emp.getFirstName() + " " + emp.getLastName();
}
}
System.out.println("max: " + maxSalary + " = " + max);
System.out.println("min: " + minSalary + " = " + min);
}
}
PC21-JavaUzupelnienia/src/emps/P5_MinMax_v2.java 0 → 100644
package emps;
import java.util.List;
public class P5_MinMax_v2 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Employee max = null;
Employee min = null;
for(Employee emp : emps) {
if(max == null || emp.getSalary() > max.getSalary()) {
max = emp;
}
if(min == null || emp.getSalary() < min.getSalary()) {
min = emp;
}
}
System.out.println("max: " + max);
System.out.println("min: " + min);
}
}
PC21-JavaUzupelnienia/src/emps/P5_MinMax_v3.java 0 → 100644
package emps;
import java.util.List;
public class P5_MinMax_v3 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
if(emps.isEmpty()) {
System.out.println("Brak danych");
System.exit(1); // zakończenie procesu z podanym kodem
}
Employee max = emps.get(0);
Employee min = emps.get(0);
for(Employee emp : emps) {
if(emp.getSalary() > max.getSalary()) {
max = emp;
}
if(emp.getSalary() < min.getSalary()) {
min = emp;
}
}
System.out.println("max: " + max);
System.out.println("min: " + min);
}
}
PC21-JavaUzupelnienia/src/emps/P6_Sortowanie_v0.java 0 → 100644
package emps;
import java.util.List;
public class P6_Sortowanie_v0 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.sort(null);
for(Employee emp : emps) {
System.out.printf("|%-12s|%-15s|%-31s|%6d |%-20s|\n",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getCity());
}
}
}
PC21-JavaUzupelnienia/src/emps/P6_Sortowanie_v1.java 0 → 100644
package emps;
import java.util.Comparator;
import java.util.List;
public class P6_Sortowanie_v1 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
// Do metod sortujących można przekazać obiekt zgodny z interfejsem Comparator.
// Jest wiele sposobó, aby taki komparator uzyskać.
// W tej wersji tworzę dodatkową klasę KomparatorPracownikow.
// Przy okazji: niech to będzie klasa zagnieżdżona.
KomparatorPracownikow porownywarka = new KomparatorPracownikow();
emps.sort(porownywarka);
for(Employee emp : emps) {
System.out.printf("|%-12s|%-15s|%-31s|%6d |%-20s|\n",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getCity());
}
System.out.println();
System.out.printf("Do sortowania %d obiektów potrzebnych było %d porównań.\n",
emps.size(), porownywarka.liczbaPorownan);
}
private static class KomparatorPracownikow implements Comparator<Employee> {
int liczbaPorownan = 0;
// Metody porównujące (Comparator.comparte oraz Comparable.compareTo)
// zwracają wynik typu int, który ma takie znaczenie:
// wynik < 0 → lewy argument jest mniejszy od prawego
// wynik > 0 → lewy argument jest większy od prawego
// wynik = 0 → oba argumenty są równe
// TO MY JAKO AUTORZY KOMPARATORA OKREŚLAMY CO JEST MNIEJSZE, A CO WIĘKSZE
public int compare(Employee emp1, Employee emp2) {
liczbaPorownan++;
// System.out.println("porównuję " + emp1.getLastName() + " vs " + emp2.getLastName());
return emp1.getSalary() - emp2.getSalary();
// to jest sortowanie rosnące wg pensji
}
}
}
PC21-JavaUzupelnienia/src/emps/P6_Sortowanie_v2.java 0 → 100644
package emps;
import java.util.Comparator;
import java.util.List;
public class P6_Sortowanie_v2 {
// W tej wersji oobiekt Comparator tworzymy za pomocą konstrukcji "klasa anonimowa".
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.sort(new Comparator<>() {
public int compare(Employee emp1, Employee emp2) {
return emp2.getSalary() - emp1.getSalary();
}
});
for(Employee emp : emps) {
System.out.printf("|%-12s|%-15s|%-31s|%6d |%-20s|\n",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getCity());
}
}
}
PC21-JavaUzupelnienia/src/emps/P6_Sortowanie_v3.java 0 → 100644
package emps;
import java.util.List;
public class P6_Sortowanie_v3 {
// W tej wersji komparator tworzę za pomocą wyrażenia lambda. Dostępne od Java 8.
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.sort((emp1, emp2) -> emp2.getSalary() - emp1.getSalary());
for(Employee emp : emps) {
System.out.printf("|%-12s|%-15s|%-31s|%6d |%-20s|\n",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getCity());
}
}
}
PC21-JavaUzupelnienia/src/emps/P6_Sortowanie_v4.java 0 → 100644
package emps;
import java.util.Comparator;
import java.util.List;
public class P6_Sortowanie_v4 {
// W Java 8 pojawiły się też kreatory komparatorów, które pozwalają porównywać obiekty zwn wybrane kryteria.
// Do comparing / comparingInt itd
// przekazuje się funkcję, która na podstawie obiektu zwraca wybraną wartość, wg której obiekty są porównywane.
// Najczęściej tą funkcją jest getter odczytujący wybrane pole.
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.sort(Comparator.comparingInt(Employee::getSalary).reversed());
for(Employee emp : emps) {
System.out.printf("|%-12s|%-15s|%-31s|%6d |%-20s|\n",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getCity());
}
}
}
PC21-JavaUzupelnienia/src/emps/P6_Sortowanie_v5.java 0 → 100644
package emps;
import java.util.Comparator;
import java.util.List;
public class P6_Sortowanie_v5 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.sort(Comparator.comparing(Employee::getLastName).thenComparing(Employee::getFirstName));
for(Employee emp : emps) {
System.out.printf("|%-12s|%-15s|%-31s|%6d |%-20s|\n",
emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getCity());
}
}
}
PC21-JavaUzupelnienia/src/emps/P7_UnikalneMiasta.java 0 → 100644
package emps;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
public class P7_UnikalneMiasta {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Set<String> miasta = new TreeSet<>();
for(Employee emp : emps) {
if(!emp.getCity().isEmpty()) {
miasta.add(emp.getCity());
}
}
System.out.println(miasta);
System.out.println("Liczba miast: " + miasta.size());
System.out.println();
for(String miasto : miasta) {
System.out.println(" * " + miasto);
}
}
}
PC21-JavaUzupelnienia/src/emps/Porownywanie.java 0 → 100644
package emps;
import java.time.LocalDate;
public class Porownywanie {
public static void main(String[] args) {
Employee emp1 = new Employee(1, "Jan", "Kowalski", "kierowca", 4400, LocalDate.of(1990, 4, 5), "transport", "Jasna 14", "01-234", "Warszawa", "Polska");
Employee emp2 = new Employee(1, "Jan", "Kowalski", "kierowca", 4400, LocalDate.of(1990, 4, 5), "transport", "Jasna 14", "01-234", "Warszawa", "Polska");
Employee emp3 = new Employee(3, "Janina", "Kowalska", "kierowca", 4400, LocalDate.of(1990, 4, 5), "transport", "Jasna 14", "01-234", "Warszawa", "Polska");
Employee emp4 = emp1;
System.out.println(emp1);
System.out.println(emp2);
System.out.println(emp3);
System.out.println();
System.out.println("==");
System.out.println(emp1 == emp1);
System.out.println(emp1 == emp2);
System.out.println(emp1 == emp3);
System.out.println(emp1 == emp4);
System.out.println();
System.out.println("eq");
System.out.println(emp1.equals(emp1));
System.out.println(emp1.equals(emp2));
System.out.println(emp1.equals(emp3));
System.out.println(emp1.equals(emp4));
// Domyślna implementacja equals, tak samo jak operacja ==, porównuje adresy obiektów.
// Sprawdza, czy to jest TEN SAM obiekt (a nie TAKI SAM).
// Aby equals sprawdzało czy obiekty zawierają te same dane, powinniśmy przedefiniować (Override)metodę equals w definicji klasy.
}
}
PC21-JavaUzupelnienia/src/emps/zadania.txt 0 → 100644
P1_WypiszWybranePola - dla każdego pracowika wypisać wybrane informacje,
np. "Steven King (President) zarabia 24000"
P2_WypiszBogatych - wypisz tych pracowników, którzy zarabiają >= 10 tys.
P3_Srednia - oblicz średnią pensję wszystkich
P4_SredniaJob - oblicz średnią pensję na wybranym stanowisku
- może być wpisane na stałe (np. Programmer)
- a może uda się wersję, że user wpisuje
P5_MinMax - wypisz kto zarabia najwięcej, a kto najmniej (nie tylko liczby, ale też imię i nazwisko)
P6_Sortowanie (opcjonalnie) - posortuj pracowników wg pensji malejąco
P7_UnikalneMiasta - wypisz miasta bez powtórzeń
PC21-JavaUzupelnienia/src/p00_hello/Hello.java 0 → 100644
package p00_hello;
public class Hello {
public static void main(String[] args) {
System.out.println("Hello world");
}
}
PC21-JavaUzupelnienia/src/p01_okna_dialogowe/RodzajeOkien.java 0 → 100644
package p01_okna_dialogowe;
import java.time.LocalDateTime;
import javax.swing.JOptionPane;
public class RodzajeOkien {
public static void main(String[] args) {
JOptionPane.showMessageDialog(null, "To jest zwykły MessageDialog");
JOptionPane.showMessageDialog(null, "To jest MessageDialog typu WARNING", "Uwaga", JOptionPane.WARNING_MESSAGE);
// są też inne typy: PLAIN_MESSAGE, INFORMATION_MESSAGE, QUESTION_MESSAGE, WARNING_MESSAGE, ERROR_MESSAGE
String cos = JOptionPane.showInputDialog("To jest inputDialog.\nNapisz coś:");
String data = JOptionPane.showInputDialog("To jest inputDialog z początkową wartością.", LocalDateTime.now());
// Rozbudowana wersja showInputDialog pozwala wybrać wartość z rozwijanej listy
// Należy przekazać tablicę wartości do wyboru
String[] opcje = {"wiosna", "lato", "jesień", "zima"};
String poraRoku = (String)JOptionPane.showInputDialog(null, "Którą porę roku lubisz najbardziej?",
"Pytanie", JOptionPane.QUESTION_MESSAGE, null, opcje, "jesień");
int pora2 = JOptionPane.showOptionDialog(null, "A której pory nie lubisz?",
"Pytanie 2", 0, JOptionPane.QUESTION_MESSAGE, null, opcje, "zima");
// dostajemy numer wybranej opcji, od 0
int wybor = JOptionPane.showConfirmDialog(null, "Czy chcesz " + cos + " o godzinie " + data + "?");
switch(wybor) {
case JOptionPane.YES_OPTION ->
JOptionPane.showMessageDialog(null, "TAK");
case JOptionPane.NO_OPTION ->
JOptionPane.showMessageDialog(null, "NO");
case JOptionPane.CANCEL_OPTION ->
JOptionPane.showMessageDialog(null, "Cancel");
default ->
JOptionPane.showMessageDialog(null, "Inna wartość: " + wybor);
// zamknięcie okna daje wynik -1 czyli CLOSED_OPTION
}
}
}
PC21-JavaUzupelnienia/src/p01_okna_dialogowe/Rozmowa.java 0 → 100644
package p01_okna_dialogowe;
import javax.swing.*;
public class Rozmowa {
public static void main(String[] args) {
String imie = JOptionPane.showInputDialog("Jak masz na imię?");
int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat, " + imie + "?"));
if(wiek >= 18) {
JOptionPane.showMessageDialog(null, "Możesz kupić piwo :-)");
} else {
JOptionPane.showMessageDialog(null, "Proponuję oranżadę",
"Niepełnoletni!", JOptionPane.WARNING_MESSAGE);
}
}
}
PC21-JavaUzupelnienia/src/p01_okna_dialogowe/Rozmowa_ImportStatic.java 0 → 100644
package p01_okna_dialogowe;
import static java.lang.Integer.parseInt;
import static javax.swing.JOptionPane.*;
public class Rozmowa_ImportStatic {
public static void main(String[] args) {
String imie = showInputDialog("Jak masz na imię?");
int wiek = parseInt(showInputDialog("Ile masz lat, " + imie + "?"));
if(wiek >= 18) {
showMessageDialog(null, "Możesz kupić piwo :-)");
} else {
showMessageDialog(null, "Proponuję oranżadę", "Niepełnoletni!", WARNING_MESSAGE);
}
}
}
PC21-JavaUzupelnienia/src/p02_konsola/A_Print.java 0 → 100644
package p02_konsola;
import java.util.Locale;
public class A_Print {
public static void main(String[] args) {
// println wypisuje coś i potem przechodzi do nast. linii
System.out.println("Wypisuję pierwszą linię");
System.out.println("Wypisuję drugą linię");
System.err.println("To jest niby błąd");
// pusty println - pusta linia
System.out.println();
// print - wypisuje coś i nie przechodzi do nowej linii
System.out.print("Ala");
System.out.print("Ola");
System.out.print("Ela");
System.out.println("Koniec");
int x = 50;
String s = "Ala";
// print, println przyjmują dowolne parametry
System.out.println(x);
// ale przyjmują tylko jeden parametr
//System.out.println("Liczba:", x);
// Jeśli chcemy wypisać kilka rzeczy, to najczęściej łączy się je znakiem +
// Do napisu można dodać także inne wartoścu (liczby, obiekty...)
System.out.println("Liczba: " + x);
System.out.println();
// W Javie dostępne jest też printf, prawie takie samo jak w C i podobne jak % w Pythonie.
// Pierwszym parametrem jest wzorzec (pattern), w którym są normalne fragmenty tekstu oraz znaczniki %X,
// na które są wstawiane wartości podane później po przecinku.
// %s - string lub dowolna wartość przekonwertowana na tekst tak, jakbyśmy wypisali ją printem
// %d - liczba całkowita
// %f - liczba z ułamkiem
// %x - liczba szesnastkowo
System.out.printf("Osoba %s ma %d lat.\n", s, x);
double pi = Math.PI;
// Zostaną użyte "lokale" z ustawień systemu, u mnie polskie - liczba wypisuje się z przecinkiem
System.out.printf("|%10s|%4d|%-4d|%04d|%6.3f|%n", s, x, x, x, pi);
// Wskazuję lokale amerykańskie - liczba wypisze się z kropką
System.out.printf(Locale.US, "|%10s|%4d|%-4d|%04d|%6.3f|%n", s, x, x, x, pi);
System.out.println();
// Jeśli bardzo potrzebujemy, to na standadowe wyjście można wypisywać też dane binarne.
System.out.write(65);
System.out.write(66);
System.out.write(67);
System.out.write(10);
}
}
PC21-JavaUzupelnienia/src/p02_konsola/B_StandardoweWejscie1.java 0 → 100644
package p02_konsola;
import java.io.IOException;
public class B_StandardoweWejscie1 {
public static void main(String[] args) throws IOException {
// standardowe wyjście (stdout)
System.out.println("Normalny output");
// wyjście błędów (stderr)
System.err.println("Wyjście błędów");
System.out.println("Napisz kawałek tekstu:");
// standardowe wejście
int x = System.in.read();
System.out.println("pierwszy bajt: " + x);
x = System.in.read();
System.out.println("drugi bajt: " + x);
}
}
PC21-JavaUzupelnienia/src/p02_konsola/B_StandardoweWejscie2.java 0 → 100644
package p02_konsola;
import java.io.IOException;
import java.util.Arrays;
public class B_StandardoweWejscie2 {
public static void main(String[] args) throws IOException {
System.out.println("Napisz coś");
// Można też wczytać całą porcję bajtów do tablicy
byte[] bajty = new byte[100];
int ile = System.in.read(bajty);
System.out.println("Odczytano " + ile + " bajtów.");
System.out.println(Arrays.toString(bajty));
// Można utworzyć napis na podstawie ciągu bajtów:
String napis = new String(bajty, 0, ile);
// String napis = new String(bajty, 0, ile, "UTF-8");
System.out.println("Napisałeś: " + napis);
}
}
// System.in pozwala czytać surowe dane w postaci pojedynczych bajtów lub tablicy bajtów.
// Jest to niewygodne. Przydałaby nam się operacja czytania całej linii tekstu albo całych słów, albo liczb zapisanych dziesiętnie...
// W paktyce korzysta się z tego za pośrednictwem klasy Scanner (lub ewentualnie BufferedReader).
PC21-JavaUzupelnienia/src/p02_konsola/C_Skaner1.java 0 → 100644
package p02_konsola;
import java.util.Scanner;
public class C_Skaner1 {
public static void main(String[] args) {
// Deklaruję zmienną scanner typu Scanner
// i wpisuję do niej nowy obiekt klasy Scanner.
// Ten skaner będzie czytał dane ze standardowego wejścia (System.in)
Scanner scanner = new Scanner(System.in);
// Gdy zmieniemy ustawienia na amerykańskie, to liczby będzie trzeba wpisywać z kropką.
// scanner.useLocale(Locale.US);
// Jeśli tego nie zrobimy, to wszystko zależy od ustawień językowych komputera. Jeśli są PL, to wpisujemy liczby z przecinkiem
System.out.println("Wpisz linię tekstu:");
String linia = scanner.nextLine();
System.out.println("linia: " + linia);
System.out.println("Napisz kilka słów:");
String slowo1 = scanner.next();
String slowo2 = scanner.next();
// Po wczytaniu pojedynczych słów lub liczb, warto wykonać nextLine,
// aby wczytać wszystkie pozostałe znaki do końca linii - w ten sposób "oczyszczamy wejście"
String reszta = scanner.nextLine();
System.out.println("Pierwsze słowo: " + slowo1);
System.out.println("Drugie słowo: " + slowo2);
System.out.println("Reszta linii: " + reszta);
System.out.print("Podaj liczbę całkowitą: ");
int x = scanner.nextInt();
System.out.println("x = " + x);
System.out.print("Podaj liczbę z ułamkiem: ");
double d = scanner.nextDouble();
System.out.println("d = " + d);
System.out.println("iloczyn tych liczb: " + x*d);
// można też long, BigDecimal, a nawet boolean
// Zamykanie skanera, który czyta stdin, nie jest konieczne,
// ale napiszemy tu close, aby Eclipse nie pokazywał warninga.
scanner.close();
}
}
PC21-JavaUzupelnienia/src/p02_konsola/C_Skaner2_LiczbaCzyNieLiczba.java 0 → 100644
package p02_konsola;
import java.util.Scanner;
public class C_Skaner2_LiczbaCzyNieLiczba {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Napisz coś:");
if(sc.hasNextInt()) {
int liczba = sc.nextInt();
System.out.println("Wpisałeś int: " + liczba);
} else if(sc.hasNextDouble()) {
double liczba = sc.nextDouble();
System.out.println("Wpisałeś double: " + liczba);
} else {
String slowo = sc.next();
System.out.println("Wpisałeś tekst: " + slowo);
}
String reszta = sc.nextLine();
System.out.println("Reszta linii: " + reszta);
System.out.println("Reszta miała znaków: " + reszta.length());
}
}
PC21-JavaUzupelnienia/src/p02_konsola/D_BufRead.java 0 → 100644
package p02_konsola;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
// Aby czytać wejście linia po linii, można użyć klas Scanner (inny przykład) lub BufferedReader (tutaj).
// Pośrednio potrzebna jest klasa InputStreamReader.
// Gdybyśmy chcieli podać własne kodowane znaków (inne niż systemowe), to wtedy:
// InputStreamReader isr = new InputStreamReader(System.in, "UTF-8");
public class D_BufRead {
public static void main(String[] args) {
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String wiersz;
while((wiersz = br.readLine()) != null) {
System.out.println("Napisałeś " + wiersz);
if("koniec".equalsIgnoreCase(wiersz))
break;
}
System.out.println("KONIEC");
} catch(IOException e) {
e.printStackTrace();
}
}
}
PC21-JavaUzupelnienia/src/p02_konsola/E_KlasaConsole.java 0 → 100644
package p02_konsola;
import java.io.Console;
import java.util.Arrays;
public class E_KlasaConsole {
public static void main(String[] args) {
System.out.println("Początek");
Console konsola = System.console();
System.out.println("System.console() = " + konsola);
if(konsola == null) {
System.out.println("Brak możliwości utworzenia konsoli.");
return;
}
String wiersz;
while((wiersz = konsola.readLine("> ")) != null) {
konsola.printf("Napisałeś %s %n", wiersz);
if("koniec".equals(wiersz))
break;
}
System.out.println("KONIEC");
char[] hasło = konsola.readPassword("Podaj tajne hasło: ");
konsola.printf("Hasło ma długość %d %n", hasło.length);
// "zamazuję" hasło w pamięci, żeby inne programy nie mogły go odczytać
Arrays.fill(hasło, 'X');
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/A_Zmienne.java 0 → 100644
package p03_zmienne_i_typy;
public class A_Zmienne {
// zmienne z poziomu klasy - tzw. "pola"
// statyczna - jeden egzemplarz dla klasy
static int statyczna;
// "instancyjna" - oddzilenie dla każdego obiektu
int instancyjna;
public static void main(String[] args) {
// W Javie zmienne muszą zadeklarowane
// System.out.println(x);
// x = 100;
// System.out.println(x);
// Sama deklaracja zmienej:
int x;
// Java nie inicjalizuje automatycznie zmiennych lokalnych.
// Niezainicjowanych zmiennych nie wolno czytać (błąd kompilacji)
// System.out.println(x);
x = 150;
System.out.println("x = " + x);
// zmienne z poziomu klasy SĄ automatycznie inicjowane na 0, null lub false
System.out.println("statyczna = " + statyczna);
int y;
if(x > 100) {
y = 500;
System.out.println("y = " + y);
}
// tutaj kompilator "nie ma pewności", że y jest zainicjowany
// System.out.println("y = " + y);
if(x > 100) {
y = 500;
} else {
y = 600;
}
System.out.println("y = " + y);
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/B_Typy.java 0 → 100644
package p03_zmienne_i_typy;
import java.time.LocalDateTime;
public class B_Typy {
public static void main(String[] args) {
// 8 typów prostych:
// liczby calkowite: byte, short, int, long
byte b = 100;
short s = 1000;
int i = 23;
long l = 333;
System.out.println(b * s * i * l);
// 2 typy dla liczb z ułamkiem. liczby "zmiennopozycyjne" / "zmiennoprzeconkowe" (floating point)
float f = 3.14F;
double d = 123.456;
System.out.println(f * d);
System.out.println();
// char - pojedynczy znak, ale patrząc technicznie, to jest liczba 16-bitowa, która może być kodem znaku
char c = 'A';
System.out.println(c);
System.out.println(c+1); // kodem litery A jest 65
c++;
// teraz jednak "przesuwamy znak" o jedną pozycję do przodu
System.out.println(c);
boolean warunek = true;
System.out.println(warunek);
warunek = f < 3;
System.out.println(warunek);
// przy okazji dwa sposoby umieszczania egzotycznych znaków w napisach:
if(warunek) {
System.out.println("\u03C0 jest małe");
} else {
System.out.println("π jest duże");
}
System.out.println();
// Typy obiektowe: klasa, interfejs, enum, rekord oraz tablice
// Sama Java definiuje ich kilka tysięcy, a programiści mogą tworzyć własne
String napis = "Ala ma kota";
System.out.println(napis);
System.out.println(napis.toUpperCase());
LocalDateTime czas = LocalDateTime.now();
System.out.println(czas);
System.out.println("Godzina " + czas.getHour() + " minut " + czas.getMinute());
// itd, jest tego bardzo dużo
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/BityIBajty.java 0 → 100644
package p03_zmienne_i_typy;
public class BityIBajty {
/* Program wypisuje wartość zmiennej typu byte oraz jej zapis w pamięci w postaci ciągu 8 bitów, zwiększając w pętli wartość o 1.
* Widać zjawisko integer overflow: wartość +127 przechodzi w wartość -128.
* Dla zmiennych typu short, int, long jest analogicznie; różnica jest w długości ciągu bitów (16, 32 i 64) i zakresie liczb.
*/
public static void main(String[] args) {
System.out.println("Zwiększanie bajta:");
byte b = 0;
for(int i = 0; i <= 512; i++) {
String bity = Integer.toBinaryString(Byte.toUnsignedInt(b));
bity = String.format("%8s", bity);
bity = bity.replace(' ', '0');
System.out.printf("%4d : %s%n", b, bity);
b++;
}
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/BlokiTekstowe.java 0 → 100644
package p03_zmienne_i_typy;
public class BlokiTekstowe {
public static void main(String[] args) {
String blok = """
Pierwsza linia.
Druga linia
Wcięcie tekstu.
Znaki specjalne:\tdalej\nDalsza linia
Koniec.
""";
System.out.println(blok);
System.out.println(blok.length());
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/Ciekawostki.java 0 → 100644
package p03_zmienne_i_typy;
public class Ciekawostki {
public static void main(String[] args) {
int x = 5, y = 1000000000;
int z = x * y;
System.out.println(z);
System.out.println(5 * 1000000000);
System.out.println(5L * 1000000000);
System.out.println(3 * 1000000000);
// Gdy wynik obliczenia nie mieści się w zakresie dla danego typu (int lub long)
// dochodzi do "integer overflow". W Javie nie powoduje to błędu (w sensie wyjątku),
// po prostu wychodzi "przekręcony" wynik.
System.out.println();
double a = 3.0, b = 1.2;
System.out.println(a * b);
System.out.println(3 * 1.2);
double oczekiwany = 3.6;
if(a * b == oczekiwany) {
System.out.println("OK");
} else {
System.out.println("Nie OK");
System.out.println("różnica: " + (oczekiwany - a * b));
}
System.out.println();
// Liczby zmiennoprzecinkowe (w Javie: float i double) działają w przybliżeniu.
// W pamięci są zapisany w systemie dwójkowym, a nie dziesiętnym, więc zaokrąglenia nastepują w zapisie binarnym liczby, co utrudnia zrozumienie.
// Praktyczny morał: double nie używa się do liczenia pieniędzy.
// Lepszą alternatywą jest wyspecjalizowana klasa BigDecimal.
// Liczba całkowita zapisana w kodzie zaczynając od cyfry 0, jest w systemie ósemkowym.
int n = 0321; // = 3*64 + 2*8 + 1*1
System.out.println(n);
System.out.println(0321);
//NK int m = 098;
System.out.println();
// Od Javy 7 między cyframi można wpisywać znaki _ , które nie zmieniają wartości
int i = 123_456_789;
System.out.println(i);
int j = 123____4___5;
System.out.println(j);
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/Dzielenie.java 0 → 100644
package p03_zmienne_i_typy;
public class Dzielenie {
public static void main(String[] args) {
double d = 1.25;
int n = 5;
// Uwaga na kolejność działań gdy miesza się inty i double
// Tutaj: int dzielony porzez int - wynik obcinany do liczby całkowitej
System.out.println(n / 3 * d);
// dzielenie na doublach
System.out.println(n * d / 3);
System.out.println(1.0 * n / 3 * d);
System.out.println((double)n / 3 * d);
System.out.println();
System.out.println("Dzielenie całkowite i reszta z dzielenia:");
for(int i = -10; i <= 10; i++) {
System.out.printf("%3d / 3 = %2d %3d %% 3 = %2d\n", i, i / 3, i, i % 3);
}
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/LiteralyLiczbowe.java 0 → 100644
package p03_zmienne_i_typy;
public class LiteralyLiczbowe {
public static void main(String[] args) {
int x;
x = 123; // format dziesiętny
System.out.println(x);
x = 0123; // system ósemkowy
//NK x = 08; // cyfry od 0 do 7
System.out.println(x);
x = 0x100; // system szesnastkowy
System.out.println(x);
x = 0x7F;
System.out.println(x);
// system dwójkowy - od Javy 7
x = 0b1101;
System.out.println(x);
// odstępy pomiędzy cyframi - od Javy 7
x = 2_000_000;
System.out.println(x);
//NK long l = 4000000000; // wartość nie mieszcząca się w int
long l = 4000000000L; // OK
// int _1000 = 1313;
// x = _1000; // odwołanie do zmiennej :)
// x = 1000_;
x = 10______00; // po prostu tysiąc
// dopuszczalne są tylko pomiędzy cyframi.
// nie na początku, nie na końcu, nie obok kropki ani obok litery typu i wykładnika
x = 0x0F_FF_80_00;
x = 0b0011_0101;
System.out.println(x); // 1000
double dd = 10__00;
dd = 3.14; // literał liczbowy z częścią ułamkową jest typu double (a nie float)
dd = 1_00.0__0;
//dd = 100._9;
//dd = 100_.9;
dd = 100.99d;
//dd = 100.99_f;
// x = 0x_FF;
// NK x = 1L; // L na końcu oznacza typ long (może być duże lub małe)
l = 1L;
l = 1; // inta można wpisać na zmienną long
System.out.println();
float f = 12; // int na float - OK
// f = 3.14;
// literał z ułamkiem jest typu double, a double nie można wpisać na float
f = 3.14F;
f = 1.0f;
f = 3f;
f = 1.13e2F;
f = (float)3.14; // kompiluje się, ale niezalecane, bo można zgubić precyzję
System.out.println(f);
double d = 3.14;
// NK f = d;
// na końcu double'a też można podać info o typie: D albo d
d = 4.44d;
d = 4.445D;
// liczba w notacji dziesiętnej razy 10 do podanej potęgi
d = 1.25e3;
System.out.println(d);
d = 4.44e-3;
System.out.println(d);
System.out.println();
// liczba w notacji szestastkowej razy 2 do podanej potęgi - tak to jest przechowywane wewnętrznie!
d = 0x3p2; // 12
System.out.println(d);
d = 0x0.2p0; // 2/16 = 1/8 = 0.125
System.out.println(d);
d = 0x1p-3;
System.out.println(d);
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/MnozenieFloat.java 0 → 100644
package p03_zmienne_i_typy;
import java.util.Locale;
import java.util.Scanner;
public class MnozenieFloat {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
scanner.useLocale(Locale.US);
System.out.print("Podaj dwie liczby dziesiętne: ");
double x = scanner.nextDouble();
double y = scanner.nextDouble();
double wynik = x * y;
System.out.println("wynik = " + wynik);
System.out.printf("wynik : %.2f\n", wynik);
System.out.printf(Locale.US, "wynik : %.2f\n", wynik);
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/MnozenieInt.java 0 → 100644
package p03_zmienne_i_typy;
import java.util.Scanner;
public class MnozenieInt {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj dwie liczby całkowite: ");
int x = scanner.nextInt();
int y = scanner.nextInt();
int wynik1 = x * y;
System.out.println("wynik1 = " + wynik1);
try {
int wynik2 = Math.multiplyExact(x, y);
System.out.println("wynik2 = " + wynik2);
} catch(ArithmeticException e) {
System.out.println(e);
}
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/PrzeciazanieIntLong.java 0 → 100644
package p03_zmienne_i_typy;
public class PrzeciazanieIntLong {
public static void main(String[] args) {
try {
System.out.println("oblicza w wersji int:");
System.out.println(Math.multiplyExact(5, 1000_000_000));
} catch(Exception e) {
System.out.println("wersja int: wyjątek " + e);
}
System.out.println();
try {
System.out.println("oblicza w wersji long:");
System.out.println(Math.multiplyExact(5L, 1000_000_000L));
} catch(Exception e) {
System.out.println("wersja long: wyjątek " + e);
}
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/Rzutowania.java 0 → 100644
package p03_zmienne_i_typy;
public class Rzutowania {
// "Hierarchia" typów prostych:
// byte < short < int < long < float < double
// char < int
public static void main(String[] args) {
int x = 107;
float f = 3.14f;
long l3 = 13;
// rzutowanie niejawne - na zmienną typu "szerszego" można zapisać wartość typu "węższego" (widening)
long l = x;
float f2 = l3;
//NK x = l;
//NK l = f;
f = l;
// rzutowanie jawne można stosować zawsze; czasem może wiązać się z "popsuciem" wartości liczbowej
x = (int)l;
System.out.println(x);
// można stosować jawne rzutowanie nawet gdy nie jest konieczne
l = x;
l = (long)x;
System.out.println(l);
l = 4_000_000_000L;
x = (int)l;
System.out.println(x); // zmieniona wartość, ostatnie 32 bity z zapisu tej liczby
f = 100.99F;
x = (int)f; // obcina do wartości całkowitej
System.out.println(x); // 100
f = 4e9f; // 4 * 10^9 czyli 4mld
x = (int)f; // po wyjściu poza zakres przyjmuje MAXINT / MININT
System.out.println(x);
// Na zmienne typu byte, short i char można wpisywać konkretne wartości całkowite, o ile kompilator widzi, że mieszczą się w zakresie
byte b1 = 100;
//NK byte b2 = 200;
x = 100;
//NK byte b3 = x;
final int fi = 10;
b1 = fi; // jeśli wartość jest "stałą" (jest final i jest znana w czasie kompilacji)
b1 = 50;
//NK b1 = x; // bo "nie każdy int mieści się w byte"
x = b1; // OK, bo byte mieści się w int
//NK int i3 = 3L;
float f3 = 3L;
byte b = 13;
b = 15;
//NK b = 130;
x = 15;
//NK b = x;
b = (byte)x;
//NK wezByte(88);
wezByte((byte)88);
wezByte(b);
System.out.println();
System.out.println(dajByte());
System.out.println(dajZnak());
System.out.println();
l = 5_000_000_000L;
x = (int)l;
System.out.println(x);
// rzutowanie liczb całkowitych - bierzemye ostatnie bity z zapisu liczby w pamięci
// zobaczę to samo, co w int overflow gdy mnożyłem 5 * 1000000000
System.out.println("5mld long rzut na int: " + x);
double d = 5_000_000_000.0;
x = (int)d;
System.out.println("5mld double rzut na int: " + x);
// rzutowanie float i double na liczbę całkowitą - bierzemy wartość, która jest najbliżej,
// w tym przypadku będzie to Integer.MAX_VALUE
byte b2 = 40, b3 = 50;
// Operacje arytmetyczne + - * / % - są zdefiniowane dla typu int, a nie dla byte i short
// dlatego ich ywniki trzeba zrzutowa, aby pisać na zmienne tych typów
//NK byte b4 = b2 + b3;
byte b4 = (byte)(b2 + b3);
// ale bez rzutowania działają ++ i +=
System.out.println(b2);
b2++;
System.out.println(b2);
b2 += 10;
System.out.println(b2);
}
static byte dajByte() {
return 65;
}
/* NK
static byte dajByteInaczej() {
int x = 65;
return x;
}
*/
static char dajZnak() {
return 65;
}
static void wezByte(byte bbb) {
System.out.println(bbb);
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/WypiszZakresy.java 0 → 100644
package p03_zmienne_i_typy;
public class WypiszZakresy {
public static void main(String[] args) {
System.out.println("byte " + Byte.BYTES + " bajtów, od " + Byte.MIN_VALUE + " do " + Byte.MAX_VALUE);
System.out.println("short " + Short.BYTES + " bajtów, od " + Short.MIN_VALUE + " do " + Short.MAX_VALUE);
System.out.println("int " + Integer.BYTES + " bajtów, od " + Integer.MIN_VALUE + " do " + Integer.MAX_VALUE);
System.out.println("long " + Long.BYTES + " bajtów, od " + Long.MIN_VALUE + " do " + Long.MAX_VALUE);
System.out.println("char " + Character.BYTES + " bajtów, od " + (int)Character.MIN_VALUE + " do "
+ (int)Character.MAX_VALUE);
System.out.println();
// bez ograniczen: klasy BigInteger (calkowite) i BigDecimal (z ulamkiem)
System.out.println("float " + Float.BYTES + " bajtów, od " + Float.MIN_VALUE + " do " + Float.MAX_VALUE);
System.out.println(" min normal : " + Float.MIN_NORMAL);
System.out.println("double " + Double.BYTES + " bajtów, od " + Double.MIN_VALUE + " do " + Double.MAX_VALUE);
System.out.println(" min normal : " + Double.MIN_NORMAL);
System.out.println();
System.out.println("boolean : false i true");
}
}
PC21-JavaUzupelnienia/src/p03_zmienne_i_typy/Znaki.java 0 → 100644
package p03_zmienne_i_typy;
public class Znaki {
public static void main(String[] args) {
System.out.println("A");
System.out.println("A" + 5);
System.out.println('A');
System.out.println('A' + 5);
System.out.println('A' + 'B');
System.out.println();
char c = 65; // można wpisywać konkretną wartość int, o ile mieści się w zakresie
//NK char d = -1;
int x = 65;
int y = 'A';
//NK c = x; // ale nie int-a ze zmiennej
c = (char)x;
System.out.println(c);
x = c;
System.out.println(x);
x = (int)c;
System.out.println((int)c);
System.out.println();
for(char znak = 'A'; znak <= 'Z'; znak++) {
System.out.print(znak + " ");
}
System.out.println();
int ącki = 'Ą';
System.out.println(ącki);
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/Bagaz_v1.java 0 → 100644
package p04_instrukcje;
import java.util.Scanner;
/* Program czyta od użytkownika 3 liczby: wymiary walizki w cm
* i sprawdza czy walizka mieści się w limitach wymiaru.
* Warunki:
* - żaden wymiar nie może przekraczać 50 cm
* - objętość nie może przekraczać 50 tys cm³
*/
public class Bagaz_v1 {
/* W tej wersji:
* - wszystkie warunki sprawdza są w jednym if, program nie informuje konkretnie dlaczego odrzucił
* - sprawdzamy warunek "pozytywny", czyli piszemy kiedy jest dobrze; spójnikiem jest &&
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj 3 liczby - wymiary bagażu: ");
int x = scanner.nextInt();
int y = scanner.nextInt();
int z = scanner.nextInt();
if(x <= 50 && y <= 50 && z <= 50 && x*y*z <= 50000) {
System.out.println("Bagaż zaakceptowany");
} else {
System.out.println("Bagaż odrzucony");
}
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/Bagaz_v2.java 0 → 100644
package p04_instrukcje;
import java.util.Scanner;
public class Bagaz_v2 {
/* W tej wersji:
* - wszystkie warunki sprawdza są w jednym if, program nie informuje konkretnie dlaczego odrzucił
* - sprawdzamy warunek "negatywny", czyli piszemy kiedy jest źle; spójnikiem jest ||
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj 3 liczby - wymiary bagażu: ");
int x = scanner.nextInt();
int y = scanner.nextInt();
int z = scanner.nextInt();
int obj = x*y*z;
if(x > 50 || y > 50 || z > 50 || obj > 50000) {
System.out.println("Bagaż odrzucony");
} else {
System.out.println("Bagaż zaakceptowany");
}
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/Bagaz_v3.java 0 → 100644
package p04_instrukcje;
import java.util.Scanner;
public class Bagaz_v3 {
/* W tej wersji:
* - rozbijamy warunki do oddzielnych if-ów, aby program napisał dlaczego bagaż został odrzucony
* - ważne jednak, aby program ostatecznie potwierdził akceptację bagażu, lub napisał jednoznacznie, że odrzuca
* - program wypisuje tylko pierwszą przyczynę odrzucenia
* - sprawdzanie warunków pozytywnych prowadzi tutaj do powstania kodu wielokrotnie zagnieżdżonego
* (if w ifie i kolejnym ifie...)
* "else jest daleko od swojego if-a"
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj 3 liczby - wymiary bagażu: ");
int x = scanner.nextInt();
int y = scanner.nextInt();
int z = scanner.nextInt();
int obj = x*y*z;
if(x <= 50) {
if (y <= 50) {
if (z <= 50) {
if (obj <= 50000) {
System.out.println("Bagaż zaakceptowany");
System.out.println("Otwieram bramki");
// zazwyczaj, gdy wszystko jest OK, to jest większa robota do wykonania
} else {
System.out.println("objętość zbyt duża");
}
} else {
System.out.println("z zbyt duży");
}
} else {
System.out.println("y zbyt duży");
}
} else {
System.out.println("x zbyt duży");
}
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/Bagaz_v4.java 0 → 100644
package p04_instrukcje;
import java.util.Scanner;
public class Bagaz_v4 {
/* W tej wersji:
* - rozbijamy warunki do oddzielnych if-ów, aby program napisał dlaczego bagaż został odrzucony
* - program wypisuje tylko pierwszą przyczynę odrzucenia
* - dzięki sprawdzaniu warunków negatywnych, możemy zastosować schemat else-if
* i napisać to na zasadzie: sprawdź czy jest źle z 1. pwoodu, czy z 2. powodu itd.
* a jeśli nie było żadnego problemu, to na samym końcu jest wykonana operacja w przypadku braku błędów
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj 3 liczby - wymiary bagażu: ");
int x = scanner.nextInt();
int y = scanner.nextInt();
int z = scanner.nextInt();
int obj = x*y*z;
if(x > 50) {
System.out.println("x zbyt duży");
} else if (y > 50) {
System.out.println("y zbyt duży");
} else if (z > 50) {
System.out.println("z zbyt duży");
} else if (obj > 50000) {
System.out.println("objętość za duża");
} else {
System.out.println("Bagaż zaakceptowany");
System.out.println("Otwieram bramki");
}
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/Bagaz_v5.java 0 → 100644
package p04_instrukcje;
import java.util.Scanner;
public class Bagaz_v5 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj 3 liczby - wymiary bagażu: ");
int x = scanner.nextInt();
int y = scanner.nextInt();
int z = scanner.nextInt();
int obj = x*y*z;
boolean ok = true;
if(x > 50) {
System.out.println("x zbyt duży");
ok = false;
}
if(y > 50) {
System.out.println("y zbyt duży");
ok = false;
}
if(z > 50) {
System.out.println("z zbyt duży");
ok = false;
}
if(obj > 50000) {
System.out.println("objętość za duża");
ok = false;
}
if(ok) {
System.out.println("Bagaż zaakceptowany");
System.out.println("Otwieram bramki");
} else {
System.out.println("Wystąpiły problemy");
}
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/Bagaz_v6.java 0 → 100644
package p04_instrukcje;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Bagaz_v6 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj 3 liczby - wymiary bagażu: ");
int x = scanner.nextInt();
int y = scanner.nextInt();
int z = scanner.nextInt();
int obj = x*y*z;
// informacje o błędach zostaną zebrane do listy
List<String> listaBledow = new ArrayList<>();
if(x > 50) {
listaBledow.add("x zbyt duży");
}
if(y > 50) {
listaBledow.add("y zbyt duży");
}
if(z > 50) {
listaBledow.add("z zbyt duży");
}
if(obj > 50000) {
listaBledow.add("objętość za duża");
}
if(listaBledow.isEmpty()) {
System.out.println("Bagaż zaakceptowany");
System.out.println("Otwieram bramki");
} else {
System.out.println("Wystąpiły problemy w liczbie " + listaBledow.size());
for(String blad : listaBledow) {
System.out.println(" * " + blad);
}
}
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/If.java 0 → 100644
package p04_instrukcje;
import java.util.Random;
public class If {
public static void main(String[] args) {
Random random = new Random();
int x = random.nextInt(100); // liczba od 0 do 99 włącznie
int y = random.nextInt(100);
System.out.println("Wylosowane liczby:");
System.out.printf("x = %d , y = %d\n", x, y);
// Wzorcowa wersja if:
// if(WARUNEK) { INSTRUKCJE1 } else { INSTRUKCJE2 }
// Gdy WARUNEK jest prawdą, wykonają się INSTRUKCJE1, a jeśli nieprawdą, to INSTRUKCJE2
if(x % 2 == 0) {
System.out.println("x jest parzysty");
System.out.println("Ala ma kota");
} else {
System.out.println("x jest nieparzysty");
System.out.println("Ola ma psa");
}
System.out.println("a kuku");
System.out.println();
// Jeśli za ifem lub elsem do wykonania jest tylko jedna instrukcja, to można pominąć nawiasy klamrowe.
if(x >= 50)
System.out.println(">= 50");
else
System.out.println("< 50");
// Używajmy tego jednak z umiarem, tylko w bardzo prostych przypadkach, np. break, throw, return...
// W większości przypadków zalecane jest wzięcie wykonywanego kodu w {nawiasy klamrowe},
// gdyż łatwiej dokonać późniejszych zmian, np. dodać kolejną linię itp...
/* Za instrukcją strukturalną (if, while, for...) w praktyce nigdy nie stawia się średnika
if(x == y); {
System.out.println("Obie liczby są równe!");
}
Powyższy kod zawsze wyświetliłby podany napis, bo struktiura jest taka:
"jeśli x == y, nie rób nic; a później ZAWSZE wypisuj ten tekst"
*/
// Można użyć samego if, bez else:
if(x + y >= 100) {
System.out.println("suma x i y jest trzycyfrowa");
}
// ify (i inne instrukcje blokowe) można zagnieżdżać. Tutaj tym bardziej zalecamy pisanie nawiasów {}
if(x % 2 == 0) {
if(y % 2 == 0) {
System.out.println("obie liczby są parzyste");
} else {
System.out.println("x parzysty, y nieparzysty");
}
} else {
if(y % 2 == 0) {
System.out.println("x nieparzysty, y parzysty");
} else {
System.out.println("obie liczby nieparzyste");
}
}
System.out.println();
// Jeśli rozpatrywanych sytuacji jest więcej niż 2, to typowym sposobem zapisu jest ciąg
// if - else if - ... - else
if(x > y) {
System.out.println("x > y");
} else if(x < y) {
System.out.println("x < y");
} else {
System.out.println("x = y");
}
// W Javie nie ma automatycznej konwersji liczb (ani innych rzeczy) na boolean
// if(liczba) {
// System.out.println("Nie zero");
// }
//
// if(liczba = 0) {
// System.out.println("Nie zero");
// }
// Warunkiem najczęściej jest porównanie, ale może też być wywołanie metody typu boolean
String str = "Ala ma kota";
if(str.isEmpty()) {
System.out.println("puste");
}
// może też być bezpośrednie użycie zmiennej typu boolean
boolean logika = x > 10 && y % 3 == 0;
if(logika) {
System.out.println("Dziwny warunek jest prawdą");
} else {
System.out.println("Nieprawda");
}
System.out.println("Koniec programu");
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/Parkomat.java 0 → 100644
package p04_instrukcje;
import java.util.Scanner;
/* Parkowanie kosztuje 3 zł za godzinę.
Program pyta o liczbę godzin parkowania i na tej podstawie oblicza kwotę do zapłaty.
Następnie W PĘTLI:
- program wypisuje ile pozostało do zapłaty
- program prosi o wrzucenie kolejnej monety
aż zostanie wpłacona wymagana suma.
Jeśli należy się reszta, to program wypisuje ile reszty wydaje.
*/
public class Parkomat {
public static void main(String[] args) {
final int cena = 3;
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj liczbę godzin parkowania: ");
int ileGodzin = scanner.nextInt();
int doZaplaty = ileGodzin * cena;
int sumaWplat = 0;
while (sumaWplat < doZaplaty) {
System.out.println("Wpłacono " + sumaWplat + ", do zapłaty pozostało " + (sumaWplat - doZaplaty));
System.out.print("Wrzuć monetę: ");
sumaWplat += scanner.nextInt();
}
if(sumaWplat > doZaplaty) {
System.out.println("Reszta: " + (doZaplaty - sumaWplat));
}
System.out.println("Do widzenia");
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/PetlaNieskonczona.java 0 → 100644
package p04_instrukcje;
import java.time.LocalTime;
public class PetlaNieskonczona {
public static void main(String[] args) {
int licznik = 0;
while(true) {
System.out.printf("%12d : %s%n", ++licznik, LocalTime.now());
}
// Kod w tym miejscu jest niepoprawny (Java go nie skompiluje), bo to jest "martwy kod".
// System.out.println("Koniec świata");
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/PetleTeoria.java 0 → 100644
package p04_instrukcje;
public class PetleTeoria {
public static void petlaWhile() {
int i = 1;
while(i <= 5) {
System.out.println("w pętli: " + i);
i++;
}
System.out.println("za pętlą: " + i);
}
public static void doWhile() {
int i = 1;
do {
System.out.println("w pętli: " + i);
i++;
} while(i <= 5);
System.out.println("za pętlą: " + i);
}
// ominięte w main
public static void petlaFor() {
for(int i = 1; i <= 5; i++) {
System.out.println("w pętli " + i);
}
// NK System.out.println("za pętlą: " + i);
int i; // OK
}
public static void petlaFor2() {
int i;
for(i = 1; i <= 5; i++) {
System.out.println("w pętli " + i);
}
System.out.println("za pętlą: " + i); // 6
// NK int i;
}
// ominięte w main
public static void petlaFor3() {
// int i;
for(int i = 1, j = 10; i <= 5 && j < 3; i++, j = i / 10, System.out.println("z pętli " + j)) {
System.out.println("w pętli " + i);
}
// System.out.println("za pętlą: " + i);
}
// ominięte w main
// w for moga byc dowolne instrukcje
public static void petlaFor4(org.w3c.dom.Node node) {
for(org.w3c.dom.Node child = node.getFirstChild(); child != null; child = child.getNextSibling()) {
System.out.println(child.getTextContent());
}
}
public static void losowanie() {
for(;;) {
double x = Math.random();
System.out.println("Wylosowałem " + x);
if(x > 0.8)
break;
}
System.out.println("za pętlą");
}
public static void forEach() {
String[] imiona = { "Ala", "Ola", "Ela", "Ula" };
// pozwala przeglądać zawartość tablicy, albo obiekty, które są Iterable
// tzw. "for-each" albo "enhanced for loop", od Javy 5
for(String imie: imiona) {
System.out.println("Kolejna osoba to " + imie);
}
// Od Javy 10 można tak:
// for(var imie : imiona) {
// System.out.println("Kolejna osoba to " + imie);
// }
}
public static void forEachEgzamin() {
// typowa zmyłka z egzaminu
int[] t = { 1, 2, 3 };
for(int i: t) {
// i oznacza WARTOŚĆ z tablicy, a nie indeks
// więc tu dojdzie do wyjścia poza zakres tablicy
System.out.println(t[i]);
}
}
public static void przerwanie() {
for(int i = 1; i <= 10; i++) {
System.out.println("i = " + i);
if(i % 2 == 1) {
System.out.println(" nieparzysta, continue");
continue;
}
System.out.println(" nie było continue");
if(i % 3 == 0) {
System.out.println(" podzielna przed 3, break");
break;
}
System.out.println(" nie było break");
}
System.out.println("za pętlą");
}
public static int etykiety() {
int suma = 0;
duza: while(true) {
for(int i = 1; i < 10; i++) {
suma += i;
if(suma > 100)
break duza;
}
}
return suma;
}
public static void main(String[] args) {
etykieta: // kompiluje się, ale nie ma jak tego użyć
System.out.println("while");
petlaWhile();
//NK goto etykieta;
System.out.println("\ndo-while");
doWhile();
System.out.println("\nfor");
petlaFor2();
System.out.println("\nLosowanie:");
losowanie();
System.out.println("\nfor-each");
forEach();
System.out.println();
przerwanie();
System.out.println();
int x = etykiety();
System.out.println(x);
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/Petle_BreakContinue.java 0 → 100644
package p04_instrukcje;
import javax.swing.JOptionPane;
public class Petle_BreakContinue {
public static void main(String[] args) {
int licznik = 0;
while(true) {
licznik++;
JOptionPane.showInternalMessageDialog(null, "Początek pętli, licznik = " + licznik);
int odp1 = JOptionPane.showConfirmDialog(null, "Czy zrobić break?");
if(odp1 == JOptionPane.YES_OPTION) {
break;
// break w pętli powoduje natychmiastowe zakończenie tej pętli i przejście do następnej instrukcji za pętlą
}
JOptionPane.showInternalMessageDialog(null, "Środek pętli. Nie było break.");
int odp2 = JOptionPane.showConfirmDialog(null, "Czy zrobić continue?");
if(odp2 == JOptionPane.YES_OPTION) {
continue;
// continue powoduje pominięcie reszty instrukcji w bieżącym obrocie pętli
// i przejście od razu na początek następnego obrotu
}
JOptionPane.showInternalMessageDialog(null, "Koniec pętli, nie było break ani continue");
}
JOptionPane.showInternalMessageDialog(null, "Koniec programu");
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/Przerwania.java 0 → 100644
package p04_instrukcje;
public class Przerwania {
static void tabliczka(int n) {
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
System.out.printf("%3d", i * j);
System.out.print(",");
}
System.out.println("#");
}
System.out.println("\n----------------\n");
}
static void tabliczkaBreak(int n) {
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
System.out.printf("%3d", i * j);
if(i + j > n)
break;
System.out.print(",");
}
System.out.println("#");
}
System.out.println("\n----------------\n");
}
static void tabliczkaBreakEtykieta(int n) {
pierwsza: for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
System.out.printf("%3d", i * j);
if(i + j > n)
break pierwsza;
System.out.print(",");
}
System.out.println("#");
}
System.out.println("\n----------------\n");
}
static void tabliczkaContinue(int n) {
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
System.out.printf("%3d", i * j);
if(i + j > n)
continue;
System.out.print(",");
}
System.out.println("#");
}
System.out.println("\n----------------\n");
}
static void tabliczkaContinueEtykieta(int n) {
pierwsza: for(int i = 1; i <= n; i++) {
System.out.println(); // dodane
for(int j = 1; j <= n; j++) {
System.out.printf("%3d", i * j);
if(i + j > n)
continue pierwsza;
System.out.print(",");
}
System.out.println("#");
}
System.out.println("\n----------------\n");
}
public static void main(String[] args) {
tabliczka(9);
tabliczkaBreak(9);
tabliczkaBreakEtykieta(9);
tabliczkaContinue(9);
tabliczkaContinueEtykieta(9);
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/SpojnikiLogiczne.java 0 → 100644
package p04_instrukcje;
import java.util.Random;
public class SpojnikiLogiczne {
public static void main(String[] args) {
Random random = new Random();
int x = random.nextInt(20);
int y = random.nextInt(20);
System.out.println("x = " + x + " , y = " + y);
// && - koniunkcja, "i", "and"
// warunek jest prawdziwy tylko gdy obie części są prawdziwe
if(x >= 10 && y >= 10) {
System.out.println("AAA obie liczby są dwucyfrowe");
} else {
System.out.println("BBB nieprawda, że obie na raz są dwucyfrowe");
}
// || - alternatywa, "lub", "or"
// warunek jest prawdziwy gdy co najmniej jedna część jest prawdziwa
if(x >= 10 || y >= 10) {
System.out.println("CCC któraś z liczb jest dwucyfrowa");
} else {
System.out.println("DDD obie liczby są jednocyfrowe");
}
// Istnieje też ^ - to jest alternatywa rozłączna, tzw. "xor",
// Jest prawdą, gdy dokładnie jedna z części jest prawdą.
// Inaczej mówiąc ^ sprawdza czy warunki składowe dają różne wyniki.
// W praktyce nieużywane
if(x >= 10 ^ y >= 10) {
System.out.println("EEE tylko jedna z liczb jest dwucyfrowa");
} else {
System.out.println("FFF warunki są jednakowe dla obu liczb");
}
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/TabliczkaMnozenia.java 0 → 100644
package p04_instrukcje;
public class TabliczkaMnozenia {
public static void main(String[] args) {
for (int w = 1; w <= 10; w++) {
for (int k = 1; k <= 10; k++) {
// System.out.print(w*k + " ");
System.out.printf("%3d ", w*k);
}
System.out.println();
}
}
}
PC21-JavaUzupelnienia/src/p04_instrukcje/TabliczkaMnozeniaCustom.java 0 → 100644
package p04_instrukcje;
import java.util.Scanner;
public class TabliczkaMnozeniaCustom {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj liczbę wierszy: ");
final int W = scanner.nextInt();
System.out.print("Podaj liczbę kolumn: ");
final int K = scanner.nextInt();
// ustalamy długość tekstowej reprezentacji liczby i dodajemy jeszcze 1
final int szer = String.valueOf(W*K).length() + 1;
// taki wzorzec formatu ma być przekazany do printf.
// lepiej utworzyć go tutaj jeden raz, a nie za każdym razem w pętli
final String format = "%" + szer + "d";
for(int w = 1; w <= W; w++) {
for(int k = 1; k <= K; k++) {
System.out.printf(format, w*k);
}
System.out.println();
}
}
}
PC21-JavaUzupelnienia/src/p05_switch/DzienTygodnia0.java 0 → 100644
package p05_switch;
import javax.swing.JOptionPane;
public class DzienTygodnia0 {
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia [1-7]"));
// na podstawie podanego numeru wyświetl jaki to dzień
if(numer == 1) {
JOptionPane.showMessageDialog(null, "To jest poniedziałek");
} else if(numer == 2) {
JOptionPane.showMessageDialog(null, "To jest wtorek");
} else if(numer == 3) {
JOptionPane.showMessageDialog(null, "To jest środa");
} else if(numer == 4) {
JOptionPane.showMessageDialog(null, "To jest czwartek");
} else if(numer == 5) {
JOptionPane.showMessageDialog(null, "To jest piątek");
JOptionPane.showMessageDialog(null, "weekendu początek");
} else if(numer == 6) {
JOptionPane.showMessageDialog(null, "To jest sobota");
} else if(numer == 7) {
JOptionPane.showMessageDialog(null, "To jest niedziela");
} else {
JOptionPane.showMessageDialog(null, "Niepoprawny numer", "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
PC21-JavaUzupelnienia/src/p05_switch/DzienTygodnia1.java 0 → 100644
package p05_switch;
import javax.swing.JOptionPane;
public class DzienTygodnia1 {
/* switch przechodzi do tego case, którego wartość została przekazana w parametrze
* i od tego miejsca kontynuuje wykonanie do samego końca albo do napotkania instrukcji break (która powoduje wyjście ze switcha)
*
* W tej wersji pomiędzy case'ami nie ma breaków, dlatego wykonują się dalsze instrukcje aż do końca.
*/
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia [1-7]"));
switch(numer) {
case 1:
JOptionPane.showMessageDialog(null, "To jest poniedziałek");
case 2:
JOptionPane.showMessageDialog(null, "To jest wtorek");
case 3:
JOptionPane.showMessageDialog(null, "To jest środa");
case 4:
JOptionPane.showMessageDialog(null, "To jest czwartek");
case 5:
JOptionPane.showMessageDialog(null, "To jest piątek");
JOptionPane.showMessageDialog(null, "weekendu początek");
case 6:
JOptionPane.showMessageDialog(null, "To jest sobota");
case 7:
JOptionPane.showMessageDialog(null, "To jest niedziela");
default:
JOptionPane.showMessageDialog(null, "Niepoprawny numer", "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
PC21-JavaUzupelnienia/src/p05_switch/DzienTygodnia2.java 0 → 100644
package p05_switch;
import javax.swing.*;
public class DzienTygodnia2 {
/* Ta wersja pokazuje najbardziej klasyczny zapis switch, jaki działa w Javie od samego początku.
* Tak samo jest też w C, C++.
*/
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia [1-7]"));
switch (numer) {
case 1:
JOptionPane.showMessageDialog(null, "To jest poniedziałek");
break;
case 2:
JOptionPane.showMessageDialog(null, "To jest wtorek");
break;
case 3:
JOptionPane.showMessageDialog(null, "To jest środa");
break;
case 4:
JOptionPane.showMessageDialog(null, "To jest czwartek");
break;
case 5:
JOptionPane.showMessageDialog(null, "To jest piątek");
JOptionPane.showMessageDialog(null, "weekendu początek");
break;
case 6:
JOptionPane.showMessageDialog(null, "To jest sobota");
break;
case 7:
JOptionPane.showMessageDialog(null, "To jest niedziela");
break;
default:
JOptionPane.showMessageDialog(null, "Niepoprawny numer", "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
PC21-JavaUzupelnienia/src/p05_switch/DzienTygodnia3.java 0 → 100644
package p05_switch;
import javax.swing.*;
/* W tej wersji używamy notacji -> (zamiast :), w której wykonywany jest na pewno tylko jeden case,
* bez potrzeby pisania break.
* Za strzałką może być albo jedna instrukcja; albo {blok}
* Taka pojawiła się w Javie 14.
*/
public class DzienTygodnia3 {
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia [1-7]"));
switch (numer) {
case 1 ->
JOptionPane.showMessageDialog(null, "To jest poniedziałek");
case 2 ->
JOptionPane.showMessageDialog(null, "To jest wtorek");
case 3 ->
JOptionPane.showMessageDialog(null, "To jest środa");
case 4 ->
JOptionPane.showMessageDialog(null, "To jest czwartek");
case 5 -> {
JOptionPane.showMessageDialog(null, "To jest piątek");
JOptionPane.showMessageDialog(null, "weekendu początek");
}
case 6 ->
JOptionPane.showMessageDialog(null, "To jest sobota");
case 7 ->
JOptionPane.showMessageDialog(null, "To jest niedziela");
default ->
JOptionPane.showMessageDialog(null, "Niepoprawny numer", "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
PC21-JavaUzupelnienia/src/p05_switch/DzienTygodnia4.java 0 → 100644
package p05_switch;
import javax.swing.*;
public class DzienTygodnia4 {
static String nazwaDnia(int numer) {
switch (numer) {
case 1: return "poniedziałek";
case 2: return "wtorek";
case 3: return "środa";
case 4: return "czwartek";
case 5: return "piątek";
case 6: return "sobota";
case 7: return "niedziela";
default: throw new IllegalArgumentException("Nieznany numer " + numer);
}
}
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia [1-7]"));
try {
String nazwa = nazwaDnia(numer);
JOptionPane.showMessageDialog(null, "To jest " + nazwa);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e, "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
PC21-JavaUzupelnienia/src/p05_switch/DzienTygodnia5.java 0 → 100644
package p05_switch;
import javax.swing.*;
// W tej wersji korzystamy z możliwości Java 14: "switch expression".
// switch zwraca wynik, który przechwytujemy i (w tym programie) zapisujemy do zmiennej.
// Tutaj widzimy najprostsze podejście: po prawej stronie strzałek są po prostu wartości wynikowe.
// Wersja bardziej rozbudowana: IleDniMaMiesiac5
public class DzienTygodnia5 {
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia [1-7]"));
try {
String nazwa = switch (numer) {
case 1 -> "poniedziałek";
case 2 -> "wtorek";
case 3 -> "środa";
case 4 -> "czwartek";
case 5 -> "piątek";
case 6 -> "sobota";
case 7 -> "niedziela";
default -> throw new IllegalArgumentException("Nieznany numer " + numer);
};
JOptionPane.showMessageDialog(null, "To jest " + nazwa);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e, "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
PC21-JavaUzupelnienia/src/p05_switch/IleDniMaMiesiac1.java 0 → 100644
package p05_switch;
import javax.swing.*;
// klasyczny sposób grupowanie case'ów - napisz kilka casów jeden za drugim i dla nich wszystkich zrób jedną wspólną obsługą
public class IleDniMaMiesiac1 {
public static void main(String[] args) {
String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
// Wypisz ile dni ma ten miesiąc (28 / 29 / 30 / 31)
switch (miesiac) {
case "styczeń":
case "marzec":
case "maj":
case "lipiec":
case "sierpień":
case "październik":
case "grudzień":
JOptionPane.showMessageDialog(null, miesiac + " ma 31 dni");
break;
case "kwiecień":
case "czerwiec":
case "wrzesień":
case "listopad":
JOptionPane.showMessageDialog(null, miesiac + " ma 30 dni");
break;
case "luty":
int rok = Integer.parseInt(JOptionPane.showInputDialog("O który rok chodzi?"));
if (rok % 4 == 0 && rok % 100 != 0 || rok % 400 == 0) {
JOptionPane.showMessageDialog(null, miesiac + " ma 29 dni");
} else {
JOptionPane.showMessageDialog(null, miesiac + " ma 28 dni");
}
break;
default:
JOptionPane.showMessageDialog(null, "Nie znam takiego miesiąca: " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
}
}
}
PC21-JavaUzupelnienia/src/p05_switch/IleDniMaMiesiac2.java 0 → 100644
package p05_switch;
import javax.swing.*;
public class IleDniMaMiesiac2 {
public static void main(String[] args) {
String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
switch (miesiac) {
case "styczeń", "marzec", "maj", "lipiec", "sierpień", "październik", "grudzień" ->
JOptionPane.showMessageDialog(null, miesiac + " ma 31 dni");
case "kwiecień", "czerwiec", "wrzesień", "listopad" ->
JOptionPane.showMessageDialog(null, miesiac + " ma 30 dni");
case "luty" -> {
int rok = Integer.parseInt(JOptionPane.showInputDialog("O który rok chodzi?"));
if (rok % 4 == 0 && rok % 100 != 0 || rok % 400 == 0) {
JOptionPane.showMessageDialog(null, miesiac + " ma 29 dni");
} else {
JOptionPane.showMessageDialog(null, miesiac + " ma 28 dni");
}
}
default ->
JOptionPane.showMessageDialog(null, "Nie znam takiego miesiąca: " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
}
}
}
PC21-JavaUzupelnienia/src/p05_switch/IleDniMaMiesiac5.java 0 → 100644
package p05_switch;
import javax.swing.*;
public class IleDniMaMiesiac5 {
public static void main(String[] args) {
try {
String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
int ileDni = switch (miesiac) {
case "styczeń", "marzec", "maj", "lipiec", "sierpień", "październik", "grudzień" -> 31;
case "kwiecień", "czerwiec", "wrzesień", "listopad" -> 30;
case "luty" -> {
int rok = Integer.parseInt(JOptionPane.showInputDialog("O który rok chodzi?"));
if (rok % 4 == 0 && rok % 100 != 0 || rok % 400 == 0) {
yield 29;
} else {
yield 28;
}
}
default -> throw new IllegalArgumentException("Nieznany miesiąc " + miesiac);
};
JOptionPane.showMessageDialog(null, miesiac + " ma " + ileDni + " dni");
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e, "Błąd", JOptionPane.ERROR_MESSAGE);
}
}
}
PC21-JavaUzupelnienia/src/p06_klasy_i_metody_wprowadzenie/Klasa.java 0 → 100644
package p06_klasy_i_metody_wprowadzenie;
public class Klasa {
// w klasie można definiować:
// * pola (field), inaczej: zmienne instancyjne (instance variable), atrybuty
// każdy obiekt tej klasy będzie zawierał takie dane
String imie;
int liczba;
// * zmienne statyczne / zmienne klasowe
static int statyczna = 100;
// metoda, czyli fragment programu, któremu nadajemy nazwę, może mieć parametry, może dawać wynik
// metoda bez słowa "static" to metoda "instancyjna"
// można ją wywołać poprzez obiekt, ma dostęp do pól obiektu
void metodaZwykla() {
System.out.println("Jestem zwykłą metodą i widzę zmienne");
System.out.println("imie = " + imie + ", liczba = " + liczba + ", statyczna = " + statyczna);
}
// metoda statyczna jest czymś takim, jak funkcja w innych językach programowania
// ma dostęp do zmiennych statycznych, ale nie do instancyjncyh, bo "nie wiemy na jakim obiekcie mamy działać"
static void metodaStatyczna() {
System.out.println("Jestem metodą statyczną i widzę zmienne tylko statyczne");
System.out.println(statyczna++);
// System.out.println(imie);
// System.out.println(this.imie);
}
}
PC21-JavaUzupelnienia/src/p06_klasy_i_metody_wprowadzenie/Przyklad.java 0 → 100644
package p06_klasy_i_metody_wprowadzenie;
public class Przyklad {
public static void main(String[] args) {
// Nie można odwołać się do pól instancyjnych poprzez nazwę klasy
// System.out.println(Klasa.imie);
// Można do zmiennej statycznej:
System.out.println(Klasa.statyczna++);
// Tworzenie obiektu (aka "instancji"):
Klasa obiekt = new Klasa();
// W obiekcie znajdują się pola. Początkowe wartości: null, 0, false
System.out.println(obiekt.imie + " " + obiekt.liczba);
obiekt.imie = "Adam";
obiekt.liczba = 30;
System.out.println(obiekt.imie + " " + obiekt.liczba);
// Do zmienne jstatycznej można dostać się poprzez obiekt, ale jest to niezalecany zapis
System.out.println(obiekt.statyczna);
System.out.println();
obiekt.metodaZwykla();
}
}
PC21-JavaUzupelnienia/src/p07_funkcje/FunkcjeGeometryczne.java 0 → 100644
package p07_funkcje;
// Komentarz pisany w znacznikach /** */
// pełni rolę dokumentacji, tzw "javadoc".
/**
* @author patryk
*
* To jest przykład klasy, w której nie ma metody main, tylko są zdefiniowane inne metody.
* "klasa narzędziowa" / "utility class"
* Tutaj są to funkcje matematyczne dot. geometrii szkolnej.
*/
public class FunkcjeGeometryczne {
// 4 poziomy dostepu (widoczności): private, pakietowy (domyślny, nie pisze się nic), protected, public
/** Funkcja oblicza pole kwadratu.
* @param a długość boku
* @return pole kwadratu
*/
public static double poleKwadratu(double a) {
return a*a;
}
/** Oblicza obwód kwadratu o podanym boku.
* @param a długość boku
* @return obliczony obwód kwadratu
*/
public static double obwodKwadratu(double a) {
return 4*a;
}
/** Oblicza pole prostokąta o podanych bokach.
* @param a długość pierwszego boku
* @param b długość drugiego boku
* @return obliczone pole prostokąta
*/
public static double poleProstokata(double a, double b) {
return a*b;
}
public static double obwodProstokata(double a, double b) {
return 2*a + 2*b;
}
public static double poleKola(double r) {
return Math.PI * r * r;
}
public static double obwodKola(double r) {
return Math.PI * 2 * r;
}
}
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