Java-Interviewfragen (Reihe) – Gemeinsame Funktionsschnittstellen

80 % der Zeit verwenden Sie 20 % der @FunctionalInterfaces 👋

Knapp

🤔 In einem vorherigen Postwir sprachen über die @FunctionalInterface Funktion, die mit Java 8 kommt.

Wir haben verstanden:

🔹 Wofür wird es verwendet?

🔹 Woraus besteht es?

🔹 Wie kannst du deine eigenen erstellen?

Java-Entwickler haben auch einige sofort einsatzbereite Funktionsschnittstellen erstellt, um unser Leben einfacher zu machen. 💯

In diesem Beitrag werden wir die am häufigsten verwendeten durchgehen, wofür sie verwendet werden und wie sie in Ihrem speziellen Anwendungsfall verwendet werden. 🚀

Weitere Beiträge wie diesen finden Sie auf new-spike.net! 🚀

Implementierung

🔵 Prädikat

Funktionale Schnittstelle, deren abstrakte Methode ein einzelnes Element akzeptiert und a zurückgibt boolean.

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T input);
}

Erinnerung an den vorigen Beitrag funktionale Schnittstellenmüssen wir eine Implementierung für die bereitstellen test abstrakte Methode.

🔸 Beispiel

Lassen Sie uns ein Prädikat erstellen, das bestimmt, ob eine bestimmte Ganzzahl ist even oder odd.

Predicate<Integer> isEvenPredicate = input -> input%2 == 0; // provide implementation through a lambda expression

Um es zu verwenden, müssen Sie es nur aufrufen test Methode.

boolean res1 = isEvenPredicate.test(4); // will return true

boolean res2 = isEvenPredicate.test(5); // will return false;

🔵 Verbraucher

Funktionale Schnittstelle, deren abstrakte Methode ein einzelnes Element akzeptiert und zurückgibt void.

@FunctionalInterface
public interface Consumer<T> {
    void accept(T input);
}

🔸 Beispiel

Angenommen, Sie möchten das Element auf der Konsole drucken.

Consumer<Integer> loggingConsumer = input -> System.out.println(input); // provide implementation through a lambda expression

Und dann, um es anzuwenden, rufst du die an accept Methode.

loggingConsumer.accept(2); // will print to the console: "2"

Weitere Beiträge wie diesen finden Sie auf new-spike.net! 🚀

🔵 Lieferant

Funktionale Schnittstelle, deren abstrakte Methode keine Eingabeparameter hat, aber einen Wert zurückgibt.

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

🔸 Beispiel

Ein Anwendungsfall dafür könnte das Generieren einer Zufallszahl sein.

Supplier<Double> randomSupplier = () -> Math.random(); // provide implementation through a lambda expression

Um es zu verwenden, verwenden Sie die get Methode.

Double random = randomSupplier.get();

🔵 Funktion

Funktionale Schnittstelle, deren abstrakte Methode ein einzelnes Element als Eingabe akzeptiert und auch einen Wert zurückgibt.

@FunctionalInterface
public interface Function<T, U> {
    U apply(T input);
}

Mit anderen Worten, es ist eine Kombination aus Consumer und Supplier.

Dies sollten Sie verwenden, wenn Sie den Zustand der Elemente ändern oder basierend auf der Eingabe einen neuen Objekttyp generieren möchten.

🔸 Beispiel

Möglicherweise haben Sie eine User Objekt mit a name Eigentum.

Bei einer Zeichenfolge, die als Eingabe für name bereitgestellt wird, mit Functionkönnen Sie eine erstellen User mit diesem besonderen Namen.

public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }
}

Benutzer.java

Function<String, User> userFunction = input -> new User(input); // provide implementation through a lambda expression

User user = userFunction.apply("John Doe"); // generates a user with "John Doe" for name.

Weitere Beiträge wie diesen finden Sie auf new-spike.net! 🚀

Bonus

Jede dieser funktionalen Schnittstellen, die wir gerade besprochen haben, hat auch einen Korrespondenten, der zwei Eingabeparameter unterschiedlichen Typs akzeptieren kann.

Außer der Supplier Eine natürlich, da sie keine Parameter empfangen kann.

🔹 BiConsumer<T,U> – akzeptiert einen T Parameter und eins U Parameter und Rückgaben void.

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);
}

BiConsumer.java

BiConsumer<Integer, String> loggingConsumer = (input1, input2) -> System.out.println(input1 + input2);

loggingConsumer.accept(12, "apples"); // will print to the console: "12 apples"

Beispiel

🔹 BiFunction<T,U,R> – akzeptiert einen T Parameter und eins U Parameter und gibt a zurück R Parameter.

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

BiFunction.java

public class User {
    private String name;
    private Integer age;

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

Benutzer.java

Function<String, Integer, User> userFunction = (name, age) -> new User(name, age); // provide implementation through a lambda expression

User user = userFunction.apply("John Doe", 23); // generates a user with "John Doe" for name and "23" for age.

Beispiel

🔹 BiPredicate<T,U> – akzeptiert einen T Parameter und eins U Parameter und gibt a zurück boolean.

@FunctionalInterface
public interface BiPredicate<T, U> {
    boolean test(T t, U u);
}
BiPredicate<Integer, Integer> comparePredicate = (number1, number2) -> number1 >= number2;

comparePredicate.test(1,2); // returns false

comparePredicate.test(3,1); // returns true

Beispiel

Weitere Beiträge wie diesen finden Sie auf new-spike.net! 🚀

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *