Java Consumer Interface Example

🚀 Introduction to Java Consumer Functional Interface

In Java functional programming, the Consumer<T> interface (from java.util.function) is a functional interface that takes an input but does not return any result.

✅ T (Input Type): The type of the input value being processed.
 ✅ Return Type: void – The function performs an action but does not return a value.

💡 Common Use Cases:
 ✔ Logging and printing data — Writing messages to console or logs.
 ✔ Processing user inputs — Transforming or storing input values.
 ✔ Executing side-effects — Updating UI, modifying objects, or triggering external processes.

📌 In this article, you’ll learn:
 ✅ How to use Consumer<T> with examples.
 ✅ How to use accept() to process values.
 ✅ How to chain multiple consumers using andThen().
 ✅ Real-world use cases where Consumer improves Java applications.

1️⃣ Using accept() to Process Values

The accept(T t) method performs an operation on the given input.

✔ Example: Printing a String

import java.util.function.Consumer;

public class PrintConsumerExample {
    public static void main(String[] args) {
        // ✅ Define a Consumer that prints the input string
        Consumer<String> printConsumer = str -> System.out.println(str);

        printConsumer.accept("Hello world!"); // Output: Hello world!
    }
}

📌 Why use Consumer for printing?
 ✅ Encapsulates the logic into a reusable function.
 ✅ Makes processing independent of specific methods.

🚀 Use Consumer.accept() for performing actions on data without returning anything!

2️⃣ Using Consumer to Convert Strings to Uppercase

✔ Example: Transforming Input to Uppercase

import java.util.function.Consumer;

public class PrintConsumerExample {
    public static void main(String[] args) {
        // ✅ Define a Consumer that converts input to uppercase
        Consumer<String> upperCaseConsumer = str -> System.out.println("Uppercase: " + str.toUpperCase());

        upperCaseConsumer.accept("Hello"); // Output: Uppercase: HELLO
    }
}

📌 Why use Consumer for transformations?
 ✅ Executes transformations without returning values.

🚀 Use Consumer when you need to process data but don’t need a return value!

3️⃣ Combining Consumers Using andThen()

The andThen() method allows chaining multiple Consumer functions sequentially.

✔ Example: Chaining Consumers to Print and Convert to Uppercase

import java.util.function.Consumer;

public class PrintConsumerExample {
    public static void main(String[] args) {
        // Consumer to print the input
        Consumer<String> printConsumer = str -> System.out.println(str);

        // Consumer to convert the input to uppercase
        Consumer<String> upperCaseConsumer = str -> System.out.println("Uppercase: " + str.toUpperCase());

        // ✅ Chaining Consumers using andThen()
        Consumer<String> result = printConsumer.andThen(upperCaseConsumer);

        result.accept("Hello"); 
        // Output: Hello
        //         Uppercase: HELLO
    }
}

📌 Why use andThen()?
 ✅ Allows multiple operations to be executed sequentially.
 ✅ Improves modularity and reduces redundant code.

🚀 Use andThen() to chain multiple processing steps!

4️⃣ Real-World Use Cases of Consumer Interface

✔ Use Case 1: Logging System Messages

import java.util.function.Consumer;

public class LoggerExample {
    public static void main(String[] args) {
        // ✅ Consumer to log messages
        Consumer<String> logger = message -> System.out.println("[LOG]: " + message);

        logger.accept("Application started."); // Output: [LOG]: Application started.
    }
}

📌 Why use Consumer for logging?
 ✅ Encapsulates logging logic into a reusable function.
 ✅ Improves readability by avoiding redundant System.out.println calls.

🚀 Use Consumer to implement logging functionality in Java applications!

✔ Use Case 2: Iterating Over a List of Users

import java.util.List;
import java.util.function.Consumer;

public class UserProcessingExample {
    public static void main(String[] args) {
        List<String> users = List.of("Amit", "Neha", "Raj");

        // ✅ Consumer to process each user
        Consumer<String> userProcessor = user -> System.out.println("Processing user: " + user);

        users.forEach(userProcessor);
        // Output: Processing user: Amit
        //         Processing user: Neha
        //         Processing user: Raj
    }
}

📌 Why use Consumer for list processing?
 ✅ Eliminates the need for explicit for loops.
 ✅ Improves modularity by defining processing logic separately.

🚀 Use Consumer when iterating and performing actions on collections!

✔ Use Case 3: Updating User Profiles

import java.util.function.Consumer;

class User {
    String name;
    boolean isActive;

    public User(String name) {
        this.name = name;
        this.isActive = false;
    }

    public void activate() {
        this.isActive = true;
        System.out.println(name + " is now active.");
    }
}

public class UserUpdateExample {
    public static void main(String[] args) {
        User user = new User("Ramesh");

        // ✅ Consumer to activate user
        Consumer<User> activateUser = u -> u.activate();

        activateUser.accept(user);
        // Output: Ramesh is now active.
    }
}

📌 Why use Consumer for updating objects?
 ✅ Encapsulates modification logic inside a reusable function.
 ✅ Can be easily passed as a parameter to other methods.

🚀 Use Consumer for modifying object properties dynamically!

🔥 Best Practices for Using Consumer Functional Interface

Best Practices for Using Consumer Functional Interface

🔑 Key Takeaways

✅ The Consumer<T> interface processes values without returning results.
 ✅ Use accept() to execute actions on input values.
 ✅ Use andThen() to chain multiple Consumers sequentially.
 ✅ Apply Consumer in real-world cases like logging, list processing, and updating objects.

By mastering the Consumer functional interface, your Java code will be more modular, efficient, and structured! 🚀