Java ObjLongConsumer

Introduction

In Java, the ObjLongConsumer interface is a functional interface that represents an operation that accepts an object and a long-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 long value, such as modifying an object’s state.

Table of Contents

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

1. What is ObjLongConsumer?

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

2. Methods and Syntax

The main method in the ObjLongConsumer interface is:

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

Syntax

ObjLongConsumer<T> objLongConsumer = (T t, long value) -> { // operation on t and value }; 

3. Examples of ObjLongConsumer

Example 1: Updating Account Balance

import java.util.function.ObjLongConsumer; class Account { private String name; private long balance; public Account(String name, long balance) { this.name = name; this.balance = balance; } public void deposit(long 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", 100L); // Define an ObjLongConsumer that deposits a long value to an account ObjLongConsumer<Account> deposit = (acc, amount) -> acc.deposit(amount); deposit.accept(account, 50L); System.out.println(account); } } 

Output:

John's balance: 150 

Example 2: Adding Quantity to a Product

import java.util.function.ObjLongConsumer; class Product { private String name; private long quantity; public Product(String name, long quantity) { this.name = name; this.quantity = quantity; } public void addQuantity(long amount) { this.quantity += amount; } @Override public String toString() { return name + "'s quantity after addition: " + quantity; } } public class ProductQuantityExample { public static void main(String[] args) { Product product = new Product("Laptop", 10L); // Define an ObjLongConsumer that adds quantity to a product ObjLongConsumer<Product> addQuantity = (prod, amount) -> prod.addQuantity(amount); addQuantity.accept(product, 5L); System.out.println(product); } } 

Output:

Laptop's quantity after addition: 15 

4. Real-World Use Case: Logging Timestamps

In applications, ObjLongConsumer can be used to log timestamps to a logger object.

import java.util.function.ObjLongConsumer; class Logger { private String id; public Logger(String id) { this.id = id; } public void logTimestamp(long timestamp) { System.out.println("Logger " + id + " recorded timestamp: " + timestamp); } } public class TimestampLoggingExample { public static void main(String[] args) { Logger logger = new Logger("Logger1"); // Define an ObjLongConsumer to log timestamps ObjLongConsumer<Logger> logTimestamp = (log, time) -> log.logTimestamp(time); logTimestamp.accept(logger, System.currentTimeMillis()); } } 

Output:

Logger Logger1 recorded timestamp: [current timestamp in milliseconds] 

Conclusion

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