BiFunction-Schnittstelle in Java

1. BiFunction apply() Methodenbeispiel in Java
2. BiFunction andThen()-Methode in Java
3. Vermeiden NullPointerException im BiFunction Interface
4. BiFunction mit HashMap in Java
5. BiFunction und Methodenreferenz
6. Fazit

In diesem Tutorial werden wir die BiFunction-Schnittstelle in Java besprechen.

Die BiFunction-Schnittstelle ist eine eingebaute funktionale Schnittstelle, die in Java 8 eingeführt wurde und sich im Paket java.util.function befindet. Anders als die Function-Schnittstelle, die zwei Generika akzeptiert (einen Argumenttyp und einen Rückgabetyp), akzeptiert BiFunction zwei Argumente und erzeugt ein Ergebnis.

Wir können einen Lambda-Ausdruck oder eine Methodenreferenz zuweisen, die zwei Argumente akzeptiert und ein Ergebnis an ein Objekt vom Typ BiFunction zurückgibt.

BiFunction verwendet drei Generika – T, U und R. T und U sind die Typen des ersten bzw. zweiten Arguments. R ist der Typ des Ergebnisses der Funktion.

interface BiFunction<T, U, R>

Die BiFunction-Schnittstelle hat zwei Methoden:

• apply(): Führt die definierte Operation an den Argumenten aus und gibt ein Ergebnis zurück. Die Syntax dieser Methode lautet:

R apply(T t, U u) // R is the return type. T and U are the types of the two arguments

• andThen(): Gibt das Ergebnis einer zusammengesetzten Funktion zurück. Einfacher gesagt, es führt zuerst die BiFunction mit den beiden Argumenten aus und erzeugt ein Ergebnis. Als nächstes übergibt es das Ergebnis an eine Funktion. Die Syntax dieser Methode lautet:

default<V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after)

BiFunction apply() Methodenbeispiel in Java

Lassen Sie uns eine einfache BiFunction erstellen, die Argumente vom Typ Integer und Double akzeptiert und einen String zurückgibt. Wir haben die Methode apply() verwendet, um das Argument zu übergeben und das Ergebnis zu erhalten.

Siehe das Beispiel unten.

import java.util.function.*;

public class SimpleTesting {
  public static void main(String args[]) {
    // BiFunction with arguments of type Integer and Double
    // and return type of String
    BiFunction<Integer, Double, String> biFunction = (a, b) -> {
      double result = a * b;
      String s = "The result from the BiFunction is: " + result;
      return s;
    };

    String output = biFunction.apply(10, 15.5);
    System.out.print(output);
  }
}

Ausgabe:

The result from the BiFunction is: 155.0

BiFunction andThen()-Methode in Java

Lassen Sie uns das Ergebnis der oben definierten BiFunction an eine Funktion übergeben. Wir verwenden die Methode andThen(). Diese Methode wertet zuerst das Ergebnis der BiFunction aus und übergibt dieses Ergebnis dann an die after Funktion.

import java.util.function.*;

public class SimpleTesting {
  public static void main(String args[]) {
    // BiFunction with arguments of type Integer and Double
    // and return type of String
    BiFunction<Integer, Double, String> biFunction = (a, b) -> {
      double result = a * b;
      String s = "The result from the BiFunction is: " + result;
      return s;
    };

    // Function with argument of type String
    // and return type of Integer
    Function<String, Integer> after = s -> {
      Integer length = s.length();
      return length;
    };

    int output = biFunction.andThen(after).apply(
        10, 15.5); // first evaluates the BiFunction and then the Function
    System.out.print(output);
  }
}

Ausgabe:

40

Vermeiden NullPointerException im BiFunction Interface

Wenn wir eine Nullreferenz an die andThen()-Methode übergeben, gibt der Code NullPointerException zurück. Siehe das Beispiel unten. Wir sollten solche Fehler vermeiden und den Code immer in try...catch Blöcke packen.

import java.util.function.*;

public class SimpleTesting {
  public static void main(String args[]) {
    BiFunction<Integer, Double, String> biFunction = (a, b) -> {
      double result = a * b;
      String s = "The result from the BiFunction is: " + result;
      return s;
    };

    Function<String, Integer> after = null;

    int output = biFunction.andThen(after).apply(10, 15.5);
    System.out.print(output);
  }
}

Ausgabe:

Exception in thread "main" java.lang.NullPointerException
	at java.base/java.util.Objects.requireNonNull(Objects.java:222)
	at java.base/java.util.function.BiFunction.andThen(BiFunction.java:69)
	at SimpleTesting.main(SimpleTesting.java:15)

Beachten Sie, dass wir zwei BiFunctions nicht mit der Methode andThen() integrieren können.

BiFunction mit HashMap in Java

BiFunctions werden als Argumente in einigen HashMap-Methoden wie compute(), computeIfPresent(), merge() und replaceAll() verwendet.

Lassen Sie uns ein Beispiel erstellen, um BiFunction in HashMap zu verwenden. Stellen Sie sich eine HashMap vor, die Schülerrollennummern und ihre Punktzahlen speichert. Wir müssen 5 zur Punktzahl jedes Schülers hinzufügen, mit Ausnahme der Rollennummer 101.

import java.util.HashMap;
import java.util.function.*;

public class SimpleTesting {
  public static void main(String args[]) {
    HashMap<Integer, Double> scoreMap = new HashMap<>();
    scoreMap.put(101, 95.2);
    scoreMap.put(102, 86.0);
    scoreMap.put(103, 91.9);
    scoreMap.put(104, 72.8);
    scoreMap.put(105, 89.5);

    System.out.println("Intial HashMap: " + scoreMap);

    // BiFunction with arguments of type Integer and Double
    // and return type of Double
    BiFunction<Integer, Double, Double> biFunction = (key, value) -> {
      if (key == 101)
        return value;
      else
        return value + 5;
    };
    scoreMap.replaceAll(biFunction);
    System.out.print("HashMap After The Update: " + scoreMap);
  }
}

Ausgabe:

Intial HashMap: {101=95.2, 102=86.0, 103=91.9, 104=72.8, 105=89.5}
HashMap After The Update: {101=95.2, 102=91.0, 103=96.9, 104=77.8, 105=94.5}

BiFunction und Methodenreferenz

Bisher haben wir die BiFunction-Schnittstelle als Referenz für Lambda-Ausdrücke verwendet. Eine Methode kann auch über eine BiFunction referenziert werden. Die Methode muss nur zwei Argumente annehmen und gibt ein Ergebnis zurück.

Lassen Sie uns eine einfache statische Methode schreiben, die überprüft, ob die Summe der beiden gegebenen ganzen Zahlen gerade ist oder nicht. Diese Methodenreferenz können wir einer BiFunction zuweisen. Siehe das Beispiel unten.

import java.util.function.*;

public class SimpleTesting {
  static boolean isSumEven(int a, int b) {
    int sum = a + b;
    if (sum % 2 == 0)
      return true;
    else
      return false;
  }

  public static void main(String args[]) {
    BiFunction<Integer, Integer, Boolean> biFunction = SimpleTesting::isSumEven;

    System.out.println("Is sum of 10 and 21 even? " + biFunction.apply(10, 21));
    System.out.print("Is sum of 5 and 7 even? " + biFunction.apply(5, 7));
  }
}

Ausgabe:

Is sum of 10 and 21 even? false
Is sum of 5 and 7 even? true

Fazit

Die Java BiFunction-Schnittstelle ist eine funktionale Schnittstelle. Es wird als Zuweisungsziel für Lambda-Ausdrücke oder Methodenreferenzen verwendet. Die BiFunction-Schnittstelle wird der Function-Schnittstelle vorgezogen, wenn wir zwei Argumente übergeben müssen.

Die BiFunction-Schnittstelle enthält zwei Methoden: apply() und andThen(). Die Methode apply() wendet die Funktion auf die beiden angegebenen Argumente an. Die Methode andThen() wird verwendet, um das Ergebnis von BiFunction an eine Function-Schnittstelle zu übergeben.