Java IntPredicate Interface
Last modified: April 16, 2025
The java.util.function.IntPredicate interface represents a predicate
that accepts an int-valued argument. It is a functional interface with a single
abstract method test. IntPredicate is commonly used for filtering
operations on streams of primitive integers.
IntPredicate is part of Java's functional programming utilities added
in Java 8. It enables behavior parameterization for primitive int values. The
interface provides default methods for predicate composition and chaining.
IntPredicate Interface Overview
IntPredicate interface contains one abstract method and several default
methods. The key method test evaluates the predicate on the input.
Other methods enable logical operations between predicates.
@FunctionalInterface
public interface IntPredicate {
boolean test(int value);
default IntPredicate and(IntPredicate other);
default IntPredicate or(IntPredicate other);
default IntPredicate negate();
}
The code above shows the structure of IntPredicate interface. It
operates on primitive int values to avoid boxing overhead. The interface is
annotated with @FunctionalInterface to indicate its single abstract method nature.
Basic IntPredicate Usage
The simplest way to use IntPredicate is with lambda expressions. We define the condition to test on the input value. The example checks if numbers are even.
package com.zetcode;
import java.util.function.IntPredicate;
public class Main {
public static void main(String[] args) {
// Define a predicate that tests if a number is even
IntPredicate isEven = n -> n % 2 == 0;
// Test the predicate
System.out.println("Is 4 even? " + isEven.test(4));
System.out.println("Is 7 even? " + isEven.test(7));
// Predicate for numbers greater than 10
IntPredicate isGreaterThan10 = n -> n > 10;
System.out.println("Is 15 > 10? " + isGreaterThan10.test(15));
}
}
This example demonstrates basic IntPredicate usage with lambda expressions. The isEven predicate checks if a number is divisible by 2. We test it with different values. The isGreaterThan10 shows another simple condition.
Combining Predicates with AND
The and method allows combining two predicates with logical AND.
Both predicates must evaluate to true for the combined predicate to return true.
package com.zetcode;
import java.util.function.IntPredicate;
public class Main {
public static void main(String[] args) {
// Define individual predicates
IntPredicate isEven = n -> n % 2 == 0;
IntPredicate isGreaterThan10 = n -> n > 10;
// Combine with AND
IntPredicate isEvenAndGreaterThan10 = isEven.and(isGreaterThan10);
System.out.println("12: " + isEvenAndGreaterThan10.test(12));
System.out.println("8: " + isEvenAndGreaterThan10.test(8));
System.out.println("15: " + isEvenAndGreaterThan10.test(15));
}
}
This example shows predicate composition with and. The combined
predicate checks if a number is both even and greater than 10. Only 12 satisfies
both conditions in our test cases.
Combining Predicates with OR
The or method combines two predicates with logical OR. Either
predicate can be true for the combined predicate to return true.
package com.zetcode;
import java.util.function.IntPredicate;
public class Main {
public static void main(String[] args) {
// Define individual predicates
IntPredicate isNegative = n -> n < 0;
IntPredicate isDivisibleBy3 = n -> n % 3 == 0;
// Combine with OR
IntPredicate isNegativeOrDivisibleBy3 = isNegative.or(isDivisibleBy3);
System.out.println("-5: " + isNegativeOrDivisibleBy3.test(-5));
System.out.println("9: " + isNegativeOrDivisibleBy3.test(9));
System.out.println("7: " + isNegativeOrDivisibleBy3.test(7));
}
}
This example demonstrates predicate composition with or. The combined
predicate checks if a number is either negative or divisible by 3. -5 and 9
satisfy at least one condition, while 7 satisfies neither.
Negating a Predicate
The negate method returns a predicate that represents the logical
negation of the original predicate. It inverts the result of the test.
package com.zetcode;
import java.util.function.IntPredicate;
public class Main {
public static void main(String[] args) {
// Original predicate
IntPredicate isPrime = n -> {
if (n < 2) return false;
for (int i = 2; i <= Math.sqrt(n); i++) {
if (n % i == 0) return false;
}
return true;
};
// Negated predicate
IntPredicate isNotPrime = isPrime.negate();
System.out.println("Is 7 prime? " + isPrime.test(7));
System.out.println("Is 8 not prime? " + isNotPrime.test(8));
}
}
This example shows predicate negation with negate. The isPrime
predicate checks for prime numbers, while isNotPrime inverts this logic.
The results demonstrate the negation in action.
Using IntPredicate with IntStream
IntPredicate is commonly used with IntStream for filtering operations. The filter method accepts an IntPredicate to include only matching elements. This enables efficient processing of primitive int streams.
package com.zetcode;
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
// Define a predicate for perfect squares
IntPredicate isPerfectSquare = n -> {
int sqrt = (int) Math.sqrt(n);
return sqrt * sqrt == n;
};
// Filter a range of numbers
System.out.println("Perfect squares between 1 and 100:");
IntStream.rangeClosed(1, 100)
.filter(isPerfectSquare)
.forEach(System.out::println);
}
}
This example shows IntPredicate usage with IntStream. We define a predicate to identify perfect squares, then use it to filter numbers from 1 to 100. The stream pipeline prints only numbers that satisfy the condition.
Chaining Multiple Predicates
IntPredicate methods can be chained to create complex conditions from simple predicates. This approach improves code readability and maintainability.
package com.zetcode;
import java.util.function.IntPredicate;
public class Main {
public static void main(String[] args) {
// Define base predicates
IntPredicate isEven = n -> n % 2 == 0;
IntPredicate isPositive = n -> n > 0;
IntPredicate isTwoDigits = n -> n >= 10 && n <= 99;
// Chain predicates
IntPredicate complexCondition = isPositive
.and(isTwoDigits)
.and(isEven.negate());
System.out.println("15: " + complexCondition.test(15));
System.out.println("22: " + complexCondition.test(22));
System.out.println("105: " + complexCondition.test(105));
}
}
This example demonstrates chaining multiple IntPredicate operations. The complexCondition checks for positive, two-digit, odd numbers. Each test case shows how different combinations of conditions evaluate.
Method Reference as IntPredicate
Method references can be used to create IntPredicate instances when existing methods match the functional interface requirements. This provides concise syntax.
package com.zetcode;
import java.util.function.IntPredicate;
public class NumberUtils {
public static boolean isPalindrome(int number) {
String s = Integer.toString(number);
return new StringBuilder(s).reverse().toString().equals(s);
}
}
public class Main {
public static void main(String[] args) {
// Method reference as IntPredicate
IntPredicate isPalindrome = NumberUtils::isPalindrome;
System.out.println("1221: " + isPalindrome.test(1221));
System.out.println("1234: " + isPalindrome.test(1234));
}
}
This example shows using a method reference as an IntPredicate. The NumberUtils.isPalindrome method checks if a number reads the same forwards and backwards. We reference this method to create a predicate instance.
Source
Java IntPredicate Interface Documentation
In this article, we've covered the essential methods and features of the Java IntPredicate interface. Understanding these concepts is crucial for functional programming and stream processing with primitive integers in Java.
Author
List all Java tutorials.