Wie überprüfe ich, ob eine Ganzzahl in einem bestimmten Bereich liegt?

Ich hoffe auf etwas eleganteres als

if (i>0 && i<100) 

Sie könnten Abstand hinzufügen;)

if (i > 0 && i < 100) 

Für Benutzer von Commons Lang besteht die Möglichkeit, Range :

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

Siehe auch: Erstellen eines Apache Commons 3.1 Range <Integer> -Objekts

Ich denke

if (0 < i && i < 100) 

ist eleganter. Sieht aus wie eine mathematische Gleichung.

Wenn Sie etwas Besonderes suchen, können Sie Folgendes ausprobieren:

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

Zumindest verwendet es Bibliothek.

Ich denke, es ist schon eine elegante Art, die Reichweite zu vergleichen. Dieser Ansatz führt jedoch dazu, dass Sie zusätzliche Komponententests schreiben, um alle &&Fälle zu erfüllen .

Sie können also einen der folgenden Ansätze verwenden, um das Schreiben zusätzlicher Komponententests zu vermeiden.

Verwenden von Java 8-Streams:

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

Verwenden der Matheklasse:

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

Persönlich empfehle ich den zweiten Ansatz, da dadurch kein Array mit der Größe erstellt wird, die dem Bereich entspricht, den Sie überprüfen möchten.

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

es gibt true zurück, wenn minValue <= x <= MaxValue - dh innerhalb des Bereichs

es gibt false zurück, wenn x <minValue oder x> maxValue - dh außerhalb des Bereichs

Verwenden Sie mit wenn Bedingung wie unten gezeigt:

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.");
}

Unter Programm wird geprüft, ob einer der übergebenen ganzzahligen Werte in der hasTeen-Methode im Bereich von 13 (einschließlich) bis 19 (einschließlich) liegt.

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;
    }
}

******AUSGABE******

wahr, da 19 Teil der Reichweite ist

wahr, da 15 Teil der Reichweite ist

false, da alle drei Werte außerhalb des Bereichs liegen

Ich verstehe nicht, dass das nicht elegant ist, aber wenn Sie den Ausdruck oft wiederholen, ist es eine gute Idee, ihn in eine Methode einzufügen, z

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

Dies gilt insbesondere dann, wenn Sie exklusive und inklusive Vergleiche mischen. Der Methodenname kann dazu beitragen, Tippfehler zu vermeiden, z. B. die Verwendung von <when ​​<= hätte verwendet werden sollen. Die Methode kann auch sicherstellen, dass min <max etc ..

Wenn Sie etwas Originelleres suchen als

if (i > 0 && i < 100)

Sie können dies versuchen

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

Dieser Typ hat eine schöne Range- Klasse gemacht.

Seine Verwendung ergibt jedoch keinen netten Code, da es sich um eine generische Klasse handelt. Sie müssten etwas eingeben wie:

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

oder (etwas besser, wenn Sie zuerst implementieren):

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

Semantisch sind beide meiner Meinung nach besser als das, was Java standardmäßig bietet, aber der Speicheraufwand, die Leistungsverschlechterung und insgesamt mehr Eingabe sind es wert. Persönlich mag ich mdmas Ansatz besser.

if ( 0 < i && i < 100)  

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

if (i <= 0 || i> = 100)

Es wird klappen.

So überprüfen Sie, ob eine Ganzzahl in einem Bereich liegt. Größer als die Untergrenze, kleiner als die Obergrenze. Der Versuch, mit Subtraktion klug zu sein, wird wahrscheinlich nicht das tun, was Sie wollen.

Versuchen:

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

es wird zumindest funktionieren;)

Verwenden Sie diesen Code:

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

Wenn Sie sicher sind, dass Zahlen in der 2er-Komplementform gespeichert sind:

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

Eine allgemeinere und sicherere Lösung wäre:

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

Wenn Sie Spring-Daten verwenden, können Sie auch das Range-Objekt von Spring verwenden.

range = new org.springframework.data.domain.Range (3, 8); range.contains (5) gibt true zurück.

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

Googles Java Library Guava implementiert auch 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);