Java Academy · Lektion

Function och BiFunction

Transformera värden funktionellt.

Lektion 1 av 413 steg

Function och BiFunction är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad Function representerar

Function<T, R> är det centrala transformationsgränssnittet i java.util.function. Det tar ett argument av typen T och returnerar ett resultat av typen R.

Den enda abstrakta metoden är R apply(T t).
Det representerar en ren mappning från indata till utdata.

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"));
    }
}

Anropa apply

Ni anropar en Function genom att anropa apply. Lambda-kroppen innehåller transformationslogiken.

Indata- och utdatatypen kan skilja sig åt.
En metodreferens som String::toUpperCase kan ersätta ett lambda-uttryck.

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"));
    }
}

Komposition med andThen

andThen kedjar funktioner: resultatet från den första blir indata till den andra.

f.andThen(g) betyder g(f(x)).
Det läses från vänster till höger.

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));
    }
}

Komposition med compose

compose kör argumentfunktionen först.

f.compose(g) betyder f(g(x)).
Det är spegelbilden av 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() returnerar en funktion som ger tillbaka sin indata oförändrad.

Användbart i stream-collectors och standardmappningar.
Motsvarar 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"));
    }
}

Möt BiFunction

BiFunction<T, U, R> tar två argument och returnerar ett resultat.

Metoden är R apply(T t, U u).
Utmärkt för att kombinera två värden, till exempel vid sammanslagning av mappar.

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 med blandade typer

De tre typparametrarna i BiFunction kan alla vara olika.

Här kombinerar vi en String och en int till en 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 och andThen

BiFunction stöder även andThen, som tar en enarguments-Function för efterbehandling av resultatet.

BiFunction har ingen compose, eftersom det skulle kräva två indata.

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));
    }
}

Funktioner i samlingar

Många API:er tar emot en Function. Till exempel tar Map.computeIfAbsent en mappningsfunktion för nycklar som saknas.

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);
    }
}

Lagra funktioner i variabler

Eftersom funktioner är objekt kan ni lagra, skicka vidare och returnera dem. Det här är grunden för en funktionell Java-stil.

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));
    }
}

Bygga en pipeline

Genom att kedja andThen upprepade gånger bygger ni en transformationspipeline som är lättläst och återanvändbar.

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 "));
    }
}

Snabbtest

Vad beräknar f.andThen(g).apply(x)?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er de centrala transformationsgränssnitten:

Function<T,R> mappar ett värde med apply.
andThen kedjar framåt (g(f(x))); compose kedjar bakåt (f(g(x))).
Function.identity() returnerar sin indata.
BiFunction<T,U,R> hanterar två indata och stöder andThen, men inte compose.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Function och BiFunction” gratis?

Ja – hela texten till ”Function och BiFunction” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Function och BiFunction”?

Transformera värden funktionellt. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Function och BiFunction”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy