Consumer interface.

Hook: Interviewers love Consumer because it checks whether you know how Java models ‘do this, don’t return anything’ work.

Question: What is the Consumer interface in Java?

Answer: Consumer<T> is a functional interface in java.util.function that takes one value of type T and returns nothing. Its single method is accept(T t), so you use it for actions like printing, logging, saving, or updating state. In Java 8, lambdas and method references can be assigned to it, which makes code shorter and cleaner.

Interview-Ready Answer: I use Consumer when I want to perform an action on a value without producing a result. It is a functional interface with one method, accept, so I can pass lambdas like name -> System.out.println(name) or method references like System.out::println. A nice detail is that andThen lets me chain actions, and the second one runs only if the first finishes normally.

What it is

Consumer<T> lives in java.util.function. It is a functional interface, meaning it has exactly one abstract method, so a lambda can stand in for an implementation. The method is void accept(T t): you give it one value, it does something, and it does not hand back a result.

How it works under the hood

1. You choose a target type. For example, when a method parameter expects Consumer<String>, the compiler knows what shape the lambda must have.
2. Your lambda, such as s -> System.out.println(s), is converted into an object that implements Consumer<String>. In the JVM, this is usually built with invokedynamic, which lets the runtime create the implementation efficiently.
3. When someone calls accept, the lambda body runs with the supplied argument.
4. If the body only reads the value and prints, logs, saves, or updates something, that is a side effect. A side effect is any change outside the method, such as writing to a database or console.
5. If you chain with andThen, Java runs the first consumer, then the second one, but only if the first one finishes normally.

When to use it

Use Consumer whenever you need a callback for an action: forEach, logging, validation plus update, event listeners, or post-processing. Do not use it when you need a transformed value; that is the job of Function<T,R>.

Consumer vs other Java 8 functional types

Performance and edge cases

accept itself is O(1); the real cost is whatever your lambda does. Chaining with andThen adds one more call per consumer, so it is still tiny unless each action does I/O. Watch for nulls: andThen(null) throws NullPointerException, and if the first consumer throws an exception, the second never runs. For hot loops on primitives, Java also gives you IntConsumer, LongConsumer, and DoubleConsumer to avoid boxing, which means wrapping primitives into objects like Integer and paying extra memory and CPU.

Real-World Example: In a checkout service, one Consumer<Order> might write an audit log, and another might publish an event to Kafka after the order is saved. A developer once chained those actions and then reused the same consumer inside a parallel stream with a shared ArrayList. The result was intermittent ConcurrentModificationException errors, missing audit entries, and support tickets from users who saw ‘order placed’ in the UI but no confirmation email. The lesson: a Consumer is great for side effects, but the side effect must be thread-safe and should not rely on shared mutable state unless you protect it.

Follow-up & Tricky Questions:

• How is Consumer different from Function? Consumer performs an action and returns void; Function<T,R> transforms input into an output. If you need a result, choose Function; if you just need side effects, choose Consumer.
• Why is Consumer useful with streams? Stream terminal operations like forEach need a callback to act on each element. A Consumer fits perfectly when you want to print, collect metrics, or trigger a side effect.
• Can Consumer throw checked exceptions? The interface itself does not declare checked exceptions, so a lambda cannot throw one directly without handling or wrapping it. In practice, you catch it inside the lambda or convert it to an unchecked exception.
• What does andThen guarantee? It guarantees left-to-right execution: first consumer, then second consumer. If the first one throws, the second one is skipped, which is important for ordering-sensitive work like audit then publish.
• What about primitives and boxing? Plain Consumer<T> uses objects, so passing primitives like int causes boxing into Integer. For tight loops, prefer IntConsumer, LongConsumer, or DoubleConsumer to avoid that overhead.
• Does Consumer return a value? No. Its method is accept, and it is defined to return nothing. If someone says it returns something, that is a category error with Function.
• Is Consumer the same as Runnable? No. Runnable takes no input and returns nothing, while Consumer takes one input and returns nothing. Think of Runnable as ‘do a task’ and Consumer as ‘do something to this value’.
• Can andThen accept null? No, it throws NullPointerException immediately. That is deliberate fail-fast behavior so bugs show up early instead of silently dropping work.

Common Mistakes:

• Using Consumer for transformations. Correction: if you need to produce a new value, use Function or a stream map.
• Mutating shared state in parallel. Correction: keep consumers thread-safe or avoid shared mutable collections when using parallel streams.
• Assuming andThen continues after failure. Correction: the second consumer runs only if the first completes normally.
• Ignoring boxing cost for primitives. Correction: use primitive specializations like IntConsumer in hot code paths.

Memory Hook: Think of Consumer like a power socket: you plug in one value, it uses that value to do work, and nothing comes back out.

Cheat Sheet:

• Consumer<T> = one input, no return.
• Single abstract method: accept(T t).
• Best for side effects: print, log, save, notify.
• andThen chains actions in order.
• Use forEach with consumers.
• Prefer primitive consumers to avoid boxing.

Practice Tasks:

• Write a Consumer<String> that prints a username with a prefix.
• Chain two consumers with andThen and test what happens when the first throws.
• Use forEach on a list of items with a method reference like System.out::println.