CodeGym /Kursy /JAVA 25 SELF /Przekształcanie kolekcji

Przekształcanie kolekcji

JAVA 25 SELF
Poziom 28, Lekcja 1
Dostępny

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.

1
Zadanie
JAVA 25 SELF, poziom 28, lekcja 1
Niedostępne
Tworzenie listy studentów do albumu ukończeniowego 🎓
Tworzenie listy studentów do albumu ukończeniowego 🎓
1
Zadanie
JAVA 25 SELF, poziom 28, lekcja 1
Niedostępne
Łączenie skarbów z różnych skrzyń 💰
Łączenie skarbów z różnych skrzyń 💰
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION