Skip to content

2
20250520
Commit a7ca54dc by Patryk Czarnik
Options

Przykłady stream

parent 5effa2ec
Showing with 4083 additions and 3 deletions
liczby1.txt 0 → 100644
This diff is collapsed. Click to expand it.
src/emps/v2_obiektowo/Samochod.java 0 → 100644
package emps.v2_obiektowo;
public class Samochod {
private String marka, model;
private String nrRejstracyjny;
private double moc;
public Samochod(String marka, String model, String nrRejstracyjny, double moc) {
this.marka = marka;
this.model = model;
this.nrRejstracyjny = nrRejstracyjny;
this.moc = moc;
}
@Override
public String toString() {
return "Samochod [marka=" + marka + ", model=" + model + ", nrRejstracyjny=" + nrRejstracyjny + ", moc=" + moc + "]";
}
public String getMarka() {
return marka;
}
public void setMarka(String marka) {
this.marka = marka;
}
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
public String getNrRejstracyjny() {
return nrRejstracyjny;
}
public void setNrRejstracyjny(String nrRejstracyjny) {
this.nrRejstracyjny = nrRejstracyjny;
}
public double getMoc() {
return moc;
}
public void setMoc(double moc) {
this.moc = moc;
}
}
// Lombok - biblioteka, która automatycznie generuje gettery itd na podstawie adnotacji
src/emps/v3_funkcyjnie/CzegoSieNieDaWLambdach.java 0 → 100644
package emps.v3_funkcyjnie;
import java.io.FileNotFoundException;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class CzegoSieNieDaWLambdach {
static int sumaStatyczna = 0;
public static void main(String[] args) throws FileNotFoundException {
List<Employee> emps = ObslugaCSV.wczytaj();
// czy damy radę obliczyć sumę pensji za pomocą tego nowego forEach?
int sumaLokalna = 0;
int[] tablica = {0};
AtomicInteger ai = new AtomicInteger();
emps.forEach(emp -> {
// wewnątrz wyrażeń lambda nie wolno modyfikować zmiennych lokalnych
// zdefiniowanych przed tym wyrażeniem
// ograniczenie "effectively final"
// sumaLokalna += emp.getSalary();
// bardzo brzydkie, ale działa:
sumaStatyczna += emp.getSalary();
tablica[0] += emp.getSalary();
// ai.incrementAndGet(); // ++
ai.addAndGet(emp.getSalary()); // +=
});
System.out.println(sumaLokalna);
System.out.println(sumaStatyczna);
System.out.println(tablica[0]);
System.out.println(ai);
System.out.println();
// właściwe podejście w stylu funkcyjnym:
int suma = emps.stream().mapToInt(Employee::getSalary).sum();
System.out.println(suma);
}
}
src/emps/v3_funkcyjnie/DaneOpcjonalne.java 0 → 100644
package emps.v3_funkcyjnie;
import java.io.FileNotFoundException;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.Scanner;
public class DaneOpcjonalne {
public static void main(String[] args) throws FileNotFoundException {
// Użytkownik podaje nazwę miasta, a program filtruje dane wczytane z pliku
// i oblicza średnią pensję oraz znajduje najbogatszego i najbiedniejszego pracownika.
// Przykład ma pokazać, jak można wykorzystać wyniki typu Optional.
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj nazwę miasta: ");
String miasto = scanner.nextLine();
List<Employee> emps = ObslugaCSV.wczytaj();
OptionalDouble srednia = emps.stream()
.filter(emp -> emp.getCity().equals(miasto))
.mapToInt(Employee::getSalary)
.average();
Optional<Employee> min = emps.stream()
.filter(emp -> emp.getCity().equals(miasto))
.min(Comparator.comparingInt(Employee::getSalary));
Optional<Employee> max = emps.stream()
.filter(emp -> emp.getCity().equals(miasto))
.max(Comparator.comparingInt(Employee::getSalary));
System.out.println("średnia" + srednia);
System.out.println("min: " + min);
System.out.println("max: " + max);
System.out.println();
// Za pomocą isPresent / isEmpty można sprawdzać, czy obiekt zawiera wartość
if(srednia.isPresent()) {
// aby wydobyć liczbę z obiektu, piszemy getAsDouble (w przypadku pustego Optionala kończy się to błędem)
System.out.println("Średnia pensja = " + srednia.getAsDouble());
} else {
System.out.println("Brak danych");
}
System.out.println();
if(min.isPresent()) {
// aby dostać się do obiektu wewnątrz Optionala, piszemy get(); w razie braku danych powoduje to błąd
Employee emp = min.get();
System.out.println("Najbiedniejszy: " + emp.getFirstName() + " " + emp.getLastName() + " z pensją " + emp.getSalary());
} else {
System.out.println("Brak danych");
}
if(max.isEmpty()) {
System.out.println("Brak danych");
} else {
Employee emp = max.get();
System.out.println("Najbogatszy: " + emp.getFirstName() + " " + emp.getLastName() + " z pensją " + emp.getSalary());
}
System.out.println();
// Operacja orElse zwraca wartość z wnętrza Optionala, a w razie braku danych zwraca wartość alternatywną podaną w nawiasach
System.out.println("srednia.orElse(0) = " + srednia.orElse(0));
System.out.println("srednia.orElse(NaN) = " + srednia.orElse(Double.NaN));
// W przypadku obiektów użycie orElse wymagałoby posiadania "domyślnego pracownika", ew. można wstawić nulla
Employee fejkowy = new Employee(0, "Fejkowy", "Pracownik", "nikt", -1, null, "", "", "", "", "nieznany kraj");
System.out.println("najbiedniejszy lub zmyślony:");
System.out.println(min.orElse(fejkowy));
System.out.println("najbogatszy lub null:");
System.out.println(max.orElse(null));
System.out.println();
// Domyślnym wyjątkiem wyrzucanym w razie braku danych gdy robimy get jest NoSuchElementException
// System.out.println("Najbogatsza osoba to " + max.get().getLastName());
// ale możemy wyrzuć własny dedykowany wyjątek
// Podajemy to w formie lambdy, aby kod tworzący wyjątek został wykonany tylko wtedy, gdy jest naprawdę potrzebny
// String nazwisko = max.orElseThrow(() -> new RuntimeException("wielka bieda")).getLastName();
// System.out.println("Najbogatsza osoba to " + nazwisko);
// Na obiektach Optional (i w mniejszym stoniu na ich wersjach liczbowych) można wykonywać operacje
// przypominające operacje na strumieniach.
// Operacja map z Optionala jednego typu jest w stanie utworzyc Optional innego typu
// Na podstawie Optional<Employee> utworzymy Optional<String> zawierający dane pracownika
Optional<String> minTXT = min.map(emp -> "Najbiednieszy jest " + emp.getFirstName() + " " + emp.getLastName());
// Jeśli min był pusty, to minTXT też będzie pusty
// Jeśli min zawierał dane pracownika, to minTXT będzie zawierał tekst z imieniem i nazwiskiem pracownika
System.out.println("Optional<String>: " + minTXT);
// Można to wykorzystać w zapisie typu pipeline w taki sposób:
String maxTXT = emps.stream()
.filter(emp -> emp.getCity().equals(miasto))
.max(Comparator.comparingInt(Employee::getSalary))
.map(emp -> "Najbogatszy jest " + emp.getFirstName() + " " + emp.getLastName())
.orElse("Brak danych najbogatszego");
System.out.println("maxTXT: " + maxTXT);
// czasami może się zdarzyć, że wartość alternatywna jest obliczana w trakcie działania programu
// aby uniknąć niepotrzebnego obliczania (aby robić to tylko w przypadku braku danych), można podać wyrażenie lambda tworzące ten wynik
String maxTXT2 = emps.stream()
.filter(emp -> emp.getCity().equals(miasto))
.max(Comparator.comparingInt(Employee::getSalary))
.map(emp -> "Najbogatszy jest " + emp.getFirstName() + " " + emp.getLastName())
.orElseGet(() -> "Brak najbogatszego w mieście " + miasto);
System.out.println("maxTXT2: " + maxTXT2);
// Można też podać akcję, która zostanie wykonana tylko, gdy optional nie jest pusty
min.ifPresent(emp -> System.out.println("Znaleziony najbiedniejszy pracownik! - " + emp.getFirstName() + " " + emp.getLastName()));
// wersja z else (co zrobić w razie braku danych)
max.ifPresentOrElse(
emp -> System.out.println("Znaleziony najbogatszy pracownik! - " + emp.getFirstName() + " " + emp.getLastName()),
() -> System.out.println("Nie znaleziomo najbogatszego!"));
// oczywiście można to zastosować na końcu pipeline
emps.stream()
.filter(emp -> emp.getCity().equals(miasto))
.mapToInt(Employee::getSalary)
.average()
.ifPresentOrElse(
avg -> System.out.println("Jest średnia " + avg),
() -> System.out.println("Nie ma średniej"));
}
}
src/emps/v3_funkcyjnie/Employee.java 0 → 100644
package emps.v3_funkcyjnie;
import java.time.LocalDate;
import java.util.Objects;
public class Employee {
private int employeeId;
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 employeeId, String firstName, String lastName, String jobTitle, int salary, LocalDate hireDate,
String departmentName, String address, String postalCode, String city, String country) {
this.employeeId = employeeId;
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 getEmployeeId() {
return employeeId;
}
public void setEmployeeId(int employeeId) {
this.employeeId = employeeId;
}
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 String toString() {
return "Employee [employeeId=" + employeeId + ", firstName=" + firstName + ", lastName=" + lastName
+ ", jobTitle=" + jobTitle + ", salary=" + salary + ", hireDate=" + hireDate + ", departmentName="
+ departmentName + ", address=" + address + ", postalCode=" + postalCode + ", city=" + city
+ ", country=" + country + "]";
}
@Override
public int hashCode() {
return Objects.hash(address, city, country, departmentName, employeeId, firstName, hireDate, jobTitle, lastName,
postalCode, salary);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Employee other = (Employee) obj;
return Objects.equals(address, other.address) && Objects.equals(city, other.city)
&& Objects.equals(country, other.country) && Objects.equals(departmentName, other.departmentName)
&& employeeId == other.employeeId && Objects.equals(firstName, other.firstName)
&& Objects.equals(hireDate, other.hireDate) && Objects.equals(jobTitle, other.jobTitle)
&& Objects.equals(lastName, other.lastName) && Objects.equals(postalCode, other.postalCode)
&& salary == other.salary;
}
}
src/emps/v3_funkcyjnie/F0_WypiszWszystko.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.List;
public class F0_WypiszWszystko {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
// Aby zrobić coś dla każdego elementu listy, np. wypisać na ekran,
// można użyć operacji forEach.
// Do forEach można przekazać wyrażenie lambda mówiące, co zrobić z każdym elementem.
// emps.forEach(emp -> System.out.println(emp));
// W przypadku, gdy operacja sprowadza się do wywołania konkretnej metody, można użyć notacji "method reference".
emps.forEach(System.out::println);
// Można też najpierw pobrać "strumień" i dopiero na strumienia wywołać forEach, ale tu nie jest to konieczne.
// emps.stream().forEach(System.out::println);
}
}
src/emps/v3_funkcyjnie/F1_WypiszDane.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.List;
public class F1_WypiszDane {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
// Cel: wypisać wybrane pola.
// Sposób 1: w wyrażeniu lambda napisać printa, który wypisuje wybrane rzeczy
// emps.forEach(emp -> System.out.println(emp.getFirstName() + " " + emp.getLastName() + " " + emp.getSalary()));
// Sposób 2, oparty o stream: najpierw mapujemy obiekty Employee na Stringi, a następnie wypisujemy te Stringi
emps.stream()
.map(emp -> emp.getFirstName() + " " + emp.getLastName() + " " + emp.getSalary())
.forEach(System.out::println);
}
}
src/emps/v3_funkcyjnie/F2_Filtrowanie.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.Comparator;
import java.util.List;
public class F2_Filtrowanie {
// Program wypisuje tylko zarabiających >= 10 tys,
// realizujemy to filtrowaniem, ale przy okazji pokazuję Wam schemat "filter / map" - podstawowe operacje na strumieniach.
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.stream()
.filter(emp -> emp.getSalary() >= 10_000)
.forEach(emp -> System.out.println(emp.getFirstName() + " " + emp.getLastName()));
System.out.println("\n-----------------------\n");
emps.stream()
.filter(emp -> emp.getSalary() <= 5000)
.sorted(Comparator.comparing(Employee::getSalary))
.map(emp -> emp.getFirstName() + " " + emp.getLastName() + " z pensją " + emp.getSalary())
.map(String::toUpperCase) // ew. .map(s -> s.toUpperCase())
.forEach(System.out::println);
// Cały ten ↑ zapis jest określany "pipeline", który składa się z:
// - źródła danych
// - dowolnej liczby operacji pośrednich (intermediate, tutaj są to filter i map)
// - operacji końcowej (terminal, tutaj jest to forEach)
// Każdy obiekt przechodzi przez kolejne etapy przetwarzania, "schodzi z góry w dół".
}
}
src/emps/v3_funkcyjnie/F3_SredniaWszystkich.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.List;
import java.util.OptionalDouble;
import java.util.stream.Collectors;
public class F3_SredniaWszystkich {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
/*
// Uwaga, to nie zadziała; to nie tak się robi.
// Wewnątrz wyrażeń lambda nie wolno modyfikować zmiennych lokalnych zdefiniowanych na zewnątrz tych wyrażeń.
// (generalnie - nie wolno uzywać zmiennych, które nie są "effectively final"
double suma = 0;
int ile = 0;
emps.forEach(emp -> {
suma += emp.getSalary();
ile++;
});
*/
// Można użyć gotowych dedykowanych rozwiązań
// 1) IntStream (istnieją jeszcze LongStream oraz DoubleStream; nie istnieje FloatStream)
OptionalDouble srednia1 = emps.stream()
.mapToInt(Employee::getSalary)
.average();
System.out.println(srednia1);
// Gdyby strumień był pusty, to wynikiem byłby pusty Optional.
// Aby dostać się do samej liczby, najelepiej zrobić to tak (w razie braku danych podstawi 0):
double srednia2 = emps.stream()
.mapToInt(Employee::getSalary)
.average()
.orElse(0);
System.out.println(srednia2);
// 2) odpowiedni Collector, czyli taka maszynka, która zbiera dane i na końcu zwraca wynik
Double srednia3 = emps.stream().collect(Collectors.averagingInt(Employee::getSalary));
System.out.println(srednia3);
}
}
src/emps/v3_funkcyjnie/F4_SredniaJedenJob.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.List;
import java.util.OptionalDouble;
import javax.swing.JOptionPane;
public class F4_SredniaJedenJob {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
String szukanyJob = JOptionPane.showInputDialog("Podaj szukany job", "Programmer");
double srednia1 = emps.stream()
.filter(emp -> emp.getJobTitle().equalsIgnoreCase(szukanyJob))
.mapToInt(Employee::getSalary)
.average()
.orElse(0);
JOptionPane.showMessageDialog(null, "Wersja prosta: " + srednia1);
// Jeśli chcemy sprawdzić, czy zostało coś znalezione, możemy zapisać wynik jako OptionalDouble i sprawdzić ifem
OptionalDouble srednia2 = emps.stream()
.filter(emp -> emp.getJobTitle().equalsIgnoreCase(szukanyJob))
.mapToInt(Employee::getSalary)
.average();
if(srednia2.isPresent()) {
JOptionPane.showMessageDialog(null, String.format(
"Średnia pensja na stanowisku %s wynosi %.2f",
szukanyJob, srednia2.getAsDouble()));
} else {
JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
"Brak danych", JOptionPane.WARNING_MESSAGE);
}
}
}
src/emps/v3_funkcyjnie/F5_MiastaBezPowtorzen.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class F5_MiastaBezPowtorzen {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
// sposób 1: utworzyć zbiór Stringów
// ma to sens, gdy potrzebujemy wykorzystać te dane w dalszej części programu
Set<String> miasta = emps.stream()
.map(Employee::getCity)
.collect(Collectors.toSet());
System.out.println(miasta);
System.out.println("--------");
// sposób 2: w łańcuchu poleceń (pipeline) umieścić operację distinct
// ma to sens, gdy wykonujemy tylko jedną operację, np, chcemy tylko wypisać te miasta
emps.stream()
.map(Employee::getCity)
.filter(s -> !s.isEmpty())
// .filter(((Predicate<String>)String::isEmpty).negate())
.distinct()
//.sorted()
.forEach(System.out::println);
}
}
src/emps/v3_funkcyjnie/F6_MinMax.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.Comparator;
import java.util.List;
public class F6_MinMax {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
Comparator<Employee> waga = Comparator.comparingInt(Employee::getSalary);
// uwaga - tu trochę upraszczamy; zakładam, że dane w pliku na pewno są - inne wersje w przykładach Opcjonalne???
Employee min = emps.stream().min(waga).orElse(null);
Employee max = emps.stream().max(waga).orElse(null);
System.out.println("min: " + min);
System.out.println("max: " + max);
}
}
src/emps/v3_funkcyjnie/F7_Sortowanie.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.Comparator;
import java.util.List;
public class F7_Sortowanie {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
emps.stream()
.sorted(Comparator.comparingInt(Employee::getSalary).reversed())
.map(emp -> emp.getFirstName() + " " + emp.getLastName() + " " + emp.getSalary())
.forEach(System.out::println);
}
}
src/emps/v3_funkcyjnie/F7b_Sortowanie_WieleKryteriow.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.Comparator;
import java.util.List;
public class F7b_Sortowanie_WieleKryteriow {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
emps.stream()
.sorted(Comparator.comparing(Employee::getCity)
.thenComparing(Employee::getLastName)
.thenComparing(Employee::getFirstName))
.forEach(emp -> System.out.printf("%-15s %-15s %s%n",
emp.getFirstName(), emp.getLastName(), emp.getCity()));
}
}
src/emps/v3_funkcyjnie/F8_Partycje.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class F8_Partycje {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
// 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());
});
}
}
src/emps/v3_funkcyjnie/F9_Podwyzka.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.List;
public class F9_Podwyzka {
// Generalnie strumienie pozwalają nam na "odczyt", a nie służą modyfikacji listy / zbioru itp.
// Jeśli jednak obiekty zawarte w liście są "mutowalne", to za pośrednictwem strumienia MOŻNA zmodyfikować te obiekty.
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
emps.stream()
.filter(emp -> "Programmer".equals(emp.getJobTitle()))
.forEach(emp -> emp.setSalary(emp.getSalary() + 3333));
emps.forEach(emp -> System.out.println(emp.getFirstName() + " " + emp.getLastName() + " (" + emp.getJobTitle() + ") : " + emp.getSalary()));
ObslugaCSV.zapisz(emps, "zmodyfikowany2.csv");
}
}
src/emps/v3_funkcyjnie/Grupowanie7.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Grupowanie7 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Map<String, List<Employee>> grupy = emps.stream().collect(Collectors.groupingBy(Employee::getJobTitle));
// System.out.println(grupy);
grupy.forEach((job, lista) -> {
System.out.println("Stanowisko " + job + ":");
lista.forEach(emp -> {
System.out.println(" * " + emp.getFirstName() + " " + emp.getLastName() + " " + emp.getSalary());
});
System.out.println();
});
}
}
src/emps/v3_funkcyjnie/Grupowanie8.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Grupowanie8 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Map<String, Double> grupy = emps.stream()
.collect(Collectors.groupingBy(Employee::getJobTitle,
Collectors.averagingInt(Employee::getSalary)));
// System.out.println(grupy);
grupy.forEach((job, srednia) -> {
System.out.printf("%-32s → %8.2f%n", job, srednia);
});
}
}
src/emps/v3_funkcyjnie/Grupowanie9.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;
// W tej wersji dla każdej grupy od razu obliczymy "statystyki"
// Podajemy też konstruktor klasy TreeMap, aby został utworzony słownik tego typu
public class Grupowanie9 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj();
Map<String, IntSummaryStatistics> grupy = emps.stream()
.collect(Collectors.groupingBy(
Employee::getJobTitle,
TreeMap::new,
Collectors.summarizingInt(Employee::getSalary)));
grupy.forEach((job, stats) -> {
// System.out.printf("%-32s → %s%n", job, stats);
System.out.printf("| %-32s | %2d | %5d | %8.2f | %5d |%n",
job, stats.getCount(), stats.getMin(), stats.getAverage(), stats.getMax());
});
}
}
src/emps/v3_funkcyjnie/ObslugaCSV.java 0 → 100644
package emps.v3_funkcyjnie;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Stream;
public class ObslugaCSV {
public static List<Employee> wczytaj() {
// używa domyślnego pliku
return wczytaj("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(Scanner scanner = new Scanner(plik)) {
scanner.nextLine(); // pomijamy pierwszą linię
while(scanner.hasNextLine()) {
String linia = scanner.nextLine();
Employee emp = parsujLinie(linia);
emps.add(emp);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
// w razie błędu (brak pliku) wypiszemy czerwone teksty na ekran, ale nie przerwiemy programu, tylko zwrócimy pustą listę
}
return emps;
}
public static Stream<Employee> wczytajStrumieniowo(Path plik) {
try {
return Files.lines(plik)
.skip(1)
.map(ObslugaCSV::parsujLinie);
} catch (IOException e) {
e.printStackTrace();
return Stream.empty();
}
}
private static Employee parsujLinie(String linia) {
String[] t = linia.split(";", -1);
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]);
return emp;
}
public static Stream<Employee> wczytajStrumieniowo(File plik) {
return wczytajStrumieniowo(plik.toPath());
}
public static Stream<Employee> wczytajStrumieniowo(String sciezka) {
return wczytajStrumieniowo(Path.of(sciezka));
}
public static Stream<Employee> wczytajStrumieniowo() {
return wczytajStrumieniowo("emps.csv");
}
public static void zapisz(List<Employee> lista, File plik) {
try(PrintWriter out = new PrintWriter(plik)) {
out.println(
"employee_id;first_name;last_name;job_title;salary;hire_date;department_name;address;postal_code;city;country");
for(Employee emp : lista) {
out.printf("%d;%s;%s;%s;%d;%s;%s;%s;%s;%s;%s\n", emp.getEmployeeId(), emp.getFirstName(),
emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getHireDate(),
emp.getDepartmentName(), emp.getAddress(), emp.getPostalCode(), emp.getCity(),
emp.getCountry());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public static void zapisz(List<Employee> lista, String sciezka) {
zapisz(lista, new File(sciezka));
}
public static void zapisz(List<Employee> lista) {
zapisz(lista, "emps.csv");
}
public static void zapiszStrumieniowo(Stream<Employee> stream, File plik) {
try(PrintWriter out = new PrintWriter(plik)) {
out.println(
"employee_id;first_name;last_name;job_title;salary;hire_date;department_name;address;postal_code;city;country");
stream.forEachOrdered(emp -> {
out.printf("%d;%s;%s;%s;%d;%s;%s;%s;%s;%s;%s\n", emp.getEmployeeId(), emp.getFirstName(),
emp.getLastName(), emp.getJobTitle(), emp.getSalary(), emp.getHireDate(),
emp.getDepartmentName(), emp.getAddress(), emp.getPostalCode(), emp.getCity(),
emp.getCountry());
});
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
src/emps/v3_funkcyjnie/S2_Filtrowanie.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.Comparator;
public class S2_Filtrowanie {
public static void main(String[] args) {
ObslugaCSV.wczytajStrumieniowo()
.filter(emp -> emp.getSalary() <= 5000)
.sorted(Comparator.comparing(Employee::getSalary))
.map(emp -> emp.getFirstName() + " " + emp.getLastName() + " z pensją " + emp.getSalary())
.map(String::toUpperCase)
.forEach(System.out::println);
}
}
src/emps/v3_funkcyjnie/S4_SredniaJedenJob.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.OptionalDouble;
import javax.swing.JOptionPane;
public class S4_SredniaJedenJob {
public static void main(String[] args) {
String szukanyJob = JOptionPane.showInputDialog("Podaj szukany job", "Programmer");
OptionalDouble srednia2 = ObslugaCSV.wczytajStrumieniowo()
.filter(emp -> emp.getJobTitle().equalsIgnoreCase(szukanyJob))
.mapToInt(Employee::getSalary)
.average();
if(srednia2.isPresent()) {
JOptionPane.showMessageDialog(null, String.format(
"Średnia pensja na stanowisku %s wynosi %.2f",
szukanyJob, srednia2.getAsDouble()));
} else {
JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
"Brak danych", JOptionPane.WARNING_MESSAGE);
}
}
}
src/emps/v3_funkcyjnie/S_Grupowanie9.java 0 → 100644
package emps.v3_funkcyjnie;
import java.util.IntSummaryStatistics;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;
public class S_Grupowanie9 {
public static void main(String[] args) {
Map<String, IntSummaryStatistics> grupy = ObslugaCSV.wczytajStrumieniowo()
.collect(Collectors.groupingBy(
Employee::getJobTitle,
TreeMap::new,
Collectors.summarizingInt(Employee::getSalary)));
grupy.forEach((job, stats) -> {
// System.out.printf("%-32s → %s%n", job, stats);
System.out.printf("| %-32s | %2d | %5d | %8.2f | %5d |%n",
job, stats.getCount(), stats.getMin(), stats.getAverage(), stats.getMax());
});
}
}
src/emps/v4_rekord/Employee.java 0 → 100644
package emps.v4_rekord;
import java.time.LocalDate;
public record Employee(int employeeId, String firstName, String lastName, String jobTitle, int salary, LocalDate hireDate,
String departmentName, String address, String postalCode, String city, String country) {
// Rekord to jest "taka klasa", dla której automatycznie tworzone są:
// - deklaracje podanych pól, które wszystkie są "private final"
// - konstruktor z wszystkimi parametrami
// - gettery do wszystkich pól, ale uwaga, nazwą metody jest po prostu "salary()", a nie "getSalary()"
// - toString, equals i hashCode w sposób standardowy dla klas typu "value object"
// Do rekordu można dodawać własne metody. Rekord może implementować interfejsy.
public String danePracownika() {
return String.format("%s %s (%s) zarabia %d", firstName, lastName, jobTitle, salary);
}
public static int dodaj(int x, int y) {
return x + y;
}
}
src/emps/v4_rekord/Grupowanie2.java 0 → 100644
package emps.v4_rekord;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class Grupowanie2 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
Map<String, Integer> sumy = new TreeMap<>();
Map<String, Integer> ilosci = new TreeMap<>();
for(Employee emp : emps) {
int suma = sumy.getOrDefault(emp.jobTitle(), 0);
sumy.put(emp.jobTitle(), suma + emp.salary());
int ile = ilosci.getOrDefault(emp.jobTitle(), 0);
ilosci.put(emp.jobTitle(), ile+1);
}
for(String job : sumy.keySet()) {
int suma = sumy.get(job);
int ile = ilosci.get(job);
double srednia = (double)suma / ile;
System.out.printf("| %-32s | %2d | %8.2f |%n", job, ile, srednia);
}
}
}
src/emps/v4_rekord/Grupowanie8.java 0 → 100644
package emps.v4_rekord;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Grupowanie8 {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
Map<String, Double> grupy = emps.stream()
.collect(Collectors.groupingBy(
Employee::jobTitle,
Collectors.averagingInt(Employee::salary)));
grupy.forEach((job, srednia) -> {
System.out.printf("%-32s → %8.2f%n", job, srednia);
});
}
}
src/emps/v4_rekord/Grupowanie9.java 0 → 100644
package emps.v4_rekord;
import java.util.IntSummaryStatistics;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;
public class Grupowanie9 {
public static void main(String[] args) {
Map<String, IntSummaryStatistics> grupy = ObslugaCSV.wczytajStrumieniowo("emps.csv")
.collect(Collectors.groupingBy(
Employee::jobTitle,
TreeMap::new,
Collectors.summarizingInt(Employee::salary)));
grupy.forEach((job, stats) -> {
System.out.printf("| %-32s | %2d | %5d | %8.2f | %5d |%n",
job, stats.getCount(), stats.getMin(), stats.getAverage(), stats.getMax());
});
}
}
src/emps/v4_rekord/ObslugaCSV.java 0 → 100644
package emps.v4_rekord;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Stream;
public class ObslugaCSV {
public static List<Employee> wczytaj() {
// używa domyślnego pliku
return wczytaj("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(Scanner scanner = new Scanner(plik)) {
scanner.nextLine(); // pomijamy pierwszą linię
while(scanner.hasNextLine()) {
String linia = scanner.nextLine();
Employee emp = parsujLinie(linia);
emps.add(emp);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
// w razie błędu (brak pliku) wypiszemy czerwone teksty na ekran, ale nie przerwiemy programu, tylko zwrócimy pustą listę
}
return emps;
}
public static Stream<Employee> wczytajStrumieniowo(Path plik) {
try {
return Files.lines(plik)
.skip(1)
.map(ObslugaCSV::parsujLinie);
} catch (IOException e) {
e.printStackTrace();
return Stream.empty();
}
}
public static Stream<Employee> wczytajStrumieniowo(File plik) {
return wczytajStrumieniowo(plik.toPath());
}
public static Stream<Employee> wczytajStrumieniowo(String sciezka) {
return wczytajStrumieniowo(Path.of(sciezka));
}
public static Stream<Employee> wczytajStrumieniowo() {
return wczytajStrumieniowo("emps.csv");
}
public static void zapisz(List<Employee> lista, File plik) {
try(PrintWriter out = new PrintWriter(plik)) {
out.println(
"employee_id;first_name;last_name;job_title;salary;hire_date;department_name;address;postal_code;city;country");
for (Employee emp : lista) {
out.printf("%d;%s;%s;%s;%d;%s;%s;%s;%s;%s;%s\n", emp.employeeId(), emp.firstName(),
emp.lastName(), emp.jobTitle(), emp.salary(), emp.hireDate(),
emp.departmentName(), emp.address(), emp.postalCode(), emp.city(),
emp.country());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public static void zapisz(List<Employee> lista, String sciezka) {
zapisz(lista, new File(sciezka));
}
public static void zapisz(List<Employee> lista) {
zapisz(lista, "emps.csv");
}
private static Employee parsujLinie(String linia) {
String[] t = linia.split(";", -1);
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]);
return emp;
}
}
src/emps/v4_rekord/P1_WypiszDane.java 0 → 100644
package emps.v4_rekord;
import java.util.List;
// Program dla każdego pracownika wypisuje tekst postaci
// Steven King (President) zarabia 24000
public class P1_WypiszDane {
public static void main(String[] args) {
List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
for(Employee emp : emps) {
// System.out.println(emp.getFirstName() + " " + emp.getLastName());
System.out.printf("Pracownik %s %s (%s) zarabia %s%n",
emp.firstName(), emp.lastName(), emp.jobTitle(), emp.salary());
}
}
}
// TODO napisać programy P2 P3 P4 działające tak, jak w wersji nieobiektowej,
// ale w oparciu o listę obiektów Emeployee
src/emps/v4_rekord/P4_SredniaJedenJob_v3.java 0 → 100644
package emps.v4_rekord;
import java.io.File;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.filechooser.FileNameExtensionFilter;
public class P4_SredniaJedenJob_v3 {
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)
return;
File plik = chooser.getSelectedFile();
List<Employee> emps = ObslugaCSV.wczytaj(plik);
Set<String> jobs = new TreeSet<>();
for(Employee emp : emps) {
jobs.add(emp.jobTitle());
}
String szukanyJob = (String)JOptionPane.showInputDialog(null, "Wybierz stanowisko", "Wybór",
JOptionPane.QUESTION_MESSAGE, null, jobs.toArray(), "Programmer");
if(szukanyJob == null)
return;
double suma = 0;
int ile = 0;
for(Employee emp : emps) {
if(szukanyJob.equals(emp.jobTitle())) {
suma += emp.salary();
ile++;
}
}
if(ile > 0) {
double srednia = suma / ile;
JOptionPane.showMessageDialog(null, String.format(
"Na stanowisku %s pracuje %d osób.\nŚrednia pensja wynosi %.2f",
szukanyJob, ile, srednia));
} else {
JOptionPane.showMessageDialog(null, String.format("Nikt nie pracuje na stanowisku %s.", szukanyJob),
"Brak danych", JOptionPane.WARNING_MESSAGE);
}
}
}
src/emps/v4_rekord/S2_Filtrowanie.java 0 → 100644
package emps.v4_rekord;
public class S2_Filtrowanie {
public static void main(String[] args) {
ObslugaCSV.wczytajStrumieniowo("emps.csv")
.filter(emp -> emp.salary() >= 10_000)
.map(Employee::danePracownika)
.forEach(System.out::println);
}
}
src/p14_lambdy/EffectivelyFinal.java 0 → 100644
package p14_lambdy;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class EffectivelyFinal {
private static int statyczna = 0;
public static void main(String[] args) {
// W wyrażeniach lambda (podobnie w klasach anonimowych) nie można używać zmiennych lokalnych, które są modyfikowane.
// Przykład kiedy to przeszkadza w praktyce:
List<String> imiona = new ArrayList<>();
imiona.add("Ala");
imiona.add("Aleksandra");
imiona.add("Ula");
imiona.add("Elżbieta");
double liczba = 0;
liczba = liczba + imiona.size();
int x = 0;
AtomicInteger ai = new AtomicInteger();
// Głupie rozwiązanie problemu "ile jest jest imion 3-literowych"
imiona.forEach(s -> {
if(s.length() == 3) {
//NK x++; // wewnątrz wyrażeń lambda nie można modyfikować zmiennych lokalnych z otoczenia
// ani nawet używać zmiennych modyfikowanych poza lambdą
//NK System.out.println(liczba);
// mamy dostęp do zmiennych z poziomu klasy (statycznych, isntancyjnych)
statyczna++;
// ale to zły styl
// lepszym pomysłem jest obiekt "mutowalny", np. AtomicInteger (który zadziałałby także w kontekście wielowątkowym)
ai.incrementAndGet();
}
});
// w jeszcze lepszym stylu byłoby tutaj zastosowanie strumienia z filtrem
long y = imiona.stream().filter(s -> s.length() == 3).count();
System.out.println(" x : " + x);
System.out.println("statyczna : " + statyczna);
System.out.println("atomic : " + ai);
System.out.println("count : " + y);
}
}
src/p14_lambdy/FunkcjaLiczbowa.java 0 → 100644
package p14_lambdy;
// Na interfejsy, w których jest dokładnie jedna niezaimplementowana metoda
// mówi się "interfejs funkcyjny" / "functional interface"
// Przed takim interfejsem MOŻNA umieścić adnotację, która sprawdza,
// czy interfejs naprawdę spełnia wymagania. Ale bez tej adnotacji wszystko też działa.
@FunctionalInterface
public interface FunkcjaLiczbowa {
double oblicz(double x);
default String napisz(double y) {
return "Wynikiem jest " + oblicz(y);
}
}
src/p14_lambdy/MnozeniePrzez10.java 0 → 100644
package p14_lambdy;
public class MnozeniePrzez10 implements FunkcjaLiczbowa {
@Override
public double oblicz(double x) {
return 10 * x;
}
}
src/p14_lambdy/MojFrameworkFunkcyjny.java 0 → 100644
package p14_lambdy;
public class MojFrameworkFunkcyjny {
/** Aplikuje podaną funkcję do każdego elementu podanej tablicy.
* W tablicy w miejsce argumentów zapisywane są wynikowe wartości.
* @param t
* @param f
*/
public static void zastosujDoTablicy(double[] t, FunkcjaLiczbowa f) {
for(int i = 0; i < t.length; i++) {
t[i] = f.oblicz(t[i]);
}
}
}
src/p14_lambdy/MojFrameworkTest.java 0 → 100644
package p14_lambdy;
import static p14_lambdy.MojFrameworkFunkcyjny.zastosujDoTablicy;
import java.util.Arrays;
public class MojFrameworkTest {
public static void main(String[] args) {
double[] a = {0, 1, 3, 8, 13, 63, 80};
System.out.println(Arrays.toString(a));
zastosujDoTablicy(a, x -> x+1);
System.out.println(Arrays.toString(a));
zastosujDoTablicy(a, Math::sqrt);
System.out.println(Arrays.toString(a));
zastosujDoTablicy(a, liczba -> liczba*liczba);
System.out.println(Arrays.toString(a));
}
}
src/p14_lambdy/Przyklady.java 0 → 100644
package p14_lambdy;
public class Przyklady {
public static void main(String[] args) {
// Sposoby tworzenia obiektu zgodnego z interfejsem
// sprzed Javy 8:
// 1. Oddzielna klasa w projekcie
MnozeniePrzez10 m10 = new MnozeniePrzez10();
System.out.println(m10);
System.out.println(m10.oblicz(11)); // 110
FunkcjaLiczbowa m10_inaczej = new MnozeniePrzez10();
System.out.println(m10_inaczej);
System.out.println(m10_inaczej.oblicz(22)); // 220
// 2. Klasa anonimowa
FunkcjaLiczbowa m3 = new FunkcjaLiczbowa() {
public double oblicz(double x) {
return 3*x;
}
};
System.out.println(m3);
System.out.println(m3.oblicz(50)); // 150
// Istnieją jeszcze klasy wewnętrzne i klasy lokalne, ale to pomijamy...
System.out.println();
// Od Java 8 możemy używać wyrażeń lambda oraz referencji do metod
// wobec interfejsów funkcyjnych, czyli tych, w których do zaimplementowania jest jedna metoda.
FunkcjaLiczbowa f1 = x -> x*x;
System.out.println(f1);
System.out.println(f1.oblicz(5));
System.out.println(f1.oblicz(6));
System.out.println(f1.napisz(7));
FunkcjaLiczbowa f2 = (double arg) -> {
double zmienna = 10*arg;
zmienna += 5;
return zmienna;
};
System.out.println(f2);
System.out.println(f2.oblicz(7));
System.out.println(f2.oblicz(100));
System.out.println();
FunkcjaLiczbowa f3 = Math::sqrt;
System.out.println(f3);
System.out.println(f3.oblicz(81));
System.out.println(f3.oblicz(2));
System.out.println(f3.napisz(121));
}
}
src/p16_streamy/KlasaOptional.java 0 → 100644
package p16_streamy;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class KlasaOptional {
public static void main(String[] args) {
Optional<String> napis0 = Optional.empty();
System.out.println(napis0);
Optional<String> napis1 = Optional.of("Ala");
System.out.println(napis1);
// Można też tworzyć Optional w oparciu o wartość, która może być nullem (null oznacza empty)
String a = "Ola", b = null;
Optional<String> napis2 = Optional.ofNullable(a);
Optional<String> napis3 = Optional.ofNullable(b);
System.out.println(napis2);
System.out.println(napis3);
System.out.println();
// Wartość, która jest w Optionalu, najprościej odczytać operacją get
System.out.println(napis1.get());
// ale w przypadku pustego Optionala spowodowałoby to wyjątek
try {
System.out.println(napis0.get());
} catch (Exception e) {
System.err.println("próba odczytu napis0.get(): " + e);
}
System.out.println();
// Aby porównać działanie dla pustych i niepustych, operacje uruchamiam w pętli dla 3 przykładowych obiektów.
List<Optional<String>> lista = new ArrayList<>(Arrays.asList(napis1, napis2, napis3));
// Od Javy 9 możnaby (lista jest niemutowalna)
// List<Optional<String>> lista = List.of(napis1, napis2, napis3);
// Dla każdego Optionala można za pomocą if sprawdzić czy on zawiera wartość:
for(Optional<String> opt : lista) {
if(opt.isPresent()) {
System.out.println("Jest wartość " + opt.get());
} else {
System.out.println("Brak wartości");
}
}
System.out.println();
// Można też pobierając wartość zastąpić ją wartością domyślną w przypadku braku danych:
for(Optional<String> opt : lista) {
String napis = opt.orElse("nieznana osoba");
System.out.println("Witaj osobo " + napis);
}
System.out.println();
// Ponieważ utworzenie domyślnej wartości może być czasami kosztowne,
// albo musi być zrobione w czasie działania programu,
// można też przekazać funkcję, która utworzy tę wartość - najczęściej jako wyrażenienie lambda:
for(Optional<String> opt : lista) {
String napis = opt.orElseGet(() -> "Brak danych stwierdzony o godzinie " + LocalTime.now());
System.out.println("Halo halo " + napis);
}
System.out.println();
// Można też wyrzucić wyjątek, ale własny zamiast standardowego
try {
for(Optional<String> opt : lista) {
String napis = opt.orElseThrow(() -> new RuntimeException("Brak danych stwierdzony o godzinie " + LocalTime.now()));
System.out.println("Helo helo " + napis);
}
} catch (Exception e) {
System.err.println(e);
}
System.out.println();
// Są też operacje "funkcyjne", które przypominają operacje na strumieniach.
// Uwaga wstępna - wszystkie te operacjie noe modyfikują obiektu Optional w środku,
// tylko w wyniku zwracają nowego Optionala.
// Operacja map zamienia wartość w Optionalu na wynik funkcji,
// ale w przypadku pustego Optionala zwraca pustego Optionala
Optional<String> wynikMap0 = napis0.map(String::toUpperCase);
Optional<String> wynikMap1 = napis1.map(String::toUpperCase);
System.out.println(wynikMap0);
System.out.println(wynikMap1);
for(Optional<String> opt : lista) {
System.out.println("hej " + opt.map(String::toLowerCase).orElse("nieznajomy"));
}
System.out.println();
//
for(Optional<String> opt : lista) {
String napis = opt.filter(s -> s.startsWith("O")).map(String::toUpperCase).orElse("---");
System.out.println(napis);
}
}
}
src/p16_streamy/a_poczatek/A_TypowyPrzyklad.java 0 → 100644
package p16_streamy.a_poczatek;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class A_TypowyPrzyklad {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println(lista);
System.out.println();
lista.stream()
.filter(s -> s.contains("a"))
.map(s -> s.toUpperCase())
.forEach(s -> System.out.println(s));
// To odpowiada takiej pętli:
for(String s1 : lista) {
if(s1.contains("a")) {
String s2 = s1.toUpperCase();
System.out.println(s2);
}
}
}
}
src/p16_streamy/b_dzialanie/Strumienie1.java 0 → 100644
package p16_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class Strumienie1 {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
Stream<String> str1 = lista.stream();
System.out.println(str1);
// Strumień nie jest kolekcją, nie zawiera danych. Jest on tylko sposobem dostępu do danych.
str1.forEach(s -> System.out.print(s + ", "));
System.out.println();
System.out.println();
// Jednego strumienia nie można używać wielokrotnie
// forEach jest "operacją terminującą" i zamyka strumień
//EXN str1.forEach(s -> System.out.print(s + "; "));
// Jest też forEach bezpośrednio na liście (na każdym Iterable)
lista.forEach(s -> System.out.print(s + "; "));
System.out.println();
// Zobaczmy po kolei jakiego typu wyniki wychodzą:
Stream<String> str2a = Arrays.stream(tablica);
Stream<String> str2b = str2a.filter(s -> s.length() > 3);
Stream<String> str2c = str2b.map(s -> s.toUpperCase());
// Stream<Integer> str2d = str2c.map(s -> s.length());
// albo - w praktyce lepiej:
IntStream str2e = str2c.mapToInt(s -> s.length());
// Strumienie liczb oferują dodatkowe operacje.
int suma = str2e.sum();
System.out.println(suma);
System.out.println();
// Zazwyczaj nie tworzy się zmiennych pośrednich, tylko zapisuje jednym ciągiem ("pipeline"):
suma = Arrays.stream(tablica)
.filter(s -> s.length() > 3)
.map(s -> s.toUpperCase())
.mapToInt(s -> s.length())
.sum();
System.out.println(suma);
}
}
src/p16_streamy/b_dzialanie/Strumienie2_JakToDziala.java 0 → 100644
package p16_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
// Operacje wypisują co robią na ekran, abyśmy mogli sprawdzić kolejność ich wykonania.
public class Strumienie2_JakToDziala {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Iwona", "Ola", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Lista imion: " + lista);
System.out.println("Jestem przed tworzeniem strumienia");
// Chociaż wskazuję operacje sprawdź i mapuj w momencie definiowania strumienia
// to one jeszcze się nie wykonują.
Stream<String> strumien = lista.stream()
.filter(s -> sprawdz(s))
// .sorted()
.map(s -> mapuj(s));
System.out.println("Strumień utworzony: " + strumien);
lista.add("Dodatkowy");
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/p16_streamy/b_dzialanie/Strumienie2a.java 0 → 100644
package p16_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2a {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.stream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s))
.limit(5);
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/p16_streamy/b_dzialanie/Strumienie2b.java 0 → 100644
package p16_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2b {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.stream()
.limit(5)
.filter(s -> sprawdz(s))
.map(s -> mapuj(s));
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/p16_streamy/b_dzialanie/Strumienie2c.java 0 → 100644
package p16_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2c {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.parallelStream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s));
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
// forEach nie ma obowiązku zachowania kolejności i w przypadku parallelStream nie zachowuje
System.out.println("KONIEC");
}
}
src/p16_streamy/b_dzialanie/Strumienie2d.java 0 → 100644
package p16_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2d {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.parallelStream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s));
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
// forEachOrdered gwarantuje wykonanie operacji (tylko tej ostatniej) w takiej kolejności, w jakiej elementy są umieszczone w strumieniu
strumien.forEachOrdered(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/p16_streamy/b_dzialanie/Strumienie2e.java 0 → 100644
package p16_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2e {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.parallelStream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s))
.limit(5);
// tutaj wciąż te same 5 elementów jest wyświetlanych na końcu
// tak dzieje się dlatego, że strumień jest uporządkowany (ORDERED), bo pochodzi z listy
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/p16_streamy/b_dzialanie/Strumienie2f.java 0 → 100644
package p16_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2f {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.parallelStream()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s))
.limit(5);
// tutaj wciąż te same 5 elementów jest wyświetlanych na końcu - a ich kolejność będzie zachowana
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEachOrdered(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/p16_streamy/b_dzialanie/Strumienie2g.java 0 → 100644
package p16_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie2g {
static boolean sprawdz(String s) {
System.out.println("sprawdzam " + s);
return s.length() > 3;
}
static String mapuj(String s) {
System.out.println("mapuję " + s);
return s.toUpperCase();
}
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.parallelStream()
.unordered()
.filter(s -> sprawdz(s))
.map(s -> mapuj(s))
.limit(5);
// unordered - zapomnij o kolejności; to może zwiekszyć wydajność, ale wyniki tego przykładu
// (gdzie mamy limit) są niedetrministyczne
// teraz zmienia się zestaw elementów wyświetlanym na końcu forEachem
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
// strumien.forEach(s -> System.out.println(" * " + s));
strumien.forEachOrdered(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
}
}
src/p16_streamy/b_dzialanie/Strumienie3_Peek.java 0 → 100644
package p16_streamy.b_dzialanie;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Strumienie3_Peek {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
Stream<String> strumien = lista.stream()
.peek(s -> System.out.println("\n F : " + s))
.filter(s -> s.length() > 3)
.peek(s -> System.out.println(" M : " + s))
.map(String::toUpperCase)
.peek(s -> System.out.println(" # : " + s));
System.out.println("Strumień utworzony: " + strumien);
System.out.println();
System.out.println("Operacja terminująca:");
strumien.forEach(s -> System.out.println(" * " + s));
System.out.println("KONIEC");
System.out.println();
Stream<String> str2a = lista.stream();
Stream<String> str2b = str2a.peek(s -> System.out.println(" % " + s));
// peek nie wpływa na zawartość ani "widzianą z zewnątrz logikę" strumienia,
// ale powoduje, że w momencie ewaluacji strumienia na każdym elemencie będzie wykonan podana operacja
str2b.limit(5).forEach(s -> {});
}
}
src/p16_streamy/c_przeglad_operacji/C01_Generowanie.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.time.LocalTime;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
public class C01_Generowanie {
static int licznikStatyczny = 0;
public static void main(String[] args) {
Stream<String> str0 = Stream.empty();
str0.forEach(s -> System.out.print(s + ", "));
System.out.println();
Stream<String> str1 = Stream.of("Ala", "Ola", "Ela");
str1.forEach(s -> System.out.print(s + ", "));
System.out.println();
String[] tablica = {"Ala", "Ola", "Ula"};
Stream<String> str2 = Stream.of(tablica);
str2.forEach(s -> System.out.print(s + "; "));
System.out.println();
Stream.Builder<String> builder = Stream.builder();
Stream<String> str3 = builder.add("Ula").add("Ala").add("Ola").build();
str3.forEach(s -> System.out.print(s + ", "));
System.out.println();
System.out.println();
// Kolejny element strumienia generowany "bezkontekstowo" (bez żanego parametru)
Stream<LocalTime> czasy = Stream.generate(() -> LocalTime.now());
// to się zapętla:
// czasy.forEach(lt -> System.out.println(lt));
czasy.limit(20).forEach(lt -> System.out.println(lt));
//EXN przy probie kolejnego uzycia
// czasy.limit(30).forEach(lt -> System.out.println(lt));
System.out.println();
int licznikLokalny = 0;
// w wyrażeniu lambda nie wolno modyfikować zmiennych lokalnych ani używać zmieniających się zmiennych lokalnych
// int suma0 = IntStream.generate(() -> ++licznikLokalny).limit(10).sum();
int suma = IntStream.generate(() -> ++licznikStatyczny)
.filter(x -> x%2 == 1)
.limit(8)
.sum();
System.out.println(suma);
// Kolejny element generowany na podstawie poprzedniego
Stream<String> str4 = Stream.iterate("$", s -> s + "*");
// też nieskończony
str4.limit(10).forEach(System.out::println);
System.out.println();
// Przykład sensownych operacji na strumieniach nieskończonych:
IntStream parzyste = IntStream.iterate(0, x -> x+2);
IntStream nieparzyste = parzyste.map(x -> x+1);
int suma2 = nieparzyste.limit(9).sum();
System.out.println(suma2);
System.out.println();
IntStream.iterate(1, x -> x+2).limit(10).forEach(System.out::println);
System.out.println();
LongStream.iterate(1, x -> 2*x).limit(65).forEach(System.out::println);
System.out.println();
Stream<String> str11 = Stream.of("Ala", "Ola", "Ela");
Stream<String> str12 = Stream.of("Adam", "Ludwik", "Ksawery");
Stream<String> razem = Stream.concat(str11, str12);
razem.forEach(s -> System.out.print(s + ", "));
System.out.println();
}
}
src/p16_streamy/c_przeglad_operacji/C02_ZRoznychKlas.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.Collator;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.Stream;
public class C02_ZRoznychKlas {
public static void main(String[] args) {
Random random = new Random();
// nieskończony strumień losowych intów
random.ints();
random.ints().limit(100).forEach(System.out::println);
// przykład: utwórz tablicę 100 losowych int-ów:
int[] liczbyLosowe = random.ints().limit(100).toArray();
System.out.println(Arrays.toString(liczbyLosowe));
System.out.println();
//random.doubles();
int suma = random.ints(100, 0, 1000).sum();
System.out.println(suma);
System.out.println();
try {
// operacja "imperatywna":
// List<String> wczytaneLinie = Files.readAllLines(path);
// dostęp strumieniowy
// strumienie też można zamykać; ten należy zamykać
try(Stream<String> lines = Files.lines(Paths.get("pan-tadeusz.txt"))) {
lines.filter(s -> s.contains("Tadeusz"))
.sorted(Collator.getInstance())
.forEachOrdered(System.out::println);
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println();
Path dir = Paths.get("src");
try {
Files.list(dir)
.forEach(f -> System.out.println(f + " " + Files.isRegularFile(f)));
} catch (IOException e) {
e.printStackTrace();
}
}
}
src/p16_streamy/c_przeglad_operacji/C11_FilterMap.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.util.stream.Stream;
public class C11_FilterMap {
public static void main(String[] args) {
String[] imiona = {"Ala", "Ola", "Basia", "Kasia", "Ela", "Ula", "Agnieszka", "Magdalena", "Anna", "Hanna", "Joanna", "Ala", "Agata", "Genowefa", "Grażyna", "Karolina", "Julia", "Zuzanna"};
Stream.of(imiona)
.filter(s -> s.length() >= 5)
.forEach(System.out::println);
System.out.println();
Stream.of(imiona)
.map(String::toUpperCase)
.forEach(System.out::println);
System.out.println();
Stream.of(imiona)
.filter(s -> s.startsWith("A"))
.map(String::length) // Stream<String> -> Stream<Integer>
.forEach(System.out::println);
Stream.of(imiona)
.filter(s -> s.startsWith("A"))
.mapToInt(String::length) // Stream<String> -> IntStream
.forEach(System.out::println);
}
}
src/p16_streamy/c_przeglad_operacji/C12_FlatMap.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class C12_FlatMap {
static List<Integer> generuj(int ilosc) {
List<Integer> lista = new ArrayList<>();
for(int i = 1; i <= ilosc; i++) {
lista.add(i);
}
return lista;
}
static Stream<Integer> generujStrumien(int ilosc) {
List<Integer> lista = new ArrayList<>();
for(int i = 1; i <= ilosc; i++) {
lista.add(i);
}
return lista.stream();
}
static IntStream generujStrumienIntow(int ilosc) {
List<Integer> lista = new ArrayList<>();
for(int i = 1; i <= ilosc; i++) {
lista.add(i);
}
return lista.stream().mapToInt(Integer::intValue);
}
public static void main(String[] args) {
System.out.println(generuj(1));
System.out.println(generuj(3));
System.out.println(generuj(5));
System.out.println();
System.out.println("Elementy strumienia wejściowego:");
Stream.of(1, 3, 5)
.forEach(x -> System.out.print(x + " | "));
System.out.println();
System.out.println();
System.out.println("Zwykłe mapowanie:");
Stream.of(1, 3, 5)
.map(C12_FlatMap::generuj)
.forEach(x -> System.out.print(x + " | "));
System.out.println();
Stream.of(1, 3, 5)
.map(x -> C12_FlatMap.generuj(x).stream())
.forEach(x -> System.out.print(x + " | "));
System.out.println();
System.out.println();
System.out.println("Płaskie mapowanie:");
Stream.of(1, 3, 5)
.flatMap(x -> C12_FlatMap.generuj(x).stream())
.forEach(x -> System.out.print(x + " | "));
System.out.println();
System.out.println();
Stream.of(1, 3, 5)
.flatMap(C12_FlatMap::generujStrumien)
.forEach(x -> System.out.print(x + " | "));
System.out.println();
System.out.println();
int suma = Stream.of(1, 3, 5)
.flatMapToInt(C12_FlatMap::generujStrumienIntow)
.sum();
System.out.println(suma);
}
}
src/p16_streamy/c_przeglad_operacji/C12b_FlaMapTekstu.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.util.stream.Stream;
public class C12b_FlaMapTekstu {
public static void main(String[] args) {
Stream<String> linie = Stream.of(
"Ala ma kota",
"Ola ma psa",
"Sierotka ma rysia"
);
// tutaj powstaje strumień 3 strumieni
// linie.map(linia -> Stream.of(linia.split("\\s+")))
// .forEach(System.out::println);
// tutaj powstaje strumień połączonych słów
linie.flatMap(linia -> Stream.of(linia.split("\\s+")))
.map(String::toUpperCase)
.forEach(System.out::println);
}
}
src/p16_streamy/c_przeglad_operacji/C13_RozneOperacje.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class C13_RozneOperacje {
public static void main(String[] args) {
String[] imiona = {"Ala", "Ola", "Basia", "Kasia", "Ela", "Ula", "Agnieszka", "Magdalena", "Anna", "Hanna", "Joanna", "Ala", "Agata", "Genowefa", "Grażyna", "Karolina", "Julia", "Zuzanna"};
// ** operacje terminujące ** //
// forEach - dla każdego elementu wykonaj akcję
Stream.of(imiona).forEach(s -> System.out.println(s));
// forEachOrdered - dla każdego elementu wykonaj akcję zachowując kolejność (istotne dla parallelStream)
Stream.of(imiona).forEachOrdered(s -> System.out.println(s));
System.out.println("\n--------------------------------\n");
// count() - liczba elementów strumienia (też wymaga pobrania elementów !)
long n = Stream.of(imiona).count();
System.out.println("count: " + n);
// toArray - tworzy nową tablicę i wstawia tam elementy
Object[] array1 = Stream.of(imiona)
.map(String::toLowerCase)
.toArray();
System.out.println(array1 + " , length="+array1.length);
System.out.println(Arrays.toString(array1));
System.out.println();
// inna wersja: podajemy funkcję tworzącą tablice; korzyść: dostajemy String[] a nie Object[]
String[] array2 = Stream.of(imiona)
.sorted()
.toArray(String[]::new);
System.out.println(array2 + " , length="+array2.length);
System.out.println(Arrays.toString(array2));
System.out.println("\n--------------------------------\n");
// reduce - redukcja w sposób właściwy dla klas niemutowalnych
Optional<String> wynik01 = Stream.of(imiona)
.reduce(String::concat);
System.out.println("wynik01: " + wynik01);
String wynik02 = Stream.of(imiona)
.reduce("", String::concat);
System.out.println("wynik02: " + wynik02);
String wynik03 = Stream.of(imiona)
.reduce("|", String::concat);
System.out.println("wynik03: " + wynik03);
String wynik04 = Stream.of(imiona)
.parallel()
.reduce("|", String::concat);
System.out.println("wynik04: " + wynik04);
// Takie użycie concat jest niewydaje i tego nie naśladujcie
// wersja, w której typ wyniku może być inny niż typ elementów
// tu przykład sumowania długości napisów
Integer wynik05 = Stream.of(imiona)
.reduce(0, (x, s) -> x+s.length(), (x,y)->x+y);
System.out.println("wynik05: " + wynik05);
System.out.println();
// collect - redukcja w sposób właściwy dla klas mutowalnych
StringBuilder wynik06 = Stream.of(imiona).collect(
StringBuilder::new, // supplier - tworzy początkową "pusta" wartość
StringBuilder::append, // accumulator - aktualizuje wartość na podstawie elementu strumienia
StringBuilder::append); // combiner - łączy częściowe wyniki (które mogą się pojawić gdy mamy parallelStream)
System.out.println("wynik06: " + wynik06);
List<String> lista = Stream.of(imiona)
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(lista);
System.out.println("\n--------------------------------\n");
// findFirst i findAny - wybór jednego elementu
// findAny zwraca "jakikolwiek" - ale to nie znaczy "losowy"
// po prostu implementacja zwróci ten, do którego ma najszybszy dostęp
Optional<String> wynik07 = Stream.of(imiona).findFirst();
Optional<String> wynik08 = Stream.of(imiona).findAny();
Optional<String> wynik09 = Stream.of(imiona).parallel().findAny(); // niedeterministyczne, czasami była Ala a czasami Ula
// jest szansa na zobaczenie innego imienia niż Ala :)
System.out.println("findFirst : " + wynik07);
System.out.println("findAny : " + wynik08);
System.out.println("findAny par: " + wynik09);
System.out.println();
// kwantyfikatory logiczne - zwracają true albo false
// działają w sposób leniwy - przestają pobierać kolejne elementy strumienia jeśli wynik jest rozstrzygnięty
boolean bool1 = Stream.of(imiona).allMatch(s -> s.endsWith("a"));
System.out.println("bool1 = " + bool1);
boolean bool2 = Stream.of(imiona).allMatch(s -> s.startsWith("K"));
System.out.println("bool2 = " + bool2);
boolean bool3 = Stream.of(imiona).anyMatch(s -> s.startsWith("K"));
System.out.println("bool3 = " + bool3);
boolean bool4 = Stream.of(imiona).noneMatch(s -> s.startsWith("K"));
System.out.println("bool4 = " + bool4);
}
}
src/p16_streamy/c_przeglad_operacji/C14_MinMax.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import emps.v2_obiektowo.Employee;
import emps.v2_obiektowo.ObslugaCSV;
public class C14_MinMax {
public static void main(String[] args) {
List<Employee> lista = ObslugaCSV.wczytaj();
Optional<Employee> min = lista.stream().min(Comparator.comparing(Employee::getSalary));
Optional<Employee> max = lista.stream().max(Comparator.comparing(Employee::getSalary));
System.out.println("min: " + min);
System.out.println("max: " + max);
System.out.println();
if(min.isPresent()) {
System.out.println("Znaleziono minimum:");
Employee emp = min.get();
System.out.println(emp.getFirstName() + " " + emp.getLastName() + " zarabia " + emp.getSalary());
} else {
System.out.println("nie ma minimum");
}
if(max.isPresent()) {
System.out.println("Znaleziono maximum:");
Employee emp = max.get();
System.out.println(emp.getFirstName() + " " + emp.getLastName() + " zarabia " + emp.getSalary());
} else {
System.out.println("nie ma maximum");
}
System.out.println();
String [] stanowiska = {"Programmer", "Shipping Clerk", "Brygadier"};
for (String stanowisko : stanowiska) {
String tekst = lista.stream()
.filter(emp -> Objects.equals(emp.getJobTitle(), stanowisko))
.max(Comparator.comparing(Employee::getSalary))
.map(emp -> emp.getFirstName() + " " + emp.getLastName() + " zarabia " + emp.getSalary())
.orElse("nie ma takiego gościa");
// powyższe map dotyczy Optional, a nie Stream
System.out.println("Najbogatszy " + stanowisko + ": " + tekst);
}
}
}
src/p16_streamy/c_przeglad_operacji/C21_DistinctSorted.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class C21_DistinctSorted {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Magdalena", "Joanna", "Anna", "Teresa", "Ola",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
// distinct i sorted to są opearacje "stateful intermediate"
// one są wykonywane dopiero gdy na strumieniu jest odpalona operacja terminalna
// ale mogą wymagać zebrania większej ilości danych (nawet wszystkich) przed przepuszczeniem elementów do dalszych etapów przetwarzania
// Wynika z tego, że nie powinny być stosowane do strumieni nieskończonych.
String napis = lista.stream()
.distinct()
.map(String::toUpperCase)
.sorted()
.collect(Collectors.joining(", "));
System.out.println(napis);
}
}
src/p16_streamy/c_przeglad_operacji/C22_DistinctSorted.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class C22_DistinctSorted {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Ala", "Magdalena", "Ola", "Joanna", "Anna", "Teresa", "Ola",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
// distinct i sorted to są opearacje "stateful intermediate"
// one są wykonywane dopiero gdy na strumieniu jest odpalona operacja terminalna
// ale mogą wymagać zebrania większej ilości danych (nawet wszystkich) przed przepuszczeniem elementów do dalszych etapów przetwarzania
// Wynika z tego, że nie powinny być stosowane do strumieni nieskończonych.
String napis = lista.stream()
.map(String::toUpperCase)
.peek(s -> System.out.println("start " + s))
.distinct()
.peek(s -> System.out.println("za distinct " + s))
.sorted()
.peek(s -> System.out.println("za sorted " + s))
.collect(Collectors.joining(", "));
System.out.println();
System.out.println(napis);
}
}
src/p16_streamy/c_przeglad_operacji/C23_DistinctSorted.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class C23_DistinctSorted {
public static void main(String[] args) {
String[] tablica = { "Ala", "Ola", "Iwona", "Ala", "Magdalena", "Ola", "Joanna", "Anna", "Teresa", "Ola",
"Żaneta", "Ęcki", "Ącki", "Agnieszka", "ala", "Łucja", "Julia", "Julitta", "Zuzanna" };
List<String> lista = new ArrayList<>(Arrays.asList(tablica));
System.out.println("Przed tworzeniem strumienia");
// distinct i sorted to są opearacje "stateful intermediate"
// one są wykonywane dopiero gdy na strumieniu jest odpalona operacja terminalna
// ale mogą wymagać zebrania większej ilości danych (nawet wszystkich) przed przepuszczeniem elementów do dalszych etapów przetwarzania
// Wynika z tego, że nie powinny być stosowane do strumieni nieskończonych.
String napis = lista.parallelStream()
.map(String::toUpperCase)
.peek(s -> System.out.println("start " + s))
.distinct()
.peek(s -> System.out.println("za distinct " + s))
.sorted()
.peek(s -> System.out.println("za sorted " + s))
.collect(Collectors.joining(", "));
System.out.println();
System.out.println(napis);
}
}
src/p16_streamy/c_przeglad_operacji/C31_TypyProste.java 0 → 100644
package p16_streamy.c_przeglad_operacji;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
public class C31_TypyProste {
public static void main(String[] args) {
DoubleStream losowe = DoubleStream.generate(Math::random);
losowe.limit(100).forEach(x -> System.out.print(x + ", "));
System.out.println();
Random random = new Random();
double sumaLosowych1 = random.doubles().limit(10).sum();
System.out.println(sumaLosowych1);
random.ints(10, 100, 200).forEach(x -> System.out.print(x + ", "));
System.out.println();
LongStream potegi = LongStream.iterate(1, x -> x*2);
potegi.limit(65).forEach(x -> System.out.println(x));
System.out.println();
IntStream.range(0, 10).forEach(x -> System.out.print(x + ", "));
System.out.println();
IntStream.rangeClosed(0, 10).forEach(x -> System.out.print(x + ", "));
IntStream str_int = IntStream.rangeClosed(0, 10);
// tłumaczenie między strumieniem intów a strumieniem Integerów:
Stream<Integer> str_Integer = str_int.boxed();
IntStream str_int2 = str_Integer.mapToInt(Integer::intValue);
// IntStream str_int3 = str_Integer.mapToInt(x -> x);
List<Integer> liczby = IntStream.range(0, 100)
.map(i -> i*i)
.boxed() // zmienia IntStream na Stream<Integer>
.collect(Collectors.toList());
System.out.println(liczby);
}
}
src/p16_streamy/d_redukcje_i_grupowanie/Collect_i_Reduce.java 0 → 100644
package p16_streamy.d_redukcje_i_grupowanie;
import java.util.stream.Stream;
/* collect i reduce to dwa schematy służące do agregacji danych strumienia,
* czyli "zbierania danych" tak, aby na podstawie całego zestawu danych uzyskać pojedynczy wynik.
*
* collect i Collectory - schemat agregacji wykorzystujący klasy mutowalne,
* jako krok operacji podaje się metodę typu void
*
* reduce - schemat agregacji wykorzystujący klasy niemutowalne lub wartości liczbowe
* jako krok operacji podaje się metodę zwracającą wynik
*/
public class Collect_i_Reduce {
public static void main(String[] args) {
String[] imiona = {"Ala", "Ola", "Ela"};
{
StringBuilder wynik = Stream.of(imiona).collect(
StringBuilder::new, // supplier - tworzy początkową "pustą" wartość
StringBuilder::append, // accumulator - aktualizuje wartość na podstawie elementu strumienia
StringBuilder::append); // combiner - łączy częściowe wyniki (które mogą się pojawić gdy mamy parallelStream)
System.out.println("1: " +wynik);
}
// w przypadku strumienia sekwencyjnego można to przetłumaczyć na taką pętlę:
{
StringBuilder wynik = new StringBuilder();
for (String s : imiona) {
wynik.append(s); // tylko wywołanie, wynik tej metody nie jest brany pod uwagę, może być void
}
System.out.println("2: " + wynik);
}
// #################
// Klasa, o którą się opieramy, musi być mutowalna, a operacja (w tym przypadku append)
// musi zmieniać obiekt, na którym jest wołana
// To nie zadziała:
{
String wynik = Stream.of(imiona).collect(
String::new,
String::concat, // concat nie zmienia Strina, na którym jest wołany - więc nie będzie efektu
String::concat);
System.out.println("3: " + wynik);
}
// Dla klas niemutowalnych (i typów prostych) właściwym schematem jest reduce:
{
String wynik = Stream.of(imiona).reduce(
"",
String::concat);
System.out.println("4: " + wynik);
}
// to tłumaczy się na taką pętlę:
{
String wynik = "";
for (String s : imiona) {
wynik = wynik.concat(s); // przypisanie / podmiana wyniku !!!
}
System.out.println("5: " + wynik);
}
// Gdyby "combiner" częściowych wyników różnił się od "accumulatora" pojedynczych wartości,
// podajemy go jako trzeci parametr
{
String wynik = Stream.of(imiona).reduce(
"",
String::concat,
String::concat);
System.out.println("6: " + wynik);
}
// Tu jest taka sytuacja, bo na wejściu mamy strumień Stringów,
// a wynikiem jest int
// pierwsza funkcja jest typu (int, String) -> int
// a druga jest typu (int, int) -> int
{
int wynik = Stream.of(imiona).reduce(
0,
(suma, str) -> suma + str.length(),
Math::addExact);
System.out.println("7: " + wynik);
}
// te ostatnie funkcje ("combiner") są używane tylko gdy parallelStream
}
}
src/p16_streamy/d_redukcje_i_grupowanie/CollectorLaczacyNapisy.java 0 → 100644
package p16_streamy.d_redukcje_i_grupowanie;
import java.util.Collections;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
/* Przykład własnej definicji Collectora.
* Tylko, aby pokazać, jak one działają.
* Collector o funkcjonalności łączenia napisów istnieje: Collectors.joining();
*/
public class CollectorLaczacyNapisy implements Collector<String, StringBuilder, String> {
@Override
public Supplier<StringBuilder> supplier() {
// nie tak: return new StringBullder();
return StringBuilder::new;
}
@Override
public BiConsumer<StringBuilder, String> accumulator() {
return StringBuilder::append; // append(String)
}
@Override
public BinaryOperator<StringBuilder> combiner() {
return StringBuilder::append; // append(StringBuilder)
}
@Override
public Function<StringBuilder, String> finisher() {
return StringBuilder::toString;
}
@Override
public Set<Characteristics> characteristics() {
return Collections.emptySet();
}
}
src/p16_streamy/d_redukcje_i_grupowanie/Collector_Test.java 0 → 100644
package p16_streamy.d_redukcje_i_grupowanie;
import java.util.stream.Collector;
import java.util.stream.Collector.Characteristics;
import java.util.stream.Stream;
public class Collector_Test {
public static void main(String[] args) {
String[] imiona = {"Ala", "Ola", "Ela"};
CollectorLaczacyNapisy collector1 = new CollectorLaczacyNapisy();
String wynik1 = Stream.of(imiona).collect(collector1);
System.out.println(wynik1);
// Ale to samo można zrobić bezpośrednio w kodzie:
// Najpierw wersja, że akumulator staje się wynikiem - nie ma funkcji finisher
Collector<String, StringBuilder, StringBuilder> collector2 =
Collector.of(StringBuilder::new, StringBuilder::append, StringBuilder::append);
StringBuilder wynik2 = Stream.of(imiona).collect(collector2);
System.out.println(wynik2);
// Dodaję finisher równy StringBuilder.toString - ostateczny wynik typu String
Collector<String, StringBuilder, String> collector3 =
Collector.of(StringBuilder::new, StringBuilder::append, StringBuilder::append, StringBuilder::toString);
String wynik3 = Stream.of(imiona).collect(collector3);
System.out.println(wynik3);
}
}
src/p16_streamy/d_redukcje_i_grupowanie/Kolektory1.java 0 → 100644
package p16_streamy.d_redukcje_i_grupowanie;
import java.util.Collection;
import java.util.Comparator;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import emps.v2_obiektowo.Employee;
import emps.v2_obiektowo.ObslugaCSV;
public class Kolektory1 {
public static void main(String[] args) {
//List<Employee> emps = Collections.emptyList();
List<Employee> emps = ObslugaCSV.wczytaj();
// collectory obliczające standardowe funkcje agregujące
Long ilu = emps.stream().collect(Collectors.counting());
Integer suma = emps.stream().collect(Collectors.summingInt(Employee::getSalary));
Double avg = emps.stream().collect(Collectors.averagingInt(Employee::getSalary));
// dla pustego zbioru danych wychodzi 0.0
System.out.println(ilu + ", " + suma + ", " + avg);
// Porównuje pracowników wg pensji
Comparator<Employee> komp = Comparator.comparingInt(Employee::getSalary);
Optional<Employee> min = emps.stream().collect(Collectors.minBy(komp));
Optional<Employee> max = emps.stream().collect(Collectors.maxBy(komp));
System.out.println(min);
System.out.println(max);
// przykład wyciągaia wartości z Optionala
String str1 = min
.map(emp -> emp.getFirstName()
+ " " + emp.getLastName()
+ " / " + emp.getSalary())
.orElse("nie ma takiego gościa");
System.out.println(str1);
System.out.println();
// Oblicza wszystkie 5 standardowe funkcje agregujące
IntSummaryStatistics statystyki = emps.stream().collect(Collectors.summarizingInt(Employee::getSalary));
System.out.println(statystyki);
System.out.println(statystyki.getAverage());
System.out.println();
// Zestaw kolektorów zbierających dane do kolekcji:
List<String> list1 = emps.stream()
.map(Employee::getFirstName)
.sorted()
.distinct()
.collect(Collectors.toList());
System.out.println(list1);
Set<String> set1 = emps.stream()
.map(Employee::getCity)
.collect(Collectors.toSet());
System.out.println(set1);
Collection<String> kolekcja = emps.stream()
.map(Employee::getCity)
.collect(Collectors.toCollection(TreeSet::new));
System.out.println(kolekcja);
System.out.println();
// Tworząc słownik podajemy skąd się biorą klucze, skąd się biorą wartości
// i ewentualnie jak aktualizować już wpisane wartości
Map<String, Integer> grupy = emps.stream()
.collect(Collectors.toMap(Employee::getCity,
Employee::getSalary,
Math::addExact));
grupy.forEach((k,v) -> System.out.printf("%20s -> %10s\n", k, v));
System.out.println();
String txt1 = emps.stream()
.map(Employee::getDepartmentName)
.distinct()
.collect(Collectors.joining());
System.out.println(txt1);
String txt2 = emps.stream()
.map(Employee::getDepartmentName)
.distinct()
.collect(Collectors.joining(", "));
System.out.println(txt2);
String txt3 = emps.stream()
.map(Employee::getDepartmentName)
.distinct()
.collect(Collectors.joining(", ", "<", ">"));
System.out.println(txt3);
}
}
src/p16_streamy/d_redukcje_i_grupowanie/Kolektory2.java 0 → 100644
package p16_streamy.d_redukcje_i_grupowanie;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;
import emps.v2_obiektowo.Employee;
import emps.v2_obiektowo.ObslugaCSV;
public class Kolektory2 {
public static void main(String[] args) {
//List<Employee> emps = Collections.emptyList();
List<Employee> emps = ObslugaCSV.wczytaj();
// grouping by - zbiera elementy w grupy
Map<String, List<Employee>> grupy1 = emps.stream()
.collect(Collectors.groupingBy(Employee::getJobTitle));
grupy1.forEach((k,v) -> {
System.out.println(k);
v.forEach(emp -> {
System.out.printf(" %-12s %-12s %10s\n", emp.getFirstName(), emp.getLastName(), emp.getSalary());
});
});
System.out.println();
// Podajemy dodatkowy kolektor mówiący co robić z każdą grupą
Map<String, Integer> grupy2 = emps.stream()
.collect(Collectors.groupingBy(
Employee::getJobTitle,
Collectors.summingInt(Employee::getSalary)));
grupy2.forEach((k,v) -> {
System.out.printf("%-32s %12s\n", k, v);
});
System.out.println();
// Możemy też podać fabrykę map jako środkowy parametr
Map<String, Integer> grupy3 = emps.stream()
.collect(Collectors.groupingBy(
Employee::getJobTitle,
TreeMap::new,
Collectors.summingInt(Employee::getSalary)));
grupy3.forEach((k,v) -> {
System.out.printf("%-32s %12s\n", k, v);
});
System.out.println();
System.out.println("================");
Map<Boolean, List<Employee>> partycje1 = emps.stream()
.collect(Collectors.partitioningBy(emp -> emp.getSalary() >= 10000));
System.out.println("Bogaci:");
partycje1.get(true)
.forEach(emp -> System.out.println(" " + emp.getLastName()));
System.out.println("\nBiedni:");
partycje1.get(false)
.forEach(emp -> System.out.println(" "+ emp.getLastName()));
System.out.println();
Map<Boolean, Long> partycje2 = emps.stream()
.collect(Collectors.partitioningBy(
emp -> emp.getSalary() >= 10000,
Collectors.counting()));
System.out.println("Bogatych " + partycje2.get(true));
System.out.println("Biednych " + partycje2.get(false));
}
}
src/p16_streamy/d_redukcje_i_grupowanie/Silnia_Reduce.java 0 → 100644
package p16_streamy.d_redukcje_i_grupowanie;
import java.math.BigInteger;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
public class Silnia_Reduce {
static long silniaFun(int n) {
return LongStream.rangeClosed(2, n)
.reduce(1L, (a, i) -> a * i);
}
static long silniaKlasyczna(int n) {
// działa jak taka pętla:
long a = 1L;
for(int i = 2; i <= n; i++) {
a = a * i;
}
return a;
}
static long silniaFun2(int n) {
return LongStream.rangeClosed(2, n)
.reduce(1, Math::multiplyExact);
}
static BigInteger silniaFunBig(int n) {
return IntStream.rangeClosed(2, n)
.mapToObj(BigInteger::valueOf)
.reduce(BigInteger.ONE, BigInteger::multiply);
}
public static void main(String[] args) {
System.out.println(silniaFun(5));
System.out.println(silniaFun2(5));
try {
System.out.println(silniaFun2(21));
} catch (Exception e) {
System.out.println("overflow");
}
System.out.println(silniaFunBig(5));
System.out.println(silniaFunBig(100));
}
}
src/p17_parallel_stream/a/SprawdzanieIleWatkow1.java 0 → 100644
package p17_parallel_stream.a;
import java.util.Arrays;
import java.util.function.IntUnaryOperator;
import java.util.stream.IntStream;
public class SprawdzanieIleWatkow1 {
public static void main(String[] args) {
IntUnaryOperator operacja = x -> {
System.out.println(Thread.currentThread().getId());
return 2*x;
};
int[] tab = new int[100];
Arrays.fill(tab, 33);
System.out.println("Sekwencyjnie:");
int suma1 = IntStream.of(tab).map(operacja).sum();
System.out.println("suma1 = " + suma1);
System.out.println();
System.out.println("Parallel:");
int suma2 = IntStream.of(tab).parallel().map(operacja).sum();
System.out.println("suma2 = " + suma2);
}
}
src/p17_parallel_stream/a/SprawdzanieIleWatkow2.java 0 → 100644
package p17_parallel_stream.a;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.function.IntUnaryOperator;
import java.util.stream.IntStream;
public class SprawdzanieIleWatkow2 {
public static void main(String[] args) {
AtomicIntegerArray array = new AtomicIntegerArray(50);
IntUnaryOperator operacja = x -> {
int id = (int)Thread.currentThread().getId();
array.incrementAndGet(id);
return 2*x;
};
int[] tab = new int[1_000_000];
Arrays.fill(tab, 33);
System.out.println("Tablica wątków na początku:");
System.out.println(array);
int suma2 = IntStream.of(tab).parallel().map(operacja).sum();
System.out.println("suma2 = " + suma2);
System.out.println();
System.out.println("Tablica wątków na końcu:");
System.out.println(array);
int ileWatkow = 0;
for (int i = 0; i < array.length(); i++) {
if(array.get(i) > 0) {
ileWatkow++;
System.out.printf("wątek nr %3d - %8d razy\n", i, array.get(i));
}
}
System.out.println();
System.out.println("W sumie pracowało " + ileWatkow + " wątków.");
System.out.println("Ilość procesorów: " +
Runtime.getRuntime().availableProcessors());
}
}
src/p17_parallel_stream/a/SumArray.java 0 → 100644
package p17_parallel_stream.a;
import java.util.Random;
import java.util.function.LongSupplier;
import java.util.stream.LongStream;
public class SumArray {
static final int N = 120_000_000;
static final int MAX = 1000;
static final int POWTORZENIA = 40;
static long[] tab;
public static void main(String[] args) {
System.out.println("Generuje dane");
tab = new long[N];
wylosuj();
System.out.println("pętla");
testuj(SumArray::petla);
System.out.println("stream");
testuj(SumArray::sekw);
System.out.println("parallel stream");
testuj(SumArray::parallel);
System.out.println();
System.out.println("pętla");
testuj(POWTORZENIA, SumArray::petla);
System.out.println("stream");
testuj(POWTORZENIA, SumArray::sekw);
System.out.println("parallel stream");
testuj(POWTORZENIA, SumArray::parallel);
}
private static void testuj(LongSupplier metoda) {
long start = System.currentTimeMillis();
long wynik = metoda.getAsLong();
long end = System.currentTimeMillis();
System.out.printf("czas: %6d, wynik: %15d\n", end - start, wynik);
}
private static void testuj(int n, LongSupplier metoda) {
long start = System.currentTimeMillis();
long wynik = 0L;
for(int i = 1; i <= n; i++) {
wynik += metoda.getAsLong();
}
long end = System.currentTimeMillis();
System.out.printf("czas: %6d, wynik: %15d\n", end - start, wynik);
}
private static void wylosuj() {
Random r = new Random();
for (int i = 0; i < tab.length; i++) {
tab[i] = r.nextInt(MAX);
}
}
private static long petla() {
long suma = 0L;
for (int i = 0; i < tab.length; i++) {
suma += tab[i];
}
return suma;
}
private static long sekw() {
return LongStream.of(tab).sum();
}
private static long parallel() {
return LongStream.of(tab).parallel().sum();
}
}
src/p17_parallel_stream/b_spliterator/ArrayListSplit.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.ArrayList;
import java.util.List;
import java.util.Spliterator;
import java.util.function.Consumer;
public class ArrayListSplit {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("aaa");
lista.add("bbb");
lista.add("ccc");
lista.add("ddd");
lista.add("eee");
lista.add("fff");
lista.add("ggg");
lista.add("hhh");
lista.add("iii");
lista.add("jjj");
System.out.println(lista);
Consumer<String> akcja = s -> System.out.println("* " + s);
System.out.println("Pętla tryAdvance:");
Spliterator<String> spliterator1 = lista.spliterator();
while(spliterator1.tryAdvance(akcja));
System.out.println();
System.out.println("forEachRemaining:");
Spliterator<String> spliterator2 = lista.spliterator();
spliterator2.forEachRemaining(akcja);
System.out.println();
System.out.println("trySplit 2 poziomy:");
Spliterator<String> spliterator3 = lista.spliterator();
System.out.println("estimate size: " + spliterator3.estimateSize());
Spliterator<String> spliterator3a = spliterator3.trySplit();
System.out.println("Oryginalny:");
spliterator3.forEachRemaining(akcja);
System.out.println("wynik pierwszego split:");
spliterator3a.forEachRemaining(akcja);
System.out.println();
System.out.println("trySplit 3 poziomy:");
Spliterator<String> spliterator4 = lista.spliterator();
System.out.println("estimate size: " + spliterator4.estimateSize());
Spliterator<String> spliterator4a = spliterator4.trySplit();
Spliterator<String> spliterator4b = spliterator4.trySplit();
System.out.println("Oryginalny:");
spliterator4.forEachRemaining(akcja);
System.out.println("wynik pierwszego split:");
spliterator4a.forEachRemaining(akcja);
System.out.println("wynik drugiego split:");
spliterator4b.forEachRemaining(akcja);
System.out.println();
}
}
src/p17_parallel_stream/b_spliterator/LinkedListSplit.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Spliterator;
import java.util.function.Consumer;
// Morał: LinkedList nie dzieli się na fragmenty, więc operacje nie będą zrównoleglane
public class LinkedListSplit {
public static void main(String[] args) {
List<String> lista = new LinkedList<>();
lista.add("aaa");
lista.add("bbb");
lista.add("ccc");
lista.add("ddd");
lista.add("eee");
lista.add("fff");
lista.add("ggg");
lista.add("hhh");
lista.add("iii");
lista.add("jjj");
System.out.println(lista);
Consumer<String> akcja = s -> System.out.println("* " + s);
System.out.println("Pętla tryAdvance:");
Spliterator<String> spliterator1 = lista.spliterator();
while(spliterator1.tryAdvance(akcja));
System.out.println();
System.out.println("forEachRemaining:");
Spliterator<String> spliterator2 = lista.spliterator();
spliterator2.forEachRemaining(akcja);
System.out.println();
System.out.println("trySplit 2 poziomy:");
Spliterator<String> spliterator3 = lista.spliterator();
System.out.println("estimate size: " + spliterator3.estimateSize());
Spliterator<String> spliterator3a = spliterator3.trySplit();
System.out.println("Oryginalny:");
spliterator3.forEachRemaining(akcja);
System.out.println("wynik pierwszego split:");
spliterator3a.forEachRemaining(akcja);
System.out.println();
System.out.println("trySplit 3 poziomy:");
Spliterator<String> spliterator4 = lista.spliterator();
System.out.println("estimate size: " + spliterator4.estimateSize());
Spliterator<String> spliterator4a = spliterator4.trySplit();
Spliterator<String> spliterator4b = spliterator4.trySplit();
System.out.println("4a " + spliterator4a);
System.out.println("4b " + spliterator4b); // null
System.out.println("Oryginalny:");
spliterator4.forEachRemaining(akcja);
System.out.println("wynik pierwszego split:");
spliterator4a.forEachRemaining(akcja);
// NPE
// System.out.println("wynik drugiego split:");
// spliterator4b.forEachRemaining(akcja);
System.out.println();
}
}
src/p17_parallel_stream/b_spliterator/MierzenieCzasu.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.function.LongSupplier;
public class MierzenieCzasu {
public static void uruchom(LongSupplier metoda) {
long start = System.nanoTime();
long wynik = metoda.getAsLong();
long end = System.nanoTime();
System.out.printf("czas: %12d , wynik = %d\n", (end - start) / 1000, wynik);
}
public static void uruchom(int n, LongSupplier metoda) {
long start = System.currentTimeMillis();
long wynik = 0L;
for(int i = 1; i <= n; i++) {
wynik += metoda.getAsLong();
}
long end = System.currentTimeMillis();
System.out.printf("czas: %6d, wynik: %15d\n", end - start, wynik);
}
}
src/p17_parallel_stream/b_spliterator/SpliteratorLiczbyNieparzyste.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.Spliterator;
import java.util.function.Consumer;
public class SpliteratorLiczbyNieparzyste implements Spliterator<Integer> {
private int max;
private int min;
// domyślnie 100 liczb
public SpliteratorLiczbyNieparzyste() {
this(100);
}
public SpliteratorLiczbyNieparzyste(int ile) {
this(0, ile);
}
private SpliteratorLiczbyNieparzyste(int min, int max) {
this.min = min;
this.max = max;
}
private int next() {
return 1 + 2 * min++;
}
private boolean hasNext() {
return min < max;
}
@Override
public boolean tryAdvance(Consumer<? super Integer> action) {
if(hasNext()) {
action.accept(this.next());
return true;
} else {
return false;
}
}
@Override
public SpliteratorLiczbyNieparzyste trySplit() {
int middle = (max + min) / 2;
SpliteratorLiczbyNieparzyste nowy = new SpliteratorLiczbyNieparzyste(min, middle);
min = middle;
return nowy;
}
@Override
public long estimateSize() {
return max - min;
}
@Override
public int characteristics() {
return ORDERED | DISTINCT | SIZED | SUBSIZED | NONNULL;
}
}
src/p17_parallel_stream/b_spliterator/SpliteratorPowolny.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.Spliterator;
import java.util.function.Consumer;
public class SpliteratorPowolny implements Spliterator<Integer> {
private int max;
private int min;
private int niepotrzebne;
private final int SPOWOLNIENIE = 10000;
// domyślnie 100 liczb
public SpliteratorPowolny() {
this(100);
}
public SpliteratorPowolny(int ile) {
this(0, ile);
}
private SpliteratorPowolny(int min, int max) {
this.min = min;
this.max = max;
}
private int next() {
for(int i=0; i<SPOWOLNIENIE; i++) {
niepotrzebne++;
}
return 1 + 2 * min++;
}
private boolean hasNext() {
return min < max;
}
@Override
public boolean tryAdvance(Consumer<? super Integer> action) {
action.accept(this.next());
return hasNext();
}
@Override
public SpliteratorPowolny trySplit() {
int middle = (max + min) / 2;
SpliteratorPowolny nowy = new SpliteratorPowolny(min, middle);
min = middle;
return nowy;
}
@Override
public long estimateSize() {
return max - min;
}
@Override
public int characteristics() {
return ORDERED | DISTINCT | SIZED | SUBSIZED | NONNULL;
}
}
src/p17_parallel_stream/b_spliterator/SpliteratorPrimitive.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.Spliterator;
import java.util.function.IntConsumer;
public class SpliteratorPrimitive implements Spliterator.OfInt {
private int max;
private int min;
// domyślnie 100 liczb
public SpliteratorPrimitive() {
this(100);
}
public SpliteratorPrimitive(int ile) {
this(0, ile);
}
private SpliteratorPrimitive(int min, int max) {
this.min = min;
this.max = max;
}
private int next() {
return 1 + 2 * min++;
}
private boolean hasNext() {
return min < max;
}
@Override
public boolean tryAdvance(IntConsumer action) {
action.accept(this.next());
return hasNext();
}
@Override
public SpliteratorPrimitive trySplit() {
int middle = (max + min) / 2;
SpliteratorPrimitive nowy = new SpliteratorPrimitive(min, middle);
min = middle;
return nowy;
}
@Override
public long estimateSize() {
return max - min;
}
@Override
public int characteristics() {
return ORDERED | DISTINCT | SIZED | SUBSIZED | NONNULL;
}
}
src/p17_parallel_stream/b_spliterator/Test1.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public class Test1 {
// Stream<Integer> bez spowalniania. Niepotrzebny narzut na boxing
public static void main(String[] args) {
SpliteratorLiczbyNieparzyste spl1 = new SpliteratorLiczbyNieparzyste(10000000);
Stream<Integer> str1 = StreamSupport.stream(spl1, false);
MierzenieCzasu.uruchom(() -> str1.mapToInt(x->x).sum());
SpliteratorLiczbyNieparzyste spl2 = new SpliteratorLiczbyNieparzyste(10000000);
Stream<Integer> str2 = StreamSupport.stream(spl2, true);
MierzenieCzasu.uruchom(() -> str2.mapToInt(x->x).sum());
System.out.println();
}
}
src/p17_parallel_stream/b_spliterator/Test2.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.Spliterator;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public class Test2 {
// Spliterator sztucznie spowolniony, Stream<Integer>, widać zysk z parallel
public static void main(String[] args) {
Spliterator<Integer> spl1 = new SpliteratorPowolny(10000000);
Stream<Integer> str1 = StreamSupport.stream(spl1, false);
MierzenieCzasu.uruchom(() -> str1.mapToLong(x->x).sum());
Spliterator<Integer> spl2 = new SpliteratorPowolny(10000000);
Stream<Integer> str2 = StreamSupport.stream(spl2, true);
MierzenieCzasu.uruchom(() -> str2.mapToLong(x->x).sum());
}
}
src/p17_parallel_stream/b_spliterator/Test3.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;
public class Test3 {
public static void main(String[] args) {
// IntStream bez żadnego boxingnu - działa najszybciej
SpliteratorPrimitive spl1 = new SpliteratorPrimitive(10000000);
IntStream str1 = StreamSupport.intStream(spl1, false);
MierzenieCzasu.uruchom(() -> str1.sum());
SpliteratorPrimitive spl2 = new SpliteratorPrimitive(10000000);
IntStream str2 = StreamSupport.intStream(spl2, true);
MierzenieCzasu.uruchom(() -> str2.sum());
}
}
src/p17_parallel_stream/b_spliterator/TestNieparzyste.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.Spliterator;
import java.util.function.Consumer;
public class TestNieparzyste {
public static void main(String[] args) {
Consumer<Integer> akcja = i -> System.out.print(i + ", ");
SpliteratorLiczbyNieparzyste spl1 = new SpliteratorLiczbyNieparzyste(100);
spl1.forEachRemaining(akcja);
System.out.println();
System.out.println();
Spliterator<Integer> spl2 = new SpliteratorLiczbyNieparzyste(100);
Spliterator<Integer> a = spl2.trySplit();
Spliterator<Integer> b = a.trySplit();
System.out.println("Fragmenty:");
b.forEachRemaining(akcja);
System.out.println();
a.forEachRemaining(akcja);
System.out.println();
spl2.forEachRemaining(akcja);
System.out.println();
System.out.println();
}
}
src/p17_parallel_stream/b_spliterator/TestStrumienNieparzystych.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public class TestStrumienNieparzystych {
public static void main(String[] args) {
Consumer<Integer> akcja = i -> System.out.print(i + ", ");
SpliteratorLiczbyNieparzyste spl1 = new SpliteratorLiczbyNieparzyste(100);
Stream<Integer> str1 = StreamSupport.stream(spl1, false);
str1.forEach(akcja);
System.out.println();
System.out.println();
SpliteratorLiczbyNieparzyste spl2 = new SpliteratorLiczbyNieparzyste(100);
Stream<Integer> str2 = StreamSupport.stream(spl2, true);
str2.forEach(akcja);
System.out.println();
System.out.println();
SpliteratorLiczbyNieparzyste spl3 = new SpliteratorLiczbyNieparzyste(50);
Stream<Integer> str3 = StreamSupport.stream(spl3, false);
int suma3 = str3.mapToInt(x -> x).sum();
System.out.println(suma3);
SpliteratorLiczbyNieparzyste spl4 = new SpliteratorLiczbyNieparzyste(50);
Stream<Integer> str4 = StreamSupport.stream(spl4, true);
int suma4 = str4.mapToInt(x -> x).sum();
System.out.println(suma4);
}
}
src/p17_parallel_stream/b_spliterator/TestStrumienPrimite.java 0 → 100644
package p17_parallel_stream.b_spliterator;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;
public class TestStrumienPrimite {
public static void main(String[] args) {
IntConsumer akcja = i -> System.out.print(i + ", ");
SpliteratorPrimitive spl1 = new SpliteratorPrimitive(100);
IntStream str1 = StreamSupport.intStream(spl1, false);
str1.forEach(akcja);
System.out.println();
}
}
src/p20_pliki/CzytajPlik_BufferedReader1.java
......@@ -9,7 +9,7 @@ public class CzytajPlik_BufferedReader1 {
public static void main(String[] args) {
// BufferedReader działa szybciej niż Scanner, ale potrafi mniej niż Scanner
// Tutaj używamy starszego sposobu tworzenia obiektu BufferedReader
try(BufferedReader reader = new BufferedReader(new FileReader("nowy3.txt"))) {
try(BufferedReader reader = new BufferedReader(new FileReader("plik.txt"))) {
while(true) {
String line = reader.readLine();
if(line == null) break; // koniec pliku
......
src/p20_pliki/CzytajPlik_BufferedReader2.java
......@@ -11,7 +11,7 @@ public class CzytajPlik_BufferedReader2 {
// BufferedReader działa szybciej niż Scanner, ale potrafi mniej niż Scanner
// Tutaj używamy nowszego sposobu tworzenia obiektu BufferedReader - za pośrednictwem klasy Files
// Inaczej zapiszemy też warunek pętli.
try(BufferedReader reader = Files.newBufferedReader(Paths.get("nowy3.txt"))) {
try(BufferedReader reader = Files.newBufferedReader(Paths.get("plik.txt"))) {
String line;
while((line = reader.readLine()) != null) {
System.out.println(line);
......
src/p20_pliki/CzytajPlik_Scanner.java
......@@ -12,7 +12,7 @@ public class CzytajPlik_Scanner {
// new File("C:/Users/patryk/Documents/plik.txt")
public static void main(String[] args) {
try(Scanner scanner = new Scanner(new File("nowy3.txt"))) {
try(Scanner scanner = new Scanner(new File("plik.txt"))) {
while(scanner.hasNextLine()) {
String line = scanner.nextLine();
System.out.println(line);
......
src/p29_daty/DataICzas.java 0 → 100644
package p29_daty;
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.temporal.ChronoField;
public class DataICzas {
public static void main(String[] args) {
// Która godzina jest w innej strefie czasowej
LocalDateTime dt2 = LocalDateTime.now(ZoneId.of("UTC-4"));
System.out.println(dt2);
LocalDateTime dt = LocalDateTime.now();
System.out.println(dt);
// Metody "with" modyfikują wybrane pole i zwracają wmieniony obiekt
dt.with(ChronoField.HOUR_OF_DAY, 17);
System.out.println(dt); // nie widać zmiany, bo dato-czasy są immutable
// przypisanie na zmienną dt zapisuje zmieniony obiekt
dt = dt.with(ChronoField.HOUR_OF_DAY, 17);
System.out.println(dt);
dt = dt.withDayOfMonth(13);
System.out.println(dt);
dt = dt.withDayOfYear(200);
System.out.println(dt);
dt = dt.with(ChronoField.SECOND_OF_DAY, 12360);
System.out.println(dt);
try {
dt = dt.with(ChronoField.OFFSET_SECONDS, 7200);
System.out.println(dt);
} catch (Exception e) {
System.out.println("Był wyjątek " + e.getClass() + " " + e.getMessage());
}
dt = LocalDateTime.now();
System.out.println(dt);
OffsetDateTime przesuniety = dt.atOffset(ZoneOffset.ofHours(5));
System.out.println(przesuniety);
dt = LocalDateTime.parse("2019-05-08T14:55:04.360");
System.out.println(dt);
dt = LocalDateTime.parse("2019-05-08T14:55");
System.out.println(dt);
dt = LocalDateTime.parse("2019-05-08T14:55:00");
System.out.println(dt); // sekundy równe zero w ogóle się nie wypisują
}
}
src/p29_daty/Formatowanie1_Standardy.java 0 → 100644
package p29_daty;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
public class Formatowanie1_Standardy {
public static void main(String[] args) {
LocalDateTime teraz = LocalDateTime.now();
DateTimeFormatter[] formats = {
DateTimeFormatter.BASIC_ISO_DATE,
DateTimeFormatter.ISO_DATE,
DateTimeFormatter.ISO_DATE_TIME,
DateTimeFormatter.ISO_LOCAL_DATE_TIME,
DateTimeFormatter.ISO_ORDINAL_DATE,
DateTimeFormatter.ISO_WEEK_DATE,
};
System.out.println("Format domyslny:");
System.out.println(teraz.toString());
System.out.println(LocalDate.now().toString());
System.out.println(LocalTime.now().toString());
System.out.println();
for (DateTimeFormatter df : formats) {
// formatowanie można wywoływać na dwa sposoby
System.out.println(teraz.format(df));
System.out.println(df.format(teraz));
}
}
}
src/p29_daty/Formatowanie2_Jezykowo.java 0 → 100644
package p29_daty;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Locale;
public class Formatowanie2_Jezykowo {
public static void main(String[] args) {
ZonedDateTime teraz = ZonedDateTime.now();
DateTimeFormatter df = DateTimeFormatter
.ofLocalizedDateTime(FormatStyle.FULL)
.withLocale(new Locale("ru", "RU"));
System.out.println(teraz.format(df));
}
}
src/p29_daty/Formatowanie3_Jezykowo_BezStrefy.java 0 → 100644
package p29_daty;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Locale;
public class Formatowanie3_Jezykowo_BezStrefy {
public static void main(String[] args) {
LocalDateTime teraz = LocalDateTime.now();
Locale[] locales = {
new Locale("pl", "PL"),
new Locale("pl"),
new Locale("fr", "FR"),
new Locale("de", "DE"),
new Locale("es", "ES"),
new Locale("it", "IT"),
new Locale("ru", "RU"),
new Locale("ja", "JP"),
new Locale("ar", "EY"),
new Locale("en", "GB"),
new Locale("en", "US"),
new Locale("en")
};
FormatStyle[] styles = {
//FormatStyle.FULL,
//FormatStyle.LONG,
FormatStyle.MEDIUM,
FormatStyle.SHORT
};
for(Locale locale : locales) {
System.out.println("\nLOCALE " + locale);
for(FormatStyle style : styles) {
DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(style);
System.out.println(teraz.format(df));
}
}
}
}
src/p29_daty/Formatowanie4_Jezykowo_Strefa.java 0 → 100644
package p29_daty;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Locale;
public class Formatowanie4_Jezykowo_Strefa {
public static void main(String[] args) {
ZonedDateTime teraz = ZonedDateTime.now();
Locale[] locales = {
new Locale("pl", "PL"),
new Locale("pl"),
new Locale("fr", "FR"),
new Locale("de", "DE"),
new Locale("es", "ES"),
new Locale("it", "IT"),
new Locale("ru", "RU"),
new Locale("ja", "JP"),
new Locale("ar", "EY"),
new Locale("en", "GB"),
new Locale("en", "US"),
new Locale("en")
};
FormatStyle[] styles = {
FormatStyle.FULL,
FormatStyle.LONG,
FormatStyle.MEDIUM,
FormatStyle.SHORT
};
for(Locale locale : locales) {
System.out.println("\nLOCALE " + locale);
for(FormatStyle style : styles) {
DateTimeFormatter df = DateTimeFormatter
.ofLocalizedDateTime(style)
.withLocale(locale);
System.out.println(teraz.format(df));
System.out.println(df.format(teraz));
}
}
}
}
src/p29_daty/Formatowanie5_Pattern.java 0 → 100644
package p29_daty;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
public class Formatowanie5_Pattern {
public static void main(String[] args) {
ZonedDateTime teraz = ZonedDateTime.now();
DateTimeFormatter df = DateTimeFormatter.ofPattern("YYYY-MM-dd");
System.out.println(teraz.format(df));
df = DateTimeFormatter.ofPattern("dd.MM.YY");
System.out.println(teraz.format(df));
df = DateTimeFormatter.ofPattern("dd.MM.YYY");
System.out.println(teraz.format(df));
df = DateTimeFormatter.ofPattern("d M Y");
System.out.println(teraz.format(df));
df = DateTimeFormatter.ofPattern("dd MM YY");
System.out.println(teraz.format(df));
df = DateTimeFormatter.ofPattern("e dd MMM");
System.out.println(teraz.format(df));
df = DateTimeFormatter.ofPattern("EEE, dd MMMM");
System.out.println(teraz.format(df));
df = DateTimeFormatter.ofPattern("EEEE, dd MMMMM");
System.out.println(teraz.format(df));
}
}
src/p29_daty/Formatowanie6_Parse.java 0 → 100644
package p29_daty;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Formatowanie6_Parse {
public static void main(String[] args) {
LocalDateTime data = LocalDateTime.now();
DateTimeFormatter df = DateTimeFormatter.ofPattern("EEEE,yyyyMMdd HH@mm");
System.out.println(data.format(df));
System.out.println(data);
System.out.println();
data = LocalDateTime.parse("wtorek,19981208 12@13", df);
System.out.println(data);
}
}
src/p29_daty/Okresy.java 0 → 100644
package p29_daty;
import java.time.LocalDate;
import java.time.Period;
public class Okresy {
public static void main(String[] args) {
LocalDate d1 = LocalDate.parse("2015-05-13");
LocalDate d2 = LocalDate.parse("2016-09-11");
Period p1 = Period.between(d1, d2);
System.out.println(p1);
Period p2 = Period.of(3, 14, 44);
System.out.println(p2);
LocalDate dzisiaj = LocalDate.now();
LocalDate przyszlosc1 = dzisiaj.plus(p2);
System.out.println(przyszlosc1);
LocalDate przyszlosc2 = (LocalDate) p2.addTo(dzisiaj);
System.out.println(przyszlosc2);
Period p3 = p2.normalized();
System.out.println(p3); // miesiące są normalizowane (miesiące powyżej 12 są zamieniane na lata), ale dni nie, bo się nie da
System.out.println();
Period p4 = Period.parse("P3M2W10D"); // tygodnie od razu przeliczają się na dni, ale miesiące nie przeliczają się na lata
System.out.println(p4);
Period p5 = Period.ofWeeks(3);
System.out.println(p5);
Period p6 = Period.ofDays(50);
System.out.println(p6);
}
}
src/p29_daty/Porownywanie.java 0 → 100644
package p29_daty;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collections;
public class Porownywanie {
public static void main(String[] args) {
LocalDate d1 = LocalDate.now();
LocalDate d2 = LocalDate.of(2016, 12, 7);
LocalDate d3 = LocalDate.parse("2016-04-04");
System.out.println(d1.equals(d2)); // T
System.out.println(d1.equals(d3)); // F
if(d1.compareTo(d3) > 0) {
System.out.println("d1 później niż d3");
} else {
System.out.println("d1 wcześniej niż d3");
}
if(d1.isAfter(d3)) {
System.out.println("d1 później niż d3");
} else {
System.out.println("d1 wcześniej niż d3");
}
ArrayList<LocalDate> daty = new ArrayList<>();
daty.add(LocalDate.of(2015, 12, 24));
daty.add(LocalDate.of(2016, 9, 24));
daty.add(LocalDate.of(2015, 3, 11));
daty.add(LocalDate.of(2016, 8, 8));
System.out.println(daty);
Collections.sort(daty);
System.out.println(daty);
}
}
src/p29_daty/ProsteDaty.java 0 → 100644
package p29_daty;
import java.time.LocalDate;
import java.time.Month;
import java.time.Period;
public class ProsteDaty {
public static void main(String[] args) {
LocalDate data1 = LocalDate.now();
System.out.println(data1);
LocalDate data2 = LocalDate.of(2016, 12, 5);
System.out.println(data2);
LocalDate data3 = LocalDate.of(2016, Month.DECEMBER, 5);
System.out.println(data3);
LocalDate data4 = LocalDate.parse("2016-12-05");
System.out.println(data4);
LocalDate data5 = LocalDate.parse("2016-02-29");
System.out.println(data5);
// LocalDate data6 = LocalDate.parse("2015-02-29");
// System.out.println(data6);
// najpierw starsza potem pozniejsza
Period czasTrwania = Period.between(data4, data1);
System.out.println(czasTrwania);
System.out.println(czasTrwania.getDays());
}
}
src/p29_daty/ProstyCzas.java 0 → 100644
package p29_daty;
import java.time.LocalTime;
public class ProstyCzas {
public static void main(String[] args) {
LocalTime czas1 = LocalTime.now(); // ustawia z dokladnoscia do milisekundy
System.out.println(czas1);
// uwaga: można utworzyć czas nie podając sekund
LocalTime czas2 = LocalTime.of(12, 15);
System.out.println(czas2);
LocalTime czas3 = LocalTime.of(12, 15, 33);
System.out.println(czas3);
// uwaga: nanosekumdy podajemy jako liczbę całkowitą (int)
LocalTime czas4 = LocalTime.of(12, 15, 33, 333222111);
System.out.println(czas4);
// to oznacza jedną nanosekundę (miliardową część sekundy),
// a nie jedną dizesiątą sekundy
LocalTime czas5 = LocalTime.of(12, 15, 33, 1);
System.out.println(czas5);
}
}
src/p29_daty/PrzykladInstant.java 0 → 100644
package p29_daty;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class PrzykladInstant {
public static void main(String[] args) {
Instant czas = Instant.now();
System.out.println(czas);
ZonedDateTime uNas = czas.atZone(ZoneId.systemDefault());
System.out.println(uNas);
ZonedDateTime zoned = ZonedDateTime.now();
System.out.println(zoned);
}
}
src/p29_daty/StareFormatowanieDat.java 0 → 100644
package p29_daty;
import java.text.DateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
public class StareFormatowanieDat {
public static void display(Date date, Locale locale) {
DateFormat df;
df = DateFormat.getDateInstance(DateFormat.DEFAULT, locale);
System.out.println("Date DEFAULT: " + df.format(date));
df = DateFormat.getDateInstance(DateFormat.FULL, locale);
System.out.println("Date FULL: " + df.format(date));
df = DateFormat.getDateInstance(DateFormat.LONG, locale);
System.out.println("Date LONG: " + df.format(date));
df = DateFormat.getDateInstance(DateFormat.MEDIUM, locale);
System.out.println("Date MEDIUM: " + df.format(date));
df = DateFormat.getDateInstance(DateFormat.SHORT, locale);
System.out.println("Date SHORT: " + df.format(date));
df = DateFormat.getTimeInstance(DateFormat.DEFAULT, locale);
System.out.println("Time DEFAULT: " + df.format(date));
df = DateFormat.getTimeInstance(DateFormat.FULL, locale);
System.out.println("Time FULL: " + df.format(date));
df = DateFormat.getTimeInstance(DateFormat.LONG, locale);
System.out.println("Time LONG: " + df.format(date));
df = DateFormat.getTimeInstance(DateFormat.MEDIUM, locale);
System.out.println("Time MEDIUM: " + df.format(date));
df = DateFormat.getTimeInstance(DateFormat.SHORT, locale);
System.out.println("Time SHORT: " + df.format(date));
//Tu już tylko przykładowo
df = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, locale);
System.out.println("DateTime DEFAULT DEFAULT: " + df.format(date));
df = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.SHORT, locale);
System.out.println("DateTime LONG SHORT: " + df.format(date));
}
public static void main(String[] args) {
Locale[] all = {
new Locale("pl", "PL"),
new Locale("pl"),
new Locale("de", "DE"),
new Locale("fr", "FR"),
new Locale("ru", "RU"),
new Locale("es", "ES"),
new Locale("it", "IT"),
new Locale("ja", "JP"),
new Locale("ar", "EY"),
new Locale("en", "GB"),
new Locale("en", "US"),
new Locale("en") };
Date now = Calendar.getInstance().getTime();
DateFormat df = DateFormat.getInstance();
System.out.println("domyślnie: " + df.format(now));
for (Locale locale : all) {
System.out.println("Dla locali " + locale.toString());
display(now, locale);
System.out.println();
}
}
}
src/p29_daty/WypiszDostepneLocale.java 0 → 100644
package p29_daty;
import java.text.DateFormat;
import java.util.Locale;
import java.util.Locale.Category;
public class WypiszDostepneLocale {
public static void main(String[] args) {
System.out.println("DEFAULT: "+Locale.getDefault());
System.out.println("DISPLAY: "+Locale.getDefault(Category.DISPLAY));
System.out.println("FORMAT: "+Locale.getDefault(Category.FORMAT));
for (Locale loc : DateFormat.getAvailableLocales()) {
System.out.println(loc.toString() + " " + loc.getDisplayLanguage() + "/" + loc.getDisplayCountry() );
}
}
}
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