Lære Funktion: Datatransformation | Grundlæggende og Funktionelle Kapaciteter af Stream API

Mens Predicate hjælper os med at evaluere booleske udtryk, gør Function det muligt at transformere data ved at anvende operationer, der returnerer resultater baseret på input.

Function anvendes ofte til datatransformation, såsom typekonvertering, beregninger eller værdibehandling.

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

Interfacet Function<T, R> i Java repræsenterer et funktionelt interface, der tager et argument af typen T og returnerer et resultat af typen R.

Metoden apply(T t) udfører datatransformationen ved at tage inputværdien og returnere resultatet. Dette muliggør oprettelse af fleksible funktioner til behandling af data af forskellige typer.

Praktisk anvendelse

Antag, at du har en liste over brugernavne, og du skal beregne længden af hvert navn til videre analyse eller databehandling.

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> users = Arrays.asList("Alice", "Bob", "Charlie", "David");

        Function<String, Integer> nameLength = name -> name.length();

        users.forEach(user -> {
            System.out.println(user + " has " + nameLength.apply(user) + " characters.");
        });
    }
}

I dette eksempel har du en liste over brugernavne. For hvert navn anvendes funktionen nameLength, som beregner antallet af tegn i navnet ved hjælp af metoden length(). Ved at bruge metoden forEach itereres der over hvert element i listen, og der udskrives en meddelelse, der viser, hvor mange tegn hvert navn indeholder.

Kombinering af funktioner

Function-interfacet tilbyder flere metoder til kombinering af funktioner, hvilket gør det muligt at oprette en kæde af operationer.

Metode andThen()

Metoden andThen() gør det muligt at kombinere to funktioner ved først at anvende én funktion og derefter sende resultatet videre til den anden funktion. Dette er nyttigt, når der skal udføres flere operationer i rækkefølge.

Eksempel

Du har en liste af brugernavne, og du skal gøre det første bogstav stort i hvert navn og derefter kontrollere, om navnet har mere end 5 tegn.

Main.java


              1234567891011121314151617181920212223
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> usernames = Arrays.asList("john", "alice", "bob", "charlie", "david");

        // Capitalize first letter
        Function<String, String> capitalizeFirstLetter = name -> name.substring(0, 1).toUpperCase() + name.substring(1);
        // Check if the username has more than 5 characters
        Function<String, Boolean> isLongerThanFive = name -> name.length() > 5;

        // Combine functions using `andThen()`
        Function<String, Boolean> formattedNameThenCheckLength = capitalizeFirstLetter.andThen(isLongerThanFive);

        usernames.forEach(user -> {
            System.out.println(user + " -> " + formattedNameThenCheckLength.apply(user));
        });
    }
}

Du gør først det første bogstav stort i hvert brugernavn ved hjælp af capitalizeFirstLetter. Derefter kontrolleres det formaterede brugernavn for, om det har mere end 5 tegn ved hjælp af isLongerThanFive. De to funktioner kombineres med andThen() for sekventiel behandling.

Metode compose()

Metoden compose() muliggør kombination af funktioner, men i omvendt rækkefølge: den anden funktion anvendes først, og resultatet sendes derefter videre til den første funktion.

Eksempel

Du har en streng, og du ønsker først at beregne dens længde og derefter tilføje et præfiks til resultatet.

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        String phrase = "Hello World";

        // First, calculate the length, then add a prefix
        Function<String, Integer> stringLength = String::length;
        Function<Integer, String> addPrefix = length -> "Length: " + length;

        // Combine functions using compose
        Function<String, String> lengthThenPrefix = addPrefix.compose(stringLength);

        System.out.println(lengthThenPrefix.apply(phrase));  // Output: Length: 11
    }
}

I dette eksempel beregnes først længden af strengen ved hjælp af stringLength, og derefter sendes resultatet videre til funktionen addPrefix, som tilføjer et præfiks foran. Du bruger compose() til at anvende funktionerne i den ønskede rækkefølge.

Metode identity()

Metoden identity() returnerer en funktion, der blot returnerer sit argument uden nogen ændringer. Dette er nyttigt, når du skal videregive en funktion, der ikke ændrer inputværdien, men som kræves for at overholde interfacet.

Eksempel

Forestil dig, at du skal behandle en liste af brugernavne ved at anvende flere transformationer: én til at konvertere navnene til store bogstaver, en anden til at tilføje suffikset "User", og en tredje ved hjælp af funktionen identity() for at lade navnet være uforandret. Opgaven er at anvende disse funktioner på hvert navn i listen, samtidig med at programmets interface forbliver ensartet for hver transformation.

Main.java


              1234567891011121314151617181920212223242526272829303132
            
package com.example;

import java.util.List;
import java.util.Arrays;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> usernames = Arrays.asList("alice", "bob", "charlie", "david", "eve");

        // `Function` to convert the username to uppercase
        Function<String, String> uppercaseFunction = name -> name.toUpperCase();

        // `Function` to add the "User" suffix
        Function<String, String> suffixFunction = name -> name + "User";

        // Identity `Function`, which does nothing
        Function<String, String> identityFunction = Function.identity();

        // Applying a combination of functions
        List<Function<String, ?>> transformations = Arrays.asList(uppercaseFunction, suffixFunction, identityFunction);

        // Applying each `Function` from the list
        for (Function<String, ?> transformation : transformations) {
            System.out.println("--------------------");

            usernames.stream()
                .map(name -> transformation.apply(name))
                .forEach(System.out::println);
        }
    }
}

Som du kan se, består outputtet af tre formaterede lister med brugernavne. Den sidste liste indeholder de originale navne, hvilket er, hvor identity()-metoden er nyttig, da den gør det muligt at returnere navnene uden at tilføje ekstra logik til håndtering af uændrede værdier. Dette gør koden renere og mere effektiv ved direkte at bruge identity(), når der ikke er behov for transformation.

1. Hvad gør `andThen()`-metoden i `Function`-interfacet?

2. Hvad bliver resultatet, når `identity()`-metoden anvendes?

3. Hvad gør `compose()`-metoden?

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 6

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Suggested prompts:

Can you give an example of how to use the Function interface in Java?

What is the difference between andThen() and compose() methods?

When should I use the identity() method in practice?

Awesome!

Completion rate improved to 2.33

Stryg for at vise menuen

Function anvendes ofte til datatransformation, såsom typekonvertering, beregninger eller værdibehandling.

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

Interfacet Function<T, R> i Java repræsenterer et funktionelt interface, der tager et argument af typen T og returnerer et resultat af typen R.

Praktisk anvendelse

Antag, at du har en liste over brugernavne, og du skal beregne længden af hvert navn til videre analyse eller databehandling.

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> users = Arrays.asList("Alice", "Bob", "Charlie", "David");

        Function<String, Integer> nameLength = name -> name.length();

        users.forEach(user -> {
            System.out.println(user + " has " + nameLength.apply(user) + " characters.");
        });
    }
}

Kombinering af funktioner

Function-interfacet tilbyder flere metoder til kombinering af funktioner, hvilket gør det muligt at oprette en kæde af operationer.

Metode andThen()

Eksempel

Du har en liste af brugernavne, og du skal gøre det første bogstav stort i hvert navn og derefter kontrollere, om navnet har mere end 5 tegn.

Main.java


              1234567891011121314151617181920212223
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> usernames = Arrays.asList("john", "alice", "bob", "charlie", "david");

        // Capitalize first letter
        Function<String, String> capitalizeFirstLetter = name -> name.substring(0, 1).toUpperCase() + name.substring(1);
        // Check if the username has more than 5 characters
        Function<String, Boolean> isLongerThanFive = name -> name.length() > 5;

        // Combine functions using `andThen()`
        Function<String, Boolean> formattedNameThenCheckLength = capitalizeFirstLetter.andThen(isLongerThanFive);

        usernames.forEach(user -> {
            System.out.println(user + " -> " + formattedNameThenCheckLength.apply(user));
        });
    }
}

Metode compose()

Eksempel

Du har en streng, og du ønsker først at beregne dens længde og derefter tilføje et præfiks til resultatet.

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        String phrase = "Hello World";

        // First, calculate the length, then add a prefix
        Function<String, Integer> stringLength = String::length;
        Function<Integer, String> addPrefix = length -> "Length: " + length;

        // Combine functions using compose
        Function<String, String> lengthThenPrefix = addPrefix.compose(stringLength);

        System.out.println(lengthThenPrefix.apply(phrase));  // Output: Length: 11
    }
}

Metode identity()

Eksempel

Main.java


              1234567891011121314151617181920212223242526272829303132
            
package com.example;

import java.util.List;
import java.util.Arrays;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<String> usernames = Arrays.asList("alice", "bob", "charlie", "david", "eve");

        // `Function` to convert the username to uppercase
        Function<String, String> uppercaseFunction = name -> name.toUpperCase();

        // `Function` to add the "User" suffix
        Function<String, String> suffixFunction = name -> name + "User";

        // Identity `Function`, which does nothing
        Function<String, String> identityFunction = Function.identity();

        // Applying a combination of functions
        List<Function<String, ?>> transformations = Arrays.asList(uppercaseFunction, suffixFunction, identityFunction);

        // Applying each `Function` from the list
        for (Function<String, ?> transformation : transformations) {
            System.out.println("--------------------");

            usernames.stream()
                .map(name -> transformation.apply(name))
                .forEach(System.out::println);
        }
    }
}

1. Hvad gør `andThen()`-metoden i `Function`-interfacet?

2. Hvad bliver resultatet, når `identity()`-metoden anvendes?

3. Hvad gør `compose()`-metoden?

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 6

Funktion: Datatransformation

Praktisk anvendelse

Kombinering af funktioner

Metode andThen()

Eksempel

Metode compose()

Eksempel

Metode identity()

Eksempel

1. Hvad gør andThen()-metoden i Function-interfacet?

2. Hvad bliver resultatet, når identity()-metoden anvendes?

3. Hvad gør compose()-metoden?

Awesome!

Funktion: Datatransformation

Praktisk anvendelse

Kombinering af funktioner

Metode andThen()

Eksempel

Metode compose()

Eksempel

Metode identity()

Eksempel

1. Hvad gør andThen()-metoden i Function-interfacet?

2. Hvad bliver resultatet, når identity()-metoden anvendes?

3. Hvad gør compose()-metoden?

1. Hvad gør `andThen()`-metoden i `Function`-interfacet?

2. Hvad bliver resultatet, når `identity()`-metoden anvendes?

3. Hvad gør `compose()`-metoden?

1. Hvad gør `andThen()`-metoden i `Function`-interfacet?

2. Hvad bliver resultatet, når `identity()`-metoden anvendes?

3. Hvad gør `compose()`-metoden?