Java ObjDoubleConsumer

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Introduction

In Java, the ObjDoubleConsumer interface is a functional interface that represents an operation that accepts an object and a double-valued argument and returns no result. It is part of the java.util.function package and is commonly used for operations that involve both an object and a double value, such as modifying an object's state.

Table of Contents

  1. What is ObjDoubleConsumer?
  2. Methods and Syntax
  3. Examples of ObjDoubleConsumer
  4. Real-World Use Case
  5. Conclusion

1. What is ObjDoubleConsumer?

ObjDoubleConsumer is a functional interface that performs an operation on an object and a double value without returning any result. It is useful for scenarios where an object's state needs to be modified based on a double input.

2. Methods and Syntax

The main method in the ObjDoubleConsumer interface is:

  • void accept(T t, double value): Performs this operation on the given object and double argument.

Syntax

ObjDoubleConsumer<T> objDoubleConsumer = (T t, double value) -> {
    // operation on t and value
};

3. Examples of ObjDoubleConsumer

Example 1: Updating Account Balance

import java.util.function.ObjDoubleConsumer;

class Account {
    private String name;
    private double balance;

    public Account(String name, double balance) {
        this.name = name;
        this.balance = balance;
    }

    public void deposit(double amount) {
        this.balance += amount;
    }

    @Override
    public String toString() {
        return name + "'s balance: " + balance;
    }
}

public class AccountUpdateExample {
    public static void main(String[] args) {
        Account account = new Account("John", 100.0);

        // Define an ObjDoubleConsumer that deposits a double value to an account
        ObjDoubleConsumer<Account> deposit = (acc, amount) -> acc.deposit(amount);

        deposit.accept(account, 50.0);
        System.out.println(account);
    }
}

Output:

John's balance: 150.0

Example 2: Applying a Discount to a Product

import java.util.function.ObjDoubleConsumer;

class Product {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public void applyDiscount(double discount) {
        this.price -= this.price * discount / 100;
    }

    @Override
    public String toString() {
        return name + "'s price after discount: " + price;
    }
}

public class ProductDiscountExample {
    public static void main(String[] args) {
        Product product = new Product("Laptop", 1000.0);

        // Define an ObjDoubleConsumer that applies a discount to a product
        ObjDoubleConsumer<Product> applyDiscount = (prod, discount) -> prod.applyDiscount(discount);

        applyDiscount.accept(product, 10.0);
        System.out.println(product);
    }
}

Output:

Laptop's price after discount: 900.0

4. Real-World Use Case: Logging Temperature Readings

In applications, ObjDoubleConsumer can be used to log temperature readings to a sensor object.

import java.util.function.ObjDoubleConsumer;

class Sensor {
    private String id;

    public Sensor(String id) {
        this.id = id;
    }

    public void logTemperature(double temperature) {
        System.out.println("Sensor " + id + " recorded temperature: " + temperature);
    }
}

public class TemperatureLoggingExample {
    public static void main(String[] args) {
        Sensor sensor = new Sensor("A1");

        // Define an ObjDoubleConsumer to log temperature readings
        ObjDoubleConsumer<Sensor> logTemperature = (sens, temp) -> sens.logTemperature(temp);

        logTemperature.accept(sensor, 25.5);
    }
}

Output:

Sensor A1 recorded temperature: 25.5

Conclusion

The ObjDoubleConsumer interface is a versatile tool in Java for performing operations on an object and a double value without returning a result. It simplifies handling tasks like updating object states or logging information. Using ObjDoubleConsumer can lead to cleaner and more efficient code, especially in functional programming contexts.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Comments

Spring Boot 3 Paid Course Published for Free
on my Java Guides YouTube Channel

Subscribe to my YouTube Channel (165K+ subscribers):
Java Guides Channel

Top 10 My Udemy Courses with Huge Discount:
Udemy Courses - Ramesh Fadatare