Quelle est la syntaxe de mod en java
A titre d'exemple en pseudocode:
if ((a mod 2) == 0)
{
isEven = true;
}
else
{
isEven = false;
}
Pour les entiers non négatifs, vous pouvez utiliser l'opérateur reste / %. Pour votre exemple exact:
if ((a % 2) == 0)
{
isEven = true;
}
else
{
isEven = false;
}
Ceci peut être simplifié à une ligne:
isEven = (a % 2) == 0;
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 de caractère (%). 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'ints et renvoie un booléen. Ceci est ensuite affecté à la variable booléenne 'isEven'. Sur la base de la priorité des opérateurs, 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 "modulus" effectue en réalité l'opération restante. La différence entre mod et rem est subtile, mais importante.
(-1 mod 2) donnerait normalement 1. Plus précisément, étant donné deux nombres entiers, X et Y, l'opération (X mod Y) tend à renvoyer une valeur comprise dans l'intervalle [0, Y). Autrement dit, les modules de X et Y sont toujours supérieurs ou égaux à zéro et inférieurs à Y.
Effectuer 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 l'intervalle (-Y, 0]. Si X est positif, vous obtenez un résultat dans l'intervalle [0, Y).
Souvent, cette distinction subtile n'a pas d'importance. Pour 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 prolixe.
// Option 1: Clearest way for beginners
boolean isEven;
if ((a % 2) == 0)
{
isEven = true
}
else
{
isEven = false
}
La seconde approche tire un meilleur 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 par souci d’exhaustivité et utilise l’opérateur ternary . Bien que l'opérateur ternaire soit souvent très utile, dans ce cas, je considère que la deuxième approche est 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 d’entiers . Si le bit le moins significatif est 0, le nombre est pair. Ceci peut être vérifié en utilisant bitwise- et operator (&). Bien que cette approche soit la plus rapide (vous utilisez un 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é bitwise - et l'opérateur, et l'ai représenté sous la forme succincte présentée dans l'option 2. La réécriture dans le formulaire de l'option 1 (ou dans le cas de l'option 3) est laissée sous forme d'exercice au lecteur. ;)
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;
}
Bien qu'il soit possible de faire un bon modulo en vérifiant si la valeur est négative et le corriger si tel est le cas (comme beaucoup l'ont suggéré), il existe une solution plus compacte.
(a % b + b) % b
Ceci fera d’abord le modulo, en limitant la valeur à la plage -b -> + b, puis ajoutera b afin de s’assurer que la valeur est positive, en laissant le prochain modulo la limiter à la plage 0 -> b.
Remarque: Si b est négatif, le résultat sera également négatif.
Le code est beaucoup plus rapide sans utiliser modulo:
public boolean isEven(int a){
return ( (a & 1) == 0 );
}
public boolean isOdd(int a){
return ( (a & 1) == 1 );
}
En réalité, Java n’a pas d’opérateur modulo comme C. % en Java est un opérateur restant. Sur les entiers positifs, cela fonctionne exactement comme modulo, mais cela fonctionne différemment sur les entiers négatifs et, contrairement à modulo, peut aussi fonctionner avec des nombres à virgule flottante. Néanmoins, il est rare d'utiliser% sur autre chose que des entiers positifs. Si vous voulez l'appeler modulo, n'hésitez pas!
if (a % 2 == 0) {
} else {
}
vous devriez 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 outre, mod peut être utilisé comme ceci:
int a = 7;
b = a % 2;
b serait égal à 1. Parce que 7 % 2 = 1.
Le reste de l'opérateur Java est % et l'opérateur modulo peut être exprimé par
public int mod(int i, int j)
{
int rem = i % j;
if (j < 0 && rem > 0)
{
return rem + j;
}
if (j > 0 && rem < 0)
{
return rem + j;
}
return rem;
}
Une autre façon est:
boolean isEven = false;
if((a % 2) == 0)
{
isEven = true;
}
Mais le plus simple reste:
boolean isEven = (a % 2) == 0;
Comme @Steve Kuo a dit.
L'opérateur modulo est% (signe de pourcentage). Pour tester l'uniformité ou généralement modulo pour une puissance de 2, vous pouvez également utiliser & (l'opérateur) comme isEven =!.
Comme d'autres l'ont fait remarquer, l'opérateur % (reste) n'est pas le même que l'opération/fonction mathématique mod.
modvs%La fonction
x mod nmappexàndans la plage de[0,n).
Alors que l’opérateurx % nmappexàndans la plage de(-n,n).
Pour avoir une méthode pour utiliser l'opération de module mathématique sans 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 à comprendre cela en premier)
Dans Java, l'opération mod peut être effectuée de la manière suivante:
Math.floorMod(a, b)
Remarque: L'opération mod est différente de l'opération reste. Dans Java, l'opération reste peut être effectuée de la manière suivante:
a % b
En Java, il s'agit de l'opérateur %: 15.17.3. Opérateur restant%
Notez qu'il existe également floorMod dans la classe Java.lang.Math qui donnera un résultat différent de % pour les arguments avec des signes différents: