1. Przekształcanie elementów kolekcji
W programowaniu jedną z najczęstszych operacji — przekształcanie kolekcji: mamy kolekcję danych pewnego typu i na jej podstawie musimy utworzyć nową kolekcję innego typu. Na przykład z listy obiektów typu User uzyskać listę ich nazw (String), albo z listy liczb — listę ich kwadratów.
Najbardziej fundamentalnym i zrozumiałym sposobem w Javie jest podejście imperatywne, czyli zwykła pętla for (często — for-each).
Przykład: z listy napisów uzyskać listę ich długości
Załóżmy, że mamy listę nazw miast:
List<String> cities = List.of("Londyn", "Paryż", "Tokio", "Nowy Jork");
Naszym zadaniem jest utworzyć nową listę, która będzie zawierać długość każdej nazwy. Oczekiwany wynik: [6, 5, 5, 9].
Rozwiązanie z użyciem pętli for:
import java.util.ArrayList;
import java.util.List;
public class CollectionTransform {
public static void main(String[] args) {
List<String> cities = List.of("Londyn", "Paryż", "Tokio", "Nowy Jork");
List<Integer> lengths = new ArrayList<>(); // Tworzymy nową, pustą listę na wynik
for (String city : cities) {
// Dla każdego elementu z cities obliczamy jego długość...
int length = city.length();
// ...i dodajemy ten wynik do nowej listy
lengths.add(length);
}
System.out.println(lengths); // Wypisze: [6, 5, 5, 9]
}
}
Zaczynamy od utworzenia nowej, pustej kolekcji na wyniki — przekształcenie for-each, a w jej wnętrzu stosujemy potrzebną logikę (length()) do każdego elementu, po czym rezultat dodajemy do nowej listy przez add.
2. Przekształcanie obiektów
Często pracujemy z bardziej złożonymi typami danych. Załóżmy, że mamy klasę Product i chcemy uzyskać listę jej nazw (lub cen).
public class Product {
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
}
Mając listę produktów, uzyskamy listę ich nazw:
import java.util.ArrayList;
import java.util.List;
public class ProductExample {
public static void main(String[] args) {
List<Product> products = List.of(
new Product("Laptop", 1200.0),
new Product("Mysz", 25.5),
new Product("Klawiatura", 75.0)
);
// Tworzymy nową listę na nazwy
List<String> productNames = new ArrayList<>();
for (Product product : products) {
// Dla każdego obiektu Product pobieramy jego nazwę
productNames.add(product.getName());
}
System.out.println(productNames); // Wypisze: [Laptop, Mysz, Klawiatura]
}
}
Logika pozostaje taka sama: iterujemy po kolekcji źródłowej, stosujemy do każdego elementu potrzebną metodę (np. getName()) i dodajemy wynik do nowej kolekcji.
3. Praca z kolekcjami zagnieżdżonymi
Rozważmy przypadek listy list: kilka działów, w każdym — własna lista pracowników. Zadanie — uzyskać jedną wspólną („płaską”) listę wszystkich pracowników.
Przykład: łączenie list pracowników
List<List<String>> departments = List.of(
List.of("Anna", "Borys"),
List.of("Wiktoria", "Gleb", "Dmitrij"),
List.of("Jelena")
);
Chcemy otrzymać jedną listę: [Anna, Borys, Wiktoria, Gleb, Dmitrij, Jelena].
Sposób 1: za pomocą addAll()
import java.util.ArrayList;
import java.util.List;
public class NestedCollectionExample {
public static void main(String[] args) {
List<List<String>> departments = List.of(
List.of("Anna", "Borys"),
List.of("Wiktoria", "Gleb", "Dmitrij"),
List.of("Jelena")
);
List<String> allEmployees = new ArrayList<>();
// Iterujemy po każdej liście (dziale)
for (List<String> department : departments) {
// Dodajemy wszystkie elementy z bieżącej listy do listy wspólnej
allEmployees.addAll(department);
}
System.out.println(allEmployees); // [Anna, Borys, Wiktoria, Gleb, Dmitrij, Jelena]
}
}
Sposób 2: pętla zagnieżdżona — to samo, ale „ręcznie”:
List<List<String>> departments = List.of(...);
List<String> allEmployees = new ArrayList<>();
for (List<String> department : departments) { // Pętla zewnętrzna po działach
for (String employee : department) { // Pętla wewnętrzna po pracownikach
allEmployees.add(employee);
}
}
System.out.println(allEmployees);
Obie metody są równoważne pod względem wyniku. Metoda addAll() w istocie enkapsuluje logikę zagnieżdżonej pętli i skraca kod.
4. Przypadki złożone i przekształcenia z warunkami
Czasem przekształcenie należy wykonywać tylko dla elementów spełniających warunek. Na przykład uzyskać listę nazw miast, które zaczynają się na literę "N", i wziąć ich długości. Tutaj łączymy filtrowanie i przekształcenie: if + wywołanie metody (length()).
import java.util.ArrayList;
import java.util.List;
public class ConditionalTransform {
public static void main(String[] args) {
List<String> cities = List.of("Londyn", "Paryż", "Tokio", "Nowy Jork", "Norymberga");
List<Integer> lengths = new ArrayList<>();
for (String city : cities) {
// Najpierw sprawdzamy warunek
if (city.startsWith("N")) {
// Jeśli warunek jest spełniony, stosujemy przekształcenie
lengths.add(city.length());
}
}
System.out.println(lengths); // Wypisze: [9, 10]
}
}
Schemat jest taki: wewnątrz pętli najpierw filtrujemy element przez warunek (startsWith, porównanie, sprawdzenie zakresu itp.), następnie stosujemy potrzebne przekształcenie i odkładamy wynik do nowej listy.
5. Typowe błędy i pułapki
Błąd nr 1: modyfikowanie kolekcji źródłowej podczas iteracji. Częsty błąd to próba dodawania/usuwania elementów z kolekcji źródłowej bezpośrednio w pętli for-each. Prowadzi to do błędów i nieprzewidywalnego zachowania. Rozwiązanie: zawsze twórz nową listę na wyniki i wypełniaj ją.
Błąd nr 2: nieprawidłowe rzutowanie typów. Jeśli pracujesz z „surowymi” kolekcjami (np. przez Object) i rzutujesz elementy na nieprawidłowy typ, otrzymasz ClassCastException. Używaj generyków (List<T>) i pilnuj sygnatur.
Błąd nr 3: nieefektywne użycie zasobów. Dla bardzo dużych kolekcji ciągłe tworzenie nowych list i kopiowanie elementów może być odczuwalne w pamięci i czasie. W większości codziennych zadań jest to akceptowalne, ale przy przetwarzaniu dużych wolumenów danych uwzględnij złożoność i w razie potrzeby optymalizuj podejście.
GO TO FULL VERSION