En espérant quelque chose de plus élégant que
if (i>0 && i<100)
Vous pouvez ajouter un espacement;)
if (i > 0 && i < 100)
Je pense
if (0 < i && i < 100)
est plus élégant. On dirait une équation mathématique.
Si vous recherchez quelque chose de spécial, vous pouvez essayer:
Math.max(0, i) == Math.min(i, 100)
au moins, il utilise la bibliothèque.
Pour ceux qui utilisent commons lang, une option consiste à utiliser Range :
Range<Integer> myRange = Range.between(100, 500);
if (myRange.contains(200)){
// do something
}
Voir aussi: comment construire un objet Apache commons 3.1 Range <Integer>
Je ne vois pas en quoi cela n’est pas élégant, mais si vous répétez souvent l’expression, c’est une bonne idée de l’intégrer dans une méthode, par exemple.
class MathUtil
{
public static boolean betweenExclusive(int x, int min, int max)
{
return x>min && x<max;
}
}
Cela est particulièrement vrai si vous mélangez des comparaisons exclusives et inclusives. Le nom de la méthode peut aider à éviter les fautes de frappe, telles que l’utilisation de <quand <= aurait dû être utilisé. La méthode peut également s’assurer que min <max etc.
Ce type a créé une classe Nice Range .
Son utilisation ne produira toutefois pas de code Nice, car il s’agit d’une classe générique. Vous devez taper quelque chose comme:
if (new Range<Integer>(0, 100).contains(i))
ou (un peu mieux si vous implémentez d'abord):
class IntRange extends Range<Integer>
....
if (new IntRange(0,100).contains(i))
Sémantiquement, les deux sont IMHO plus agréables que ce que Java offre par défaut, mais la surcharge de mémoire, la dégradation des performances et plus de frappe en général en valent la peine. Personnellement, j'aime mieux l'approche de mdma .
Si vous cherchez quelque chose de plus original que
if (i > 0 && i < 100)
tu peux essayer ça
import static Java.lang.Integer.compare;
...
if(compare(i, 0) > compare(i, 100))
if ( 0 < i && i < 100)
if ( 'a' <= c && c <= 'z' )
Je pense que c'est déjà un moyen élégant de comparer la gamme. Cependant, cette approche vous oblige à écrire des tests unitaires supplémentaires pour satisfaire tous les cas &&
.
Vous pouvez donc utiliser l’une des méthodes ci-dessous pour éviter d’écrire des tests unitaires supplémentaires.
Utilisation de Java 8 Streams:
if(IntStream.rangeClosed(0,100).boxed().collect(Collectors.toList()).contains(i))
Utilisation de la classe de mathématiques:
if(Math.max(0, i) == Math.min(i, 100))
Personnellement, je recommande la deuxième approche car elle ne créera pas un tableau de la taille égale à la plage que vous souhaitez vérifier.
si (i <= 0 || i> = 100)
Ça va marcher.
Utilisez ce code:
if (lowerBound <= val && val < upperBound)
or
if (lowerBound <= val && val <= upperBound)
ValueRange range = ValueRange.of(minValue, maxValue);
range.isValidIntValue(x);
il renvoie true si minValue <= x <= MaxValue - c'est-à-dire dans la plage
il retourne false si x <minValue ou x> maxValue - i.e hors limites
sous les contrôles de programme, si l'une des valeurs entières passées dans la méthode hasTeen est comprise entre 13 (inclus) et 19 (inclus)
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;
}
}
******SORTIE******
vrai que 19 fait partie de la plage
vrai que 15 fait partie de la plage
false car les trois valeurs sont passées hors limites
Essayer:
if (i>0 && i<100) {}
cela fonctionnera au moins;)
Si vous êtes sûr que les nombres sont stockés sous forme de complément à 2:
return ((x-low) <= (high-low));
Une solution plus générale et plus sûre serait:
return ((x-high)*(x-low) <= 0);
si vous utilisez des données Spring, vous pouvez également utiliser l'objet Range de Spring.
range = new org.springframework.data.domain.Range (3, 8); range.contains (5) renvoie true.
Range<Long> timeRange = Range.create(model.getFrom(), model.getTo());
if(timeRange.contains(systemtime)){
Toast.makeText(context, "green!!", Toast.LENGTH_SHORT).show();
}
C'est comme ça que vous vérifiez si un entier est dans une plage. Supérieur à la limite inférieure, inférieur à la limite supérieure. Essayer d'être intelligent avec la soustraction ne fera probablement pas ce que vous voulez.