org.libj.util.function

Interface ThrowingBiFunction<T,U,R,E extends Exception>

Type Parameters:

T - The type of the first input to the operation.

U - The type of the second input to the operation.

R - The type of the result of the function.

E - The type of the exception that can be thrown.

All Superinterfaces:

BiFunction<T,U,R>

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface ThrowingBiFunction<T,U,R,E extends Exception>
extends BiFunction<T,U,R>

Represents a function that accepts two arguments and produces a result.

The ThrowingFunction distinguishes itself from BiFunction by allowing the functional interface to throw an Exception. This can be used to allow lambda expressions to propagate checked exceptions up the expression's call stack. An example of this pattern:

 
 BiFunction<Integer,Integer,String> function = Throwing.<Integer,Integer,String>rethrow((i, j) -> {
   if (i == 0)
     throw new IllegalArgumentException("i=" + i);
   return String.valueOf(i);
 });
 for (int i = 3; i >= 0; --i)
   function.accept(i, -i);
 
 

See Also:

Throwing

Method Summary

Modifier and Type	Method and Description
default R	apply(T t, U u)
R	applyThrows(T t, U u) Performs this operation on the given argument, allowing an exception to be thrown.

Methods inherited from interface java.util.function.BiFunction

andThen

Method Detail

apply

default R apply(T t,
                U u)

Specified by:

apply in interface BiFunction<T,U,R>

applyThrows

R applyThrows(T t,
              U u)
       throws E extends Exception

Performs this operation on the given argument, allowing an exception to be thrown.

Parameters:

t - The first input argument.

u - The second function argument.

Returns:

The function result.

Throws:

E - If an exception has occurred.

E extends Exception