All 15 Functional Interfaces & Method References questions
More in Functional Interfaces & Method References
How do the default methods andThen() and compose() on Function work, and what's the difference between them for chaining transformations? What is the difference between UnaryOperator<T> and Function<T,T>, and why does UnaryOperator exist as a separate, more specific interface? How do the primitive-specialized functional interfaces (IntFunction, ToIntFunction, IntPredicate, IntUnaryOperator, etc.) avoid the performance cost of autoboxing, and when should you prefer them over the generic equivalents? How does the Predicate interface's default methods and(), or(), and negate() enable composing complex boolean conditions from simpler ones? How would you convert a checked-exception-throwing method into a lambda usable with a standard functional interface (which doesn't declare any checked exceptions), given standard interfaces like Function don't permit checked exceptions in their abstract method signature? How does a lambda expression capture variables from its enclosing scope, and why must captured local variables be effectively final? How would you implement a custom functional interface with generic type parameters, and what considerations apply when designing one instead of reusing a built-in java.util.function interface? How would you implement memoization (caching function results) as a higher-order function wrapping an existing Function, and what thread-safety considerations apply for a memoized function used concurrently? How would you use BiFunction combined with Stream's reduce() to implement a custom aggregation, and how does this relate to the more general concept of a fold operation in functional programming? How do lambda expressions get compiled at the bytecode level using invokedynamic, and how does this differ from how an anonymous inner class implementing the same functional interface would be compiled?
Advertisement
Back to results for “Collections”
Java › Functional Interfaces & Method References

What is the difference between a Consumer<T> and a BiConsumer<T,U>, and how would you use BiConsumer for operations needing two inputs but no return value, such as Map.forEach()?

Intermediate

Answer

Consumer<T> accepts a single argument and performs a side effect with no return value (accept(T t)); BiConsumer<T,U> accepts two arguments and similarly performs a side effect with no return value (accept(T t, U u)) -- Map's forEach(BiConsumer<K,V>) method is a canonical use case, letting you process each key-value pair together in one lambda without needing to manually iterate entrySet() and destructure each Map.Entry yourself.
Map<String, Integer> ages = Map.of("Alice", 30, "Bob", 25);

// BiConsumer used directly via Map.forEach()
ages.forEach((name, age) -> System.out.println(name + " is " + age + " years old"));

// Equivalent using an explicit BiConsumer variable
BiConsumer<String, Integer> printer = (name, age) -> System.out.println(name + ": " + age);
ages.forEach(printer);
Real-world example A logging utility processing a Map<String, List<String>> of grouped validation errors uses Map.forEach() with a BiConsumer lambda to print each field name alongside its associated list of error messages, avoiding the more verbose alternative of manually iterating entrySet() and calling getKey()/getValue() on each entry.

Common follow-ups: What's the equivalent BiFunction and BiPredicate interfaces, and what scenarios call for each?;Why doesn't Consumer have an andThen()-based way to short-circuit, unlike Predicate's and()/or()?

Collections Framework;Streams & Lambdas
All 15 Functional Interfaces & Method References questions