Plages en Java, quelle est la meilleure approche?

Question

D'accord, disons un entier A doit avoir l'ordre de: [0 ... 2147483647]

Donc, fondamentalement, le pseudo-code va comme ceci: si entier A est dans cette plage faire quelque chose ... sinon faire autre chose.

Je sais que cela peut être accompli par une simple instruction if..else, mais y a-t-il un moyen plus efficace de vérifier si A est dans la plage?

Je ne veux pas aller avec cela parce qu'il semble si mal:

if (A >= 0 && A <= 2147483647){ 
    // do something 
}else{ 
    // do something else 
} 

edit: Je pense que je pose la mauvaise question, je suis juste me demander, comment faire en utilisant l'approche polymorphe. J'ai juste besoin d'une illustration simple parce que le livre que j'ai lu a un très long exemple. > _ < Désolé.

Answer 1

Vous aurez un if-check, quel que soit l'efficacité avec laquelle vous essayez d'optimiser ce calcul pas si intensif :) Vous pouvez soustraire la borne supérieure du nombre et si elle est positive, vous savez que vous êtes hors de portée. Vous pouvez peut-être effectuer une logique de décalage booléen pour le comprendre et vous pouvez même utiliser le théorème de Fermat si vous voulez (blague :) Mais le point est "pourquoi" avez-vous besoin d'optimiser cette comparaison? Quel est le but?

Answer 2

Vous pouvez créer une classe pour représenter ce

Range range = new Range(0, 2147483647); 

if(range.contains(A)){ 
    //do something 
}else{ //do something else } 



public class Range { 

    private int low; 
    private int high; 

    public Range(int low, int high){ 
     this.low = low; 
     this.high = high; 
    } 

    public boolean contains(int number){ 
     return (number >= low && number <= high); 
    } 
} 

Answer 3

Si vous vérifiez contre beaucoup d'intervalles, je suggère d'utiliser un interval tree.

Answer 4

Apache Commons Lang a un Range class pour effectuer des plages arbitraires.

Range<Integer> test = Range.between(1, 3); 
System.out.println(test.contains(2)); 
System.out.println(test.contains(4)); 

Guava Range a API similaire.

Si vous souhaitez simplement vérifier si un nombre correspond à une valeur longue ou à une valeur int, vous pouvez essayer de l'utiliser via BigDecimal. Il existe des méthodes pour longValueExact et intValueExact qui lancent des exceptions si la valeur est trop grande pour ces précisions.

Answer 5

Vous pouvez utiliser java.time.temporal.ValueRange qui accepte long et travailleraient aussi avec int:

int a = 2147; 

    //Use java 8 java.time.temporal.ValueRange. The range defined 
    //is inclusive of both min and max 
    ValueRange range = ValueRange.of(0,2147483647); 

    if(range.isValidValue(a)) { 
     System.out.println(" in range "); 
    }else { 
     System.out.println(" not in range "); 
    } 

Answer 6

Je sais que cela est tout à fait une question ancienne, mais avec Java 8 de cours d'eau, vous pouvez obtenir une gamme de int s comme celui-ci:

IntStream.rangeClosed(0, Integer.MAX_VALUE); // gives an IntStream of integers from 0 through Integer.MAX_VALUE 

vous pouvez faire quelque chose comme ceci:

if (IntStream.rangeClosed(0, Integer.MAX_VALUE).matchAny(n -> n == A)) { 
    // do something 
} else { 
    // do something else 
}