Java Academy · Lekcja

Supplier i Consumer

Tworzenie i konsumowanie wartości

Supplier i Consumer to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Działanie Supplier

Supplier<T> nie przyjmuje żadnych argumentów i tworzy wartość typu T.

Jego metodą jest T get().
Doskonale nadaje się do leniwego lub odroczonego tworzenia wartości.

import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<String> greeting = () -> "Hello!";
        System.out.println(greeting.get());
    }
}

Suppliers są leniwe

Kod wewnątrz Supplier jest wykonywany dopiero po wywołaniu get. Dzięki temu suppliers doskonale nadają się do kosztownych wartości domyślnych, które mogą nigdy nie być potrzebne.

import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<Integer> expensive = () -> {
            System.out.println("computing...");
            return 42;
        };
        System.out.println("before get");
        System.out.println(expensive.get());
    }
}

Supplier dla wartości domyślnych

Wiele interfejsów API przyjmuje Supplier, aby obliczać wartość dopiero wtedy, gdy jest potrzebna, na przykład Optional.orElseGet.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name = Optional.empty();
        System.out.println(name.orElseGet(() -> "default"));
    }
}

Działanie Consumer

Consumer<T> przyjmuje wartość i nie zwraca niczego (void).

Jego metodą jest void accept(T t).
Jest używany do efektów ubocznych, takich jak drukowanie lub rejestrowanie zdarzeń.

import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Consumer<String> printer = s -> System.out.println("Got: " + s);
        printer.accept("data");
    }
}

Consumer z forEach

Najczęściej interfejs Consumer można spotkać w metodach Iterable.forEach i Stream.forEach.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> items = List.of("a", "b", "c");
        items.forEach(item -> System.out.println(item));
    }
}

Łączenie Consumerów za pomocą andThen

Consumer obsługuje andThen, które uruchamia dwa consumery kolejno dla tych samych danych wejściowych.

import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Consumer<String> first = s -> System.out.println("upper: " + s.toUpperCase());
        Consumer<String> second = s -> System.out.println("len: " + s.length());
        first.andThen(second).accept("hello");
    }
}

BiConsumer dla dwóch danych wejściowych

BiConsumer<T, U> przyjmuje dwa argumenty i niczego nie zwraca. Map.forEach używa go do iterowania po parach klucz-wartość.

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = Map.of("Ann", 30, "Bob", 25);
        ages.forEach((name, age) -> System.out.println(name + "=" + age));
    }
}

Referencje do metod jako Consumer

Referencja do metody, taka jak System.out::println, jest czytelnym przykładem użycia Consumer.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3);
        nums.forEach(System.out::println);
    }
}

Łączenie Supplier i Consumer

Supplier może bezpośrednio przekazać utworzoną wartość do Consumer, tworząc prosty przepływ: najpierw utworzenie, potem użycie wartości.

import java.util.function.Supplier;
import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Supplier<String> source = () -> "payload";
        Consumer<String> sink = s -> System.out.println("received " + s);
        sink.accept(source.get());
    }
}

Supplier zwracający obiekty

Konstruktory stanowią naturalne źródła wartości typu Supplier za pomocą ClassName::new, gdy nie są wymagane żadne argumenty.

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<List<String>> factory = ArrayList::new;
        List<String> list = factory.get();
        list.add("x");
        System.out.println(list);
    }
}

Efekty uboczne a funkcje czyste

Warto pamiętać o tym rozróżnieniu:

Supplier: nie przyjmuje danych wejściowych, generuje wynik.
Consumer: przyjmuje dane wejściowe, ale nie generuje wyniku (efekt uboczny).
Function: przyjmuje dane wejściowe i zwraca wynik.

import java.util.function.Supplier;
import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Supplier<Integer> dice = () -> 4;
        Consumer<Integer> show = n -> System.out.println("rolled " + n);
        show.accept(dice.get());
    }
}

Szybkie sprawdzenie

Który interfejs funkcyjny nie przyjmuje argumentów i zwraca wartość?

Podsumowanie

Wartości były generowane i konsumowane w sposób funkcyjny:

Supplier<T> używa get() do leniwego generowania wartości.
Consumer<T> używa accept() do wywoływania efektów ubocznych i łączy operacje za pomocą andThen.
BiConsumer<T,U> obsługuje dwa dane wejściowe, tak jak w przypadku Map.forEach.
Referencje do metod i konstruktorów pozwalają zapisać oba rozwiązania zwięźle.

Często zadawane pytania

Czy lekcja „Supplier i Consumer” jest bezpłatna?

Tak — pełny tekst „Supplier i Consumer” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Supplier i Consumer”?

Tworzenie i konsumowanie wartości Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Supplier i Consumer”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy