如何检查整数是否在给定范围内？

希望有比这更优雅的东西

if (i>0 && i<100) 

您可以添加间距;）

if (i > 0 && i < 100) 

对于那些使用公共语言的人，可以选择使用Range：

Range<Integer> myRange = Range.between(100, 500);
if (myRange.contains(200)){
    // do something
}

另请参阅：如何构造Apache Commons 3.1 Range <Integer>对象

我认为

if (0 < i && i < 100) 

更优雅。看起来像数学方程式。

如果您正在寻找特殊的东西，可以尝试：

Math.max(0, i) == Math.min(i, 100)

至少它使用库。

我认为它已经是比较优雅的方式来比较范围了。但是，这种方法会使您编写额外的单元测试来满足所有&&情况。

因此，可以使用以下任何一种方法来避免编写额外的单元测试。

使用Java 8流：

if(IntStream.rangeClosed(0,100).boxed().collect(Collectors.toList()).contains(i))

使用数学类：

if(Math.max(0, i) == Math.min(i, 100))

我个人建议第二种方法，因为它最终不会创建大小等于要检查范围的数组。

ValueRange range = java.time.temporal.ValueRange.of(minValue, maxValue);
range.isValidIntValue(x);

如果minValue <= x <= MaxValue-即在范围内，则返回true

如果x <minValue或x> maxValue-即超出范围，则返回false

与if条件一起使用，如下所示：

int value = 10;
if(ValueRange.of(0, 100).isValidIntValue(value)) {
    System.out.println("Value is with in the Range.");
} else {
    System.out.println("Value is out of the Range.");
}

下面的程序检查hasNeen方法中传递的整数值是否在13（含）到19（含）范围内

import java.time.temporal.ValueRange;    
public class TeenNumberChecker {

    public static void main(String[] args) {
        System.out.println(hasTeen(9, 99, 19));
        System.out.println(hasTeen(23, 15, 42));
        System.out.println(hasTeen(22, 23, 34));

    }

    public static boolean hasTeen(int firstNumber, int secondNumber, int thirdNumber) {

        ValueRange range = ValueRange.of(13, 19);
        System.out.println("*********Int validation Start ***********");
        System.out.println(range.isIntValue());
        System.out.println(range.isValidIntValue(firstNumber));
        System.out.println(range.isValidIntValue(secondNumber));
        System.out.println(range.isValidIntValue(thirdNumber));
        System.out.println(range.isValidValue(thirdNumber));
        System.out.println("**********Int validation End**************");

        if (range.isValidIntValue(firstNumber) || range.isValidIntValue(secondNumber) || range.isValidIntValue(thirdNumber)) {
            return true;
        } else
            return false;
    }
}

******输出******

正确，因为19是范围的一部分

正确，因为15是范围的一部分

如果所有三个值都超出范围，则返回false

我看不出这不是很优雅，但是如果您经常重复该表达式，那么将其放入方法中是个好主意，例如

class MathUtil
{
   public static boolean betweenExclusive(int x, int min, int max)
   {
       return x>min && x<max;    
   }
}

如果您将排他性和包含性比较混合在一起，则尤其如此。方法名称可以帮助避免输入错误，例如在应该使用<=时使用<。该方法还可以确保确保min <max等。

如果您正在寻找比...更原始的东西

if (i > 0 && i < 100)

你可以试试这个

import static java.lang.Integer.compare;
...
if(compare(i, 0) > compare(i, 100))

这家伙打了一个漂亮范围类。

但是，由于它是泛型类，因此使用它不会产生很好的代码。您必须输入以下内容：

if (new Range<Integer>(0, 100).contains(i))

或（如果先实施则更好）：

class IntRange extends Range<Integer>
....
if (new IntRange(0,100).contains(i))

在语义上，两者都比默认情况下Java提供的更好IMHO，但是内存开销，性能下降和更多类型的总体输入是非常值得的。我个人更喜欢mdma的方法。

if ( 0 < i && i < 100)  

if ( 'a' <= c && c <= 'z' )

if（i <= 0 || i> = 100）

会的。

这就是您检查整数是否在范围内的方法。大于下限，小于上限。试图巧妙地进行减法运算可能不会做您想要的。

尝试：

if (i>0 && i<100) {} 

它至少会工作;）

使用此代码：

if (lowerBound <= val && val < upperBound)
or
if (lowerBound <= val && val <= upperBound)

如果您确信数字以2的补数形式存储：

return  ((x-low) <= (high-low));

一个更通用，更安全的解决方案是：

return ((x-high)*(x-low) <= 0);

如果您使用的是Spring数据，则还可以使用Spring中的Range对象。

范围=新的org.springframework.data.domain.Range（3，8）; range.contains（5）将返回true。

 Range<Long> timeRange = Range.create(model.getFrom(), model.getTo());
    if(timeRange.contains(systemtime)){
        Toast.makeText(context, "green!!", Toast.LENGTH_SHORT).show();
    }

Google的Java库Guava也实现了Range：

import com.google.common.collect.Range;

Range<Integer> open = Range.open(1, 5);
System.out.println(open.contains(1)); // false
System.out.println(open.contains(3)); // true
System.out.println(open.contains(5)); // false

Range<Integer> closed = Range.closed(1, 5);
System.out.println(closed.contains(1)); // true
System.out.println(closed.contains(3)); // true
System.out.println(closed.contains(5)); // true

Range<Integer> openClosed = Range.openClosed(1, 5);
System.out.println(openClosed.contains(1)); // false
System.out.println(openClosed.contains(3)); // true
System.out.println(openClosed.contains(5)); // true

    val = val < MIN ? MIN : ( val > MAX ? MAX : val);