Java Academy · Lekcja

Function i BiFunction

Funkcjonalne przekształcanie wartości

Function i BiFunction to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 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.

Co reprezentuje Function

Function<T, R> to podstawowy interfejs transformacji w java.util.function. Przyjmuje jeden argument typu T i zwraca wynik typu R.

Jego jedyną metodą abstrakcyjną jest R apply(T t).
Modeluje czyste przekształcenie danych wejściowych w wyjściowe.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, Integer> length = s -> s.length();
        System.out.println(length.apply("hello"));
    }
}

Wywoływanie apply

Interfejs Function wywołuje się za pomocą apply. Treść lambdy zawiera logikę transformacji.

Typy wejściowy i wyjściowy mogą się różnić.
Referencja do metody, taka jak String::toUpperCase, może zastąpić lambdę.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> upper = String::toUpperCase;
        System.out.println(upper.apply("java"));
    }
}

Kompozycja andThen

andThen łączy funkcje: wynik pierwszej funkcji staje się danymi wejściowymi drugiej.

f.andThen(g) oznacza g(f(x)).
Odczytuje się je od lewej do prawej.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = n -> n * 2;
        Function<Integer, Integer> plus3 = n -> n + 3;
        System.out.println(times2.andThen(plus3).apply(5));
    }
}

Kompozycja compose

compose najpierw uruchamia funkcję przekazaną jako argument.

f.compose(g) oznacza f(g(x)).
Jest lustrzanym odwróceniem andThen.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = n -> n * 2;
        Function<Integer, Integer> plus3 = n -> n + 3;
        System.out.println(times2.compose(plus3).apply(5));
    }
}

Function.identity

Function.identity() zwraca funkcję, która oddaje dane wejściowe bez zmian.

Jest przydatna w kolektorach strumieni i mapowaniach domyślnych.
Jest równoważna wyrażeniu x -> x.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> id = Function.identity();
        System.out.println(id.apply("unchanged"));
    }
}

Poznajemy BiFunction

BiFunction<T, U, R> przyjmuje dwa argumenty i zwraca jeden wynik.

Jego metodą jest R apply(T t, U u).
Doskonale nadaje się do łączenia dwóch wartości, na przykład podczas scalania map.

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        System.out.println(add.apply(4, 6));
    }
}

BiFunction z różnymi typami

Wszystkie trzy parametry typu interfejsu BiFunction mogą się różnić.

W tym przypadku łączymy String i int w wartość typu String.

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<String, Integer, String> repeat = (s, n) -> s.repeat(n);
        System.out.println(repeat.apply("ab", 3));
    }
}

BiFunction i andThen

BiFunction obsługuje również andThen, przyjmując jednoargumentowy Function do dalszego przetworzenia wyniku.

Interfejs BiFunction nie ma metody compose, ponieważ wymagałaby ona dwóch danych wejściowych.

import java.util.function.BiFunction;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        Function<Integer, String> label = n -> "sum=" + n;
        System.out.println(add.andThen(label).apply(7, 8));
    }
}

Funkcje w kolekcjach

Wiele interfejsów API przyjmuje Function. Na przykład Map.computeIfAbsent przyjmuje funkcję mapującą dla brakujących kluczy.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> lengths = new HashMap<>();
        lengths.computeIfAbsent("hello", String::length);
        System.out.println(lengths);
    }
}

Przechowywanie funkcji w zmiennych

Ponieważ funkcje są obiektami, można je przechowywać, przekazywać i zwracać. Jest to podstawa funkcyjnego stylu programowania w Javie.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> square = n -> n * n;
        Function<Integer, Integer> cube = n -> n * n * n;
        Function<Integer, Integer> chosen = square;
        System.out.println(chosen.apply(5));
    }
}

Budowanie potoku

Wielokrotne łączenie za pomocą andThen tworzy czytelny i wielokrotnego użytku potok transformacji.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> trim = String::trim;
        Function<String, String> upper = String::toUpperCase;
        Function<String, Integer> len = String::length;
        System.out.println(trim.andThen(upper).andThen(len).apply("  abc "));
    }
}

Szybkie sprawdzenie

Co oblicza wyrażenie f.andThen(g).apply(x)?

Podsumowanie

Poznał(a) Pan/Pani podstawowe interfejsy transformacji:

Function<T,R> mapuje jedną wartość za pomocą apply.
andThen łączy funkcje w przód (g(f(x))), a compose wstecz (f(g(x))).
Function.identity() zwraca dane wejściowe.
BiFunction<T,U,R> obsługuje dwa dane wejściowe oraz andThen, ale nie obsługuje compose.

Często zadawane pytania

Czy lekcja „Function i BiFunction” jest bezpłatna?

Tak — pełny tekst „Function i BiFunction” 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 „Function i BiFunction”?

Funkcjonalne przekształcanie 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 1 z 4.

Ile czasu zajmuje lekcja „Function i BiFunction”?

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