Réponses:
Au lieu de l'opérateur modulo, qui a une sémantique légèrement différente, pour les entiers non négatifs, vous pouvez utiliser l' opérateur restant%
. Pour votre exemple exact:
if ((a % 2) == 0)
{
isEven = true;
}
else
{
isEven = false;
}
Cela peut être simplifié en une seule ligne:
isEven = (a % 2) == 0;
%
était évalué avant de le ==
rechercher, il serait donc difficile de savoir si l'expression est équivalente à (a%2)==0
ou a%(2==0)
. Je suppose que c'est moins important en java où un booléen n'est pas le même qu'un entier
Voici la représentation de votre pseudo-code en code Java minimal;
boolean isEven = a % 2 == 0;
Je vais maintenant le décomposer en ses composants. L'opérateur de module en Java est le pourcentage (%). Par conséquent, prendre un int% int renvoie un autre int. L'opérateur double égal (==) est utilisé pour comparer des valeurs, telles qu'une paire d'entiers et renvoie un booléen. Ceci est ensuite affecté à la variable booléenne 'isEven'. En fonction de la priorité de l'opérateur, le module sera évalué avant la comparaison.
Puisque tout le monde a déjà donné la réponse, je vais ajouter un peu de contexte supplémentaire. % l'opérateur "module" effectue actuellement l'opération restante. La différence entre mod et rem est subtile, mais importante.
(-1 mod 2) donnerait normalement 1. Plus spécifiquement, étant donné deux entiers, X et Y, l'opération (X mod Y) tend à renvoyer une valeur dans la plage [0, Y). Autrement dit, le module de X et Y est toujours supérieur ou égal à zéro, et inférieur à Y.
L'exécution de la même opération avec l'opérateur "%" ou rem conserve le signe de la valeur X. Si X est négatif, vous obtenez un résultat dans la plage (-Y, 0]. Si X est positif, vous obtenez un résultat dans la plage [0, Y).
Souvent, cette distinction subtile n'a pas d'importance. Pour en revenir à votre question de code, cependant, il existe plusieurs façons de résoudre le problème de "régularité".
La première approche est bonne pour les débutants, car elle est particulièrement verbeuse.
// Option 1: Clearest way for beginners
boolean isEven;
if ((a % 2) == 0)
{
isEven = true
}
else
{
isEven = false
}
La deuxième approche tire mieux parti du langage et conduit à un code plus succinct. (N'oubliez pas que l'opérateur == renvoie un booléen.)
// Option 2: Clear, succinct, code
boolean isEven = ((a % 2) == 0);
La troisième approche est ici pour l'exhaustivité et utilise l' opérateur ternaire . Bien que l'opérateur ternaire soit souvent très utile, dans ce cas, je considère la deuxième approche comme supérieure.
// Option 3: Ternary operator
boolean isEven = ((a % 2) == 0) ? true : false;
La quatrième et dernière approche consiste à utiliser la connaissance de la représentation binaire des nombres entiers . Si le bit le moins significatif est 0, alors le nombre est pair. Cela peut être vérifié à l'aide de l' opérateur au niveau du bit et (&). Bien que cette approche soit la plus rapide (vous faites du masquage de bits simple au lieu de la division), elle est peut-être un peu avancée / compliquée pour un débutant.
// Option 4: Bitwise-and
boolean isEven = ((a & 1) == 0);
Ici, j'ai utilisé l'opérateur bit à bit et et je l'ai représenté sous la forme succincte illustrée dans l'option 2. La réécrire sous la forme de l'option 1 (et alternativement de l'option 3) est laissée au lecteur comme exercice. ;)
J'espère que cela pourra aider.
Pour que l'opération% (REM) de Java fonctionne comme MOD pour les valeurs X négatives et Y positives, vous pouvez utiliser cette méthode:
private int mod(int x, int y)
{
int result = x % y;
if (result < 0)
{
result += y;
}
return result;
}
ou avec l'opérateur ternaire (plus court, mais pas possible ou moins efficace dans certaines situations):
private int mod(int x, int y)
{
int result = x % y;
return result < 0? result + y : result;
}
Java n'a en fait pas d'opérateur modulo comme le fait C. % en Java est un opérateur restant. Sur les entiers positifs, il fonctionne exactement comme modulo, mais il fonctionne différemment sur les entiers négatifs et, contrairement à modulo, peut également fonctionner avec des nombres à virgule flottante. Pourtant, il est rare d'utiliser% sur autre chose que des entiers positifs, donc si vous voulez l'appeler un modulo, alors n'hésitez pas!
array[x mod array.length]
toujours accède à un élément de mon tableau plutôt que d'essayer d'indexer les positions négatives.
(x % y + y) % y
ou à partir de Java 8,Math.floorMod(x, y)
Bien qu'il soit possible de faire un modulo approprié en vérifiant si la valeur est négative et en la corrigeant si elle l'est (comme beaucoup l'ont suggéré), il existe une solution plus compacte.
(a % b + b) % b
Cela fera d'abord le modulo, en limitant la valeur à la plage -b -> + b, puis ajoutera b afin de garantir que la valeur est positive, laissant le modulo suivant la limiter à la plage 0 -> b.
Remarque: si b est négatif, le résultat sera également négatif
Le code s'exécute beaucoup plus rapidement sans utiliser modulo:
public boolean isEven(int a){
return ( (a & 1) == 0 );
}
public boolean isOdd(int a){
return ( (a & 1) == 1 );
}
vous devez examiner la spécification avant d'utiliser l'opérateur 'reste'%:
http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.17.3
// bad enough implementation of isEven method, for fun. so any worse?
boolean isEven(int num)
{
num %= 10;
if(num == 1)
return false;
else if(num == 0)
return true;
else
return isEven(num + 2);
}
isEven = isEven(a);
En Java, c'est l' %
opérateur:
15.17.3. Opérateur restant%
Notez qu'il y a aussi floorMod
dans la java.lang.Math
classe qui donnera un résultat différent de %
pour les arguments avec des signes différents:
%
car il fonctionne également correctement lorsque l'argument est également négatif. Aucune des autres réponses n'est vraiment correcte car elles sont accompagnées de la clause de non-responsabilité selon laquelle% n'est pas vraiment modulo, sauf si les arguments sont positifs. En particulier, si vous souhaitez mapper chaque entier à une position consécutive dans un tableau, il array[floorMod(i, array.length)
fonctionne correctement même si l'index i
passe en territoire négatif. Pas avec %
.
De plus, le mod peut être utilisé comme ceci:
int a = 7;
b = a % 2;
b
serait égal à 1. Parce que 7 % 2 = 1
.
Comme d'autres l'ont souligné, l' %
opérateur (restant) n'est pas le même que l' mod
opération / la fonction du module mathématique
.
mod
contre%
La
x mod n
fonction correspondx
àn
dans la plage de[0,n)
.
Alors que lesx % n
cartes opérateurx
àn
l'ordre de(-n,n)
.
Afin d'avoir une méthode pour utiliser l'opération de module mathématique et ne pas se soucier du signe devant x
on peut utiliser:
((x % n) + n) % n
Peut-être que cette image aide à mieux la comprendre (j'ai eu du mal à envelopper ma tête autour de cette première)
int
variable elle-même. La floorMod
méthode le fait correctement (mais vous pouvez avoir besoin de calculs supplémentaires si elle n
est négative).
Dans Java
, l' opération de mod peut être effectuée comme telle:
Math.floorMod(a, b)
Remarque:
L' opération mod est différente de l' opération restante . Dans Java
, l' opération restante peut être effectuée comme telle:
a % b
Math.floorMod()
a: The floor modulus is x - (floorDiv(x, y) * y), has the same sign as the divisor y, and is in the range of -abs(y) < r < +abs(y).
Donc ce n'est pas exactement le même que le module mathématique. Mais , il existe un moyen d'obtenir un résultat positif, également dans le Javadoc de la même méthode:If the signs of arguments are unknown and a positive modulus is needed it can be computed as (floorMod(x, y) + abs(y)) % abs(y).
floorMod
opération fonctionne comme prévu. Il y a aussi les valeurs floorMod
for long
et sinon il y a BigInteger
des valeurs plus grandes.
Une alternative au code de @Cody:
Utilisation de l'opérateur module:
bool isEven = (a % 2) == 0;
Je pense que c'est un code légèrement meilleur que d'écrire if / else, car il y a moins de duplication et de flexibilité inutilisée. Cela nécessite un peu plus de puissance cérébrale à examiner, mais la bonne dénomination de isEven
compense.