org.libj.util.function

Interface ThrowingBiConsumer<T,U,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.

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

All Superinterfaces:

BiConsumer<T,U>

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 ThrowingBiConsumer<T,U,E extends Exception>
extends BiConsumer<T,U>

Represents an operation that accepts two input arguments and returns no result. Unlike most other functional interfaces, BiConsumer is expected to operate via side-effects.

The ThrowingBiConsumer distinguishes itself from BiConsumer 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:

 
 BiConsumer<Integer,Integer> consumer = Throwing.<Integer,Integer>rethrow((i, j) -> {
   if (i == 0)
     throw new IllegalArgumentException("i=" + i);
 });
 for (int i = 3; i >= 0; --i)
   consumer.accept(i, -i);
 
 

See Also:

Throwing

Method Summary

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

Methods inherited from interface java.util.function.BiConsumer

andThen

Method Detail

accept

default void accept(T t,
                    U u)

Specified by:

accept in interface BiConsumer<T,U>

acceptThrows

void acceptThrows(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 input argument.

Throws:

E - If an exception has occurred.

E extends Exception