Java ObjIntConsumer Interface
Last modified: April 16, 2025
The java.util.function.ObjIntConsumer interface represents an
operation that accepts an object-valued and an int-valued argument, and returns
no result. It is a functional interface with a single abstract method
accept.
ObjIntConsumer is part of Java's functional programming utilities
added in Java 8. It is used when you need to perform operations combining
objects and primitive int values. Unlike regular consumers, it avoids autoboxing
overhead.
ObjIntConsumer Interface Overview
ObjIntConsumer interface contains one abstract method that must be
implemented. The method performs the operation on the given object and int
arguments. There are no default or static methods in this interface.
@FunctionalInterface
public interface ObjIntConsumer<T> {
void accept(T t, int value);
}
The code above shows the structure of ObjIntConsumer interface. It uses
generics where T is the type of the object argument. The interface is annotated
with @FunctionalInterface to indicate its single abstract method nature.
Basic ObjIntConsumer Usage
The simplest way to use ObjIntConsumer is with lambda expressions. We define what to do with the object and int parameters. The example shows a consumer that prints both values.
package com.zetcode;
import java.util.function.ObjIntConsumer;
public class Main {
public static void main(String[] args) {
// Define a consumer that prints object and int
ObjIntConsumer<String> printCombined = (s, i) ->
System.out.println("String: " + s + ", int: " + i);
// Use the consumer
printCombined.accept("Hello", 42);
printCombined.accept("Java", 8);
// Consumer with more complex logic
ObjIntConsumer<String> repeatPrint = (str, count) -> {
for (int i = 0; i < count; i++) {
System.out.println(str);
}
};
repeatPrint.accept("Loop", 3);
}
}
This example demonstrates basic ObjIntConsumer usage with lambda expressions. The printCombined consumer simply prints both arguments. The repeatPrint consumer shows more complex logic, printing a string multiple times based on the int value.
Using ObjIntConsumer with Collections
ObjIntConsumer can be useful when processing collections where you need
to combine elements with their indices or other integer values. This example shows
how to use it with a list.
package com.zetcode;
import java.util.Arrays;
import java.util.List;
import java.util.function.ObjIntConsumer;
public class Main {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// Consumer to print name with index
ObjIntConsumer<String> printIndexed = (name, index) ->
System.out.println((index + 1) + ". " + name);
// Process list with index
for (int i = 0; i < names.size(); i++) {
printIndexed.accept(names.get(i), i);
}
// Consumer to build a formatted string
StringBuilder sb = new StringBuilder();
ObjIntConsumer<String> buildString = (s, i) -> {
if (i > 0) sb.append(", ");
sb.append(s).append(":").append(i);
};
for (int i = 0; i < names.size(); i++) {
buildString.accept(names.get(i), i);
}
System.out.println("Formatted: " + sb.toString());
}
}
This example shows ObjIntConsumer used with a list of names. The printIndexed consumer displays each name with its 1-based index. The buildString consumer creates a formatted string combining names with their indices.
ObjIntConsumer in Object Processing
ObjIntConsumer is particularly useful when processing objects that
have some relationship with integer values. This example demonstrates updating
product quantities in a shopping cart.
package com.zetcode;
import java.util.HashMap;
import java.util.Map;
import java.util.function.ObjIntConsumer;
class Product {
String name;
double price;
Product(String name, double price) {
this.name = name;
this.price = price;
}
@Override
public String toString() {
return name + " ($" + price + ")";
}
}
public class Main {
public static void main(String[] args) {
Map<Product, Integer> cart = new HashMap<>();
cart.put(new Product("Laptop", 999.99), 1);
cart.put(new Product("Mouse", 25.50), 2);
cart.put(new Product("Keyboard", 45.75), 1);
// Consumer to update product quantities
ObjIntConsumer<Product> updateQuantity = (product, quantity) -> {
int current = cart.getOrDefault(product, 0);
cart.put(product, current + quantity);
};
// Add more items to cart
Product mouse = new Product("Mouse", 25.50);
updateQuantity.accept(mouse, 3);
Product headphones = new Product("Headphones", 79.99);
updateQuantity.accept(headphones, 2);
// Print final cart contents
ObjIntConsumer<Product> printCartItem = (p, q) ->
System.out.println(p + " x " + q + " = $" + (p.price * q));
cart.forEach((k, v) -> printCartItem.accept(k, v));
}
}
This example shows ObjIntConsumer used for shopping cart operations. The updateQuantity consumer adds specified quantities to products in the cart. The printCartItem consumer displays each product with its quantity and total price. This demonstrates practical object-int pair processing.
Combining ObjIntConsumer with Other Functional Interfaces
ObjIntConsumer can be combined with other functional interfaces to
create more complex operations. This example shows integration with Predicate
and Function.
package com.zetcode;
import java.util.function.Function;
import java.util.function.ObjIntConsumer;
import java.util.function.Predicate;
public class Main {
public static void main(String[] args) {
// Function to create greeting
Function<String, String> greeter = name -> "Hello, " + name + "!";
// Predicate to check if number is even
Predicate<Integer> isEven = n -> n % 2 == 0;
// Consumer that combines both
ObjIntConsumer<String> complexConsumer = (name, number) -> {
String greeting = greeter.apply(name);
String evenOdd = isEven.test(number) ? "even" : "odd";
System.out.println(greeting + " Your number is " + number +
" which is " + evenOdd + ".");
};
// Use the combined consumer
complexConsumer.accept("Alice", 42);
complexConsumer.accept("Bob", 7);
// Another example with calculation
ObjIntConsumer<Double> powerCalculator = (base, exponent) -> {
double result = Math.pow(base, exponent);
System.out.printf("%.2f^%d = %.2f%n", base, exponent, result);
};
powerCalculator.accept(2.5, 3);
powerCalculator.accept(10.0, -2);
}
}
This example demonstrates combining ObjIntConsumer with other functional interfaces. The complexConsumer uses a Function and Predicate to create a more sophisticated operation. The powerCalculator shows mathematical operations combining double and int values.
ObjIntConsumer in Stream Processing
While ObjIntConsumer isn't directly used in Stream API methods,
it can be helpful in stream processing scenarios where you need to handle
object-int pairs. This example shows a custom stream-like operation.
package com.zetcode;
import java.util.Arrays;
import java.util.List;
import java.util.function.ObjIntConsumer;
public class Main {
static <T> void processWithIndices(List<T> list, ObjIntConsumer<T> consumer) {
for (int i = 0; i < list.size(); i++) {
consumer.accept(list.get(i), i);
}
}
public static void main(String[] args) {
List<String> colors = Arrays.asList("Red", "Green", "Blue", "Yellow");
// Consumer to create indexed color codes
ObjIntConsumer<String> colorCoder = (color, index) -> {
String code = color.substring(0, 3).toUpperCase() + index;
System.out.println(color + " -> " + code);
};
processWithIndices(colors, colorCoder);
// Another example with statistics
int[] totals = new int[1];
ObjIntConsumer<Integer> summer = (num, weight) -> {
totals[0] += num * weight;
};
List<Integer> numbers = Arrays.asList(10, 20, 30, 40);
processWithIndices(numbers, summer);
System.out.println("Weighted total: " + totals[0]);
}
}
This example shows a custom stream processing method using ObjIntConsumer. The processWithIndices method applies the consumer to each element with its index. The colorCoder creates codes combining color names with positions. The summer calculates a weighted total of numbers.
ObjIntConsumer for Configuration
ObjIntConsumer can be useful for configuration scenarios where
objects need to be configured with integer parameters. This example shows
a settings application pattern.
package com.zetcode;
import java.util.function.ObjIntConsumer;
class Device {
String name;
int brightness;
int volume;
Device(String name) {
this.name = name;
}
void displaySettings() {
System.out.printf("%s - Brightness: %d, Volume: %d%n",
name, brightness, volume);
}
}
public class Main {
public static void main(String[] args) {
Device tv = new Device("Living Room TV");
Device speaker = new Device("Kitchen Speaker");
// Consumers for different device settings
ObjIntConsumer<Device> setBrightness = (d, b) -> {
d.brightness = Math.min(Math.max(b, 0), 100);
};
ObjIntConsumer<Device> setVolume = (d, v) -> {
d.volume = Math.min(Math.max(v, 0), 50);
};
// Apply settings
setBrightness.accept(tv, 75);
setVolume.accept(tv, 30);
setBrightness.accept(speaker, 0); // No brightness control
setVolume.accept(speaker, 25);
// Show final settings
tv.displaySettings();
speaker.displaySettings();
// Consumer with validation
ObjIntConsumer<Device> safeVolume = (d, v) -> {
if (d.name.contains("Speaker") && v > 40) {
System.out.println("Warning: High volume for speaker!");
}
setVolume.accept(d, v);
};
safeVolume.accept(speaker, 45);
speaker.displaySettings();
}
}
This example demonstrates using ObjIntConsumer for device configuration. Different consumers handle brightness and volume settings with appropriate constraints. The safeVolume consumer adds validation logic specific to speaker devices. This shows how ObjIntConsumer can encapsulate setting logic.
Source
Java ObjIntConsumer Interface Documentation
In this article, we've covered the essential methods and features of the Java ObjIntConsumer interface. Understanding these concepts is valuable for scenarios where you need to process objects in combination with primitive int values.
Author
List all Java tutorials.