Java

Spis treści

• Operacje na stringach

  • Długość stringa
  • Porównanie stringów
  • Formatowanie stringów
  • Substring
  • Zamiana Stringa na liczbę

• Parsowanie daty

• Operacje na datach

• Operacje na czasie (godziny, minuty, sekundy)

• Czytanie pliku po liniach

• Czytanie kolumn lini / rozdzielanie stringa

  • Użycie .split()

• Sortowanie typów prostych w liście (np. integery)

• Sortowanie obiektów w liście

• Zapisywanie do pliku / pisanie do pliku

• Operacje na folderach

  • Odczyt po zagnieżdżonych folderach

• Struktury danych

  • Lista (dynamiczna tablica)
  • Hashmap
  • HashSet

Operacje na stringach

// 1. trimStringtext = " Hello World ";
text.trim(); // " Hello World " -> "Hello World"// 2. toLowerCaseStringtext = "HELLO WORLD";
text.toLowerCase(); // "hello world"// 3. toUpperCaseStringtext = "hello world";
text.toUpperCase() // "HELLO WORLD"// 4. replaceStringtext = "21,37";
text.replace(",", ".") // "21.37"Stringtext = "cat cat cat";
text.replace("cat", "dog"); // "dog dog dog"// 5. replaceFirstStringtext = "cat cat cat";
text.replaceFirst("cat", "dog"); // "dog cat cat"

Uwaga - powyższe metody zwracają NOWEGO stringa bez modyfikacji oryginalnego.

Długość stringa

"123".length() // 3

Porównanie stringów

Lepiej używać .equals() niż == do porównywania stringów

Stringname = "John";
if (name.equals("John")) {
System.out.println("Lepiej używać .equals niż == do porównywania stringów");
}
// inne przydatne metody zwracające wartość logiczną:Stringtext = "Hello World";
text.startsWith("Hello"); // truetext.endsWith("World"); // truetext.contains("llo"); // truetext.isEmpty(); // false

Formatowanie stringów

Stringname = "John Doe";
String.format("My name is: %s", name) // My name is: John Doe// formatowanie ułamków - %.1f oznacza jedno miejsce po przecinku, %.2f oznaczałoby 2 miejsca itd...// Locale.ENGLISH jest używane by ułamek był oddzielany przez kropkę zamiast przecinek (domyślnie)doublex = 21.37;
String.format(Locale.ENGLISH, "x=%.1f", x); // x=21.4intx = 21;
String.format(Locale.ENGLISH, "x=%d", x); // x=21// Łączenie stringów"Hello, my name is: " + name// Hello, my name is John Doe

Substring

Stringtext = "Test: 233";
text.substring(6) // "233"text.substring(0, 4) // "Test"

Zamiana Stringa na liczbę

Integer.parseInt("500") // 500 ale jako intDouble.parseDouble("500.244") // 500.244 jako double

Czasami dane mogą zawierać ułamek z przecinkiem więc musimy to przekształcić przed parsowaniem:

StringsomeData = "200,4";
Double.parseDouble(someData.replace(",", ".")); // 200.4 jako double

Parsowanie daty

importjava.time.LocalDate;
importjava.time.format.DateTimeFormatter;
publicclassDateUtils {
privatestaticfinalStringDATE_FORMAT = "M/d/yy"; // np. 4/6/20publicstaticLocalDatetoDate(StringdateStr) {
DateTimeFormatterformatter = DateTimeFormatter.ofPattern(DATE_FORMAT);
returnLocalDate.parse(dateStr, formatter);
}
publicstaticStringtoStringDate(LocalDatedate) {
DateTimeFormatterformatter = DateTimeFormatter.ofPattern(DATE_FORMAT);
returnformatter.format(date);
}
}

Operacje na datach

DateTimeFormatterformatter = DateTimeFormatter.ofPattern("dd-MM-yyyy");
LocalDateotherDate = LocalDate.parse("10-07-2010", formatter);
LocalDatetoday = LocalDate.now(); // 2024-04-26 (pobranie dzisiejszej daty)// porównywanie dat:today.isAfter(otherDate); // truetoday.isBefore(otherDate); // false// naiwne obliczenie różnicy latintdiff = today.getYear() - otherDate.getYear();
System.out.printf("Jest %d lat różnicy\n", diff); // "Jest 14 lat różnicy"// dokładniejsze obliczenie różnicy latintdiff2 = Period.between(otherDate, today).getYears();
System.out.printf("Jest %d lat różnicy\n", diff2); // "Jest 13 lat różnicy"

Operacje na czasie

LocalTimetime = LocalTime.of(23, 2, 2); // 23:02:02DateTimeFormatterformatter = DateTimeFormatter.ofPattern("HH:mm:ss"); // HH - oznacza 24h formatDateTimeFormatterformatter12h = DateTimeFormatter.ofPattern("h:mm:ss a", Locale.ENGLISH); // hh - 12h formatformatter.format(time); // "23:02:02"formatter12h.format(time); // "11:02:02 PM"LocalTimenow = LocalTime.now(); // 21:33:51// formatowanie obecnego czasuformatter.format(now); // "21:33:51"now.isAfter(time); // falsenow.isBefore(time); // true

Czytanie pliku po liniach

importjava.io.IOException;
importjava.nio.file.Files;
importjava.nio.file.Path;
importjava.nio.file.Paths;
importjava.util.Iterator;
importjava.util.stream.Stream;
publicclassReadFile {
publicstaticvoidreadLines(Stringfilename) throwsIOException {
Pathpath = Paths.get(filename);
if (Files.notExists(path)) { // albo: !Files.exists(path)// sprawdzenie czy plik nie istnieje (czasem wymagane w zadaniach)System.out.println("Plik nie istnieje");
}
Stream<String> lines = Files.lines(path);
// Kilka sposobów na iteracje po liniach// 1. Lambdalines.forEach((line) -> {
System.out.println(line);
});
// 2. Referencja do metodylines.forEach(System.out::println);
// 3. IteratorIterator<String> it = lines.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}

Przekształcanie, filtrowanie linijek

Więcej przykładów: Stream guide

Pathpath = Paths.get(filename);
Stream<String> lines = Files.lines(path);
lines.skip(100) // jeżeli chcemy pominać 100 linijek
.map(String::toLowerCase) // jeżeli chcemy każdą pojedynczą linię przekształcić
.filter(line -> line.startsWith("...")) // filtrowanie linijek po zawartości

Czytanie kolumn lini / rozdzielanie stringa

importjava.util.StringTokenizer;
publicclassReadColumns {
privatestaticfinalStringDELIMITER = ";"; // przyjrzyjcie sie dokładnie jaki jest separator w pliku .csv (zazwyczaj "," ";" "|")publicstaticvoidsplitLine(Stringline) {
StringTokenizertokenizer = newStringTokenizer(line, DELIMITER);
// tokenizer działa podobnie jak iteratorwhile (tokenizer.hasMoreTokens()) {
System.out.println(tokenizer.nextToken());
}
}
}

użycie .split()

Stringtext = "Germany;Poland;Ukraine";
String[] countries = text.split(";");
System.out.println(countries[0]);
System.out.println(countries[1]);
System.out.println(countries[2]);

Sugeruję zawsze jeżeli to możliwe dać drugi parametr gdzie uwzględniamy limit elementów.

// UWAGA - PułapkaStringtext = "Germany;;";
String[] countries = text.split(";");
System.out.println(countries[0]);
System.out.println(countries[1]); // ERRORSystem.out.println(countries[2]);
// FIX:Stringtext = "Germany;;";
String[] countries = text.split(";", 3);
System.out.println(countries[0]);
System.out.println(countries[1]);
System.out.println(countries[2]);

Sortowanie typów prostych w liście (np. integery)

importjava.util.ArrayList;
importjava.util.Collections;
importjava.util.List;
publicclassSort {
List<Integer> list;
Sort() {
list = newArrayList<Integer>();
list.add(6);
list.add(2);
list.add(100);
list.add(4);
}
publicvoidsimpleSort() {
// Collections.sort modyfikuje przekazaną listęCollections.sort(list); // [2, 4, 6, 100]System.out.println(list);
// Collections.reverse NIE SORTUJE - po prostu odwraca nam listęCollections.reverse(list); // [100, 6, 4, 2]System.out.println(list);
}
}

Sortowanie obiektów w liście

importjava.util.ArrayList;
importjava.util.Comparator;
importjava.util.List;
publicclassSort {
List<DeathStat> list;
Sort() {
list = newArrayList<DeathStat>();
list.add(newDeathStat("Dęblin", 10));
list.add(newDeathStat("Ryki", 5));
list.add(newDeathStat("Lublin", 100));
list.add(newDeathStat("Puławy", 20));
}
publicvoidobjectSort() {
// Używamy komparatora - musimy przekazać lambdę/referencje do metody która zwraca inta (dla .comparingInt)// jeżeli chcemy posortować (najmniejszy -> największy)list.sort(Comparator.comparingInt(DeathStat::getCount));
// jeżeli chcemy posortować odwrotnie (największy -> najmniejszy)list.sort(Comparator.comparingInt(DeathStat::getCount).reversed());
}
}

publicclassDeathStat {
privatefinalintcount;
privatefinalStringcity;
DeathStat(Stringcity, intcount) {
this.count = count;
this.city = city;
}
intgetCount() {
returnthis.count;
}
}

Zapisywanie do pliku / pisanie do pliku

importjava.io.BufferedWriter;
importjava.io.FileWriter;
importjava.io.IOException;
publicclassSaveFile {
publicstaticvoidsave(Stringfilename) throwsIOException {
BufferedWriterwriter = newBufferedWriter(newFileWriter(filename));
writer.write("<body>\n");
writer.write("<h1>Hello World</h1>\n");
writer.write("</body>");
writer.close(); // WAŻNE: jak zapomnimy zamknąć bufora to nie zobaczymy nic w pliku
}
}

Operacje na folderach

Powiedzmy, że mam taki folder i chcę wyświetlić tylko pliki .txt:

importjava.io.IOException;
importjava.nio.file.Files;
importjava.nio.file.Path;
importjava.nio.file.Paths;
publicclassMain {
publicstaticvoidmain(String[] args) throwsIOException {
PathdirPath = Paths.get("mydir");
Files.isDirectory(dirPath); // true// przeszukiwanie folderu:// maxDepth = 1 - czyli przeszukuje 1 poziom zagnieżdżenia folderówFiles.find(dirPath, 1, (path, __) -> {
returnpath.getFileName().toString().endsWith(".txt") && Files.isRegularFile(path);
}).forEach((path) -> System.out.println(path.getFileName()));
/* OUTPUT: file1.txt file2.txt */
}
}

Odczyt po zagnieżdżonych folderach

PathdirPath = Paths.get("mydir");
// maxDepth = 2 - czyli przeszukuje 2 poziomy zagnieżdżenia folderówFiles.find(dirPath, 2, (path, __) -> {
returnpath.getFileName().toString().endsWith(".txt") && Files.isRegularFile(path);
}).forEach((path) -> System.out.println(path.getFileName()));
/* OUTPUT: file1.txt file2.txt file3.txt*/

Struktury danych

Lista (dynamiczna tablica)

Struktura danych, która przechowuje elementy w uporządkowany sposób. Można sobie ją wyobrazić jako pudełka, które ułożone są obok siebie. Każde pudełko ma swoją własną etykietę, czyli numer, którym można się do niego odnieść.

importjava.util.ArrayList;
importjava.util.List;
publicclassTodoList {
List<String> todo;
TodoList() {
todo = newArrayList<>();
// dodawanie elementówtodo.add("Wyjście z psem");
todo.add("Nauka na asyko");
todo.add("Nauka na porawke z asyko");
todo.add("Kąpiel z podłączonym tosterem");
// usunięcie pierwszego elementutodo.remove(0); // [Nauka na asyko, Nauka na porawke z asyko, Kąpiel z podłączonym tosterem]// pobranie pierwszego elementutodo.get(0); // "Nauka na asyko"// sprawdzenie czy tablica zawiera elementtodo.contains("Nauka na asyko"); // true// usunięcie z filtrowaniemtodo.removeIf((item) -> item.startsWith("Nauka")); // [Kąpiel z podłączonym tosterem]todo.clear(); // wyczyszczenie całej listy
}
}

Iterowanie po liście obiektów (instancji klas)

List<Country> countries = newArrayList<>();
[...]
for (Countrycountry : countries) {
System.out.println(country.name);
}

Hashmap / haszmapa

Struktura danych, która przechowuje pary klucz-wartość. Przykładowo możesz myśleć o niej jak o książce adresowej, gdzie kluczem jest nazwa osoby, a wartością jest jej numer telefonu.

importjava.util.HashMap;
importjava.util.NoSuchElementException;
publicclassDiseasesDescriptions {
privatefinalHashMap<String, String> descriptions;
DiseasesDescriptions() {
descriptions = newHashMap<>();
descriptions.put("diarrhea", "condition characterized by frequent [...]");
descriptions.put("ebola", "severe and often fatal illness caused by the Ebola virus");
descriptions.put("coronavirus", "infectious respiratory illness caused by the severe acute respiratory syndrome coronavirus 2 (SARS-CoV-2). ");
}
StringgetDescription(StringdiseaseName) {
if (!this.descriptions.containsKey(diseaseName)) {
thrownewNoSuchElementException("Not found");
}
returnthis.descriptions.get(diseaseName);
}
}

HashSet

Struktura działa podobnie do listy ale zawsze przechowuje unikalne elementy. Czyli nie ważne ile razy wykonamy .add() z tym samym elementem, to nigdy nie będziemy mieli duplikatów.

Uwaga - kolejność elementów w trakcie iteracji po hash secie nie jest gwarantowana.

Uwaga - nie da sie pobrać elementów z hash setu po indexie - jeżeli nam zależy na operowaniu na indexach to możemy utworzyć tablicę na bazie hash setu (pokazane w następnym przykładzie).

importjava.util.HashSet;
publicclassMain {
publicstaticvoidmain(String[] args) {
HashSet<String> cars = newHashSet<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("BMW"); // dodajemy drugi raz "BMW", ale to nie wpływa na dane w hash seciecars.add("Mazda");
System.out.println(cars); // [Volvo, Mazda, Ford, BMW]cars.contains("Mazda"); // truecars.remove("Volvo"); // [Mazda, Ford, BMW]cars.clear(); // czyści cały hash set// iteracja po elementachfor (Stringcar : cars) {
System.out.println(car);
}
}
}

Utworzenie listy na bazie hash setu

HashSet może być przydatny gdy kolekcjonujemy dane które muszą być unikalne i nie zależy nam na kolejności. Możemy utworzyć tablicę na podstawie hash setu by potem już operować jak na zwykłej liście.

Set<String> cars = newHashSet<>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("BMW"); // dodajemy drugi raz "BMW", ale to nie wpływa na dane w hash seciecars.add("Mazda");
List<String> carsList = newArrayList<>(cars);
for (Stringcar : carsList) {
System.out.printf("Car: %s\n", car);
}