Quelle est la syntaxe du mod en java

À titre d'exemple en pseudocode:

if ((a mod 2) == 0)
{
    isEven = true;
}
else
{
    isEven = false;
}

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;

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!

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

if (a % 2 == 0) {
} else {
}

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 floorModdans la java.lang.Mathclasse qui donnera un résultat différent de %pour les arguments avec des signes différents:

public static int floorMod​(int x, int y)

De plus, le mod peut être utilisé comme ceci:

int a = 7;
b = a % 2;

bserait égal à 1. Parce que 7 % 2 = 1.

L'opérateur restant en Java est %et l'opérateur modulo peut être exprimé comme

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

Comme d'autres l'ont souligné, l' %opérateur (restant) n'est pas le même que l' modopération / la fonction du module mathématique .

mod contre %

La x mod nfonction correspond xà ndans la plage de [0,n).
Alors que les x % ncartes opérateur xà nl'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 xon 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)

Une autre façon est:

boolean isEven = false;
if((a % 2) == 0)
{
    isEven = true;
}

Mais le moyen le plus simple reste:

boolean isEven = (a % 2) == 0;

Comme l'a dit @Steve Kuo.

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

L'opérateur modulo est% (signe pourcentage). Pour tester la régularité ou généralement modulo pour une puissance de 2, vous pouvez également utiliser & (l'opérateur et) comme isEven =! (A & 1).

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 isEvencompense.