How to Check Whether an Integer Exists in a Range with Java?

We can check whether an integer exists in a range in Java using conditional statements with the lower and upper bounds of the range.

To check whether an integer exists in a range, we can use the following steps:

Define the range (start and end) values.
Compare the integer to the range start and end values.
If the integer is greater than or equal to the range start value and less than or equal to the range end value, then the integer exists in the range. Otherwise, the integer does not exist in the range.

IntegerRangeChecker.java

public class IntegerRangeChecker {
    public static void main(String[] args) {
        int numberToCheck = 7;
        int rangeStart = 5;
        int rangeEnd = 10;
        if (numberToCheck >= rangeStart && numberToCheck <= rangeEnd) {
            System.out.println(numberToCheck + " is within the range [" + rangeStart + ", " + rangeEnd + "]");
        } else {
            System.out.println(numberToCheck + " is outside the range [" + rangeStart + ", " + rangeEnd + "]");
        }
    }
}

Output:

7 is within the range [5, 10]

Range Types:

We will focus on these four bounded range types throughout this section.

Closed range - includes its lower and upper bounds.
Open range - excludes its lower and upper bounds.
Left-open right-closed range - Includes its upper bound and excludes it's lower bound.
Left-closed right-open range - Includes its lower bound and excludes it's upper bound.

For example, suppose we want to know whether the integer 20 occurs within these two ranges: R1 = [10, 20), a left-closed right-open range, and R2 = (10, 20], a left-open right-closed range. Since R1 does not contain its upper bound, the integer 20 exists only in R2.

Using the < and <= Operators

IntRangeOperators.java

public class IntRangeOperators {
    public static void main(String[] args) {
        boolean result1 = isInClosedOpenRange(100, 100,1000);
        System.out.println(result1);
        boolean result2 = isInClosedRange(40, 40, 100);
        System.out.println(result2);
        boolean result3 = isInOpenRange(20, 10, 1000);
        System.out.println(result3);
        boolean result4 = isInOpenClosedRange(20, 10, 20);
        System.out.println(result4);
    }
    public static boolean isInClosedRange(Integer number, Integer lowerBound, Integer upperBound) {
        return (lowerBound <= number && number <= upperBound);
    }
    public static boolean isInOpenRange(Integer number, Integer lowerBound, Integer upperBound) {
        return (lowerBound < number && number < upperBound);
    }
    public static boolean isInOpenClosedRange(Integer number, Integer lowerBound, Integer upperBound) {
        return (lowerBound < number && number <= upperBound);
    }
    public static boolean isInClosedOpenRange(Integer number, Integer lowerBound, Integer upperBound) {
        return (lowerBound <= number && number < upperBound);
    }
}

Output:

true
true
true
true

Using Apache Commons Library

Let's move on to some range classes we can use from third-party libraries. First, we will add the Apache Commons dependency to our project:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

Here, we're implementing the same behavior as before, but using the Apache Commons Range class:

IntRangeApacheCommons.java

public class IntRangeApacheCommons {
    public boolean isInClosedRange(Integer number, Integer lowerBound, Integer upperBound) {
        final Range<Integer> range = Range.between(lowerBound, upperBound);
        return range.contains(number);
    }
    public boolean isInOpenRange(Integer number, Integer lowerBound, Integer upperBound) {
        final Range<Integer> range = Range.between(lowerBound + 1, upperBound - 1);
        return range.contains(number);
    }
    public boolean isInOpenClosedRange(Integer number, Integer lowerBound, Integer upperBound) {
        final Range<Integer> range = Range.between(lowerBound + 1, upperBound);
        return range.contains(number);
    }
    public boolean isInClosedOpenRange(Integer number, Integer lowerBound, Integer upperBound) {
        final Range<Integer> range = Range.between(lowerBound, upperBound - 1);
        return range.contains(number);
    }
public static void main(String[] args) {
    IntRangeApacheCommons rangeChecker = new IntRangeApacheCommons();
    System.out.println(rangeChecker.isInClosedRange(5, 1, 10));       
    System.out.println(rangeChecker.isInClosedRange(15, 1, 10));
    System.out.println(rangeChecker.isInOpenRange(5, 1, 10));   
    System.out.println(rangeChecker.isInOpenRange(6, 1, 10));               
    System.out.println(rangeChecker.isInOpenClosedRange(5, 1, 10)); 
    System.out.println(rangeChecker.isInClosedOpenRange(5, 1, 10));         
    System.out.println(rangeChecker.isInClosedOpenRange(10, 1, 10));      
}
}

Output:

true (5 is in [1, 10])
false (15 is outside [1, 10])
false (5 is not in (1, 10))
true (6 is in (1, 10))
false (5 is not in (2, 10))
true (5 is in [1, 9])
false (10 is outside [1, 9])

Using IntStream Class

Another approach to check if an integer exists within a range is by utilizing the IntStream class that is available in Java 8 and later versions. The IntStream class provides various methods, including range() and anyMatch() that allow us to create a range of integers and check if a value matches any element in the range.

Here's an example code snippet that demonstrates the usage of the IntStream class:

CheckRange.java

import java.util.stream.IntStream;
class CheckRange {
    public static void main(String[] args) {
        int number = 10;
        int lowerBound = 5;
        int upperBound = 15;
        boolean isInRange = IntStream.rangeClosed(lowerBound, upperBound)
                             .anyMatch(value -> value == number);
        if (isInRange) {
            System.out.println("The number is within the range.");
        } else {
            System.out.println("The number is outside the range.");
        }
    }  
}

Output:

The number is within the range.

Conclusion:

Checking whether an integer exists within a range is a common task in Java programming. We have explored three different approaches to accomplish this task: using comparison operators, utilizing the Range class from Apache Commons, and leveraging the IntStream class. Each approach has its advantages and can be chosen based on the complexity of the range and the specific requirements of our project.

By mastering these techniques, we will be able to efficiently handle range checks in our Java programs, ensuring that our code operates within the desired boundaries. So go ahead, experiment with these approaches, and unlock the power of range checking in Java.

Next TopicHttpEntity in Java

← prev next →