Qual è la sintassi per mod in Java

Ad esempio in pseudocodice:

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

Invece dell'operatore modulo, che ha una semantica leggermente diversa, per numeri interi non negativi, è possibile utilizzare l' operatore residuo% . Per il tuo esempio esatto:

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

Questo può essere semplificato in una riga:

isEven = (a % 2) == 0;

Ecco la rappresentazione del tuo pseudo-codice in un codice Java minimo;

boolean isEven = a % 2 == 0;

Ora lo scompongo nei suoi componenti. L'operatore del modulo in Java è il carattere percentuale (%). Pertanto, prendere un int% int restituisce un altro int. L'operatore double equals (==) viene utilizzato per confrontare valori, come una coppia di ints e restituisce un valore booleano. Questo viene quindi assegnato alla variabile booleana 'isEven'. In base alla precedenza dell'operatore, il modulo verrà valutato prima del confronto.

Poiché tutti gli altri hanno già dato la risposta, aggiungerò un po 'di contesto aggiuntivo. % l'operatore "modulo" sta effettivamente eseguendo l'operazione rimanente. La differenza tra mod e rem è sottile, ma importante.

(-1 mod 2) normalmente darebbe 1. Più specificatamente dati due numeri interi, X e Y, l'operazione (X mod Y) tende a restituire un valore nell'intervallo [0, Y). Detto diversamente, il modulo di X e Y è sempre maggiore o uguale a zero e minore di Y.

L'esecuzione della stessa operazione con "%" o l'operatore rem mantiene il segno del valore X. Se X è negativo si ottiene un risultato nell'intervallo (-Y, 0]. Se X è positivo si ottiene un risultato nell'intervallo [0, Y).

Spesso questa sottile distinzione non ha importanza. Tornando alla domanda sul codice, tuttavia, ci sono diversi modi per risolvere "uniformità".

Il primo approccio è buono per i principianti, perché è particolarmente prolisso.

// Option 1: Clearest way for beginners
boolean isEven;
if ((a % 2) == 0)
{
  isEven = true
}
else
{
  isEven = false
}

Il secondo approccio sfrutta meglio il linguaggio e porta a un codice più conciso. (Non dimenticare che l'operatore == restituisce un valore booleano.)

// Option 2: Clear, succinct, code
boolean isEven = ((a % 2) == 0);

Il terzo approccio è qui per completezza e utilizza l' operatore ternario . Sebbene l'operatore ternario sia spesso molto utile, in questo caso considero superiore il secondo approccio.

// Option 3: Ternary operator
boolean isEven = ((a % 2) == 0) ? true : false;

Il quarto e ultimo approccio consiste nell'utilizzare la conoscenza di rappresentazione binaria di numeri interi . Se il bit meno significativo è 0, il numero è pari. Questo può essere verificato usando l' operatore bit-bit (&). Mentre questo approccio è il più veloce (stai facendo un semplice mascheramento dei bit invece della divisione), è forse un po 'avanzato / complicato per un principiante.

// Option 4: Bitwise-and
boolean isEven = ((a & 1) == 0);

Qui ho usato l'operatore bit per bit e l'ho rappresentato nella forma sintetica mostrata nell'opzione 2. La riscrittura nella forma dell'opzione 1 (e in alternativa dell'opzione 3) è lasciata come esercizio al lettore. ;)

Spero che aiuti.

Per far funzionare l'operazione% (REM) di Java come MOD per valori X e Y positivi Y, è possibile utilizzare questo metodo:

private int mod(int x, int y)
{
    int result = x % y;
    if (result < 0)
    {
        result += y;
    }
    return result;
}

o con l'operatore ternario (più breve, ma non possibile o meno efficiente in alcune situazioni):

private int mod(int x, int y)
{
    int result = x % y;
    return result < 0? result + y : result;
}

Java in realtà non ha un operatore modulo come fa C. % in Java è un operatore rimanente. Sugli interi positivi, funziona esattamente come il modulo, ma funziona in modo diverso sugli interi negativi e, a differenza del modulo, può funzionare anche con numeri in virgola mobile. Tuttavia, è raro usare% su tutto tranne che sugli interi positivi, quindi se vuoi chiamarlo un modulo, sentiti libero!

Mentre è possibile fare un modulo corretto controllando se il valore è negativo e correggerlo se lo è (come molti hanno suggerito), esiste una soluzione più compatta.

(a % b + b) % b

Questo farà prima il modulo, limitando il valore all'intervallo -b -> + b, quindi aggiungendo b per garantire che il valore sia positivo, lasciando che il modulo successivo lo limiti all'intervallo 0 -> b.

Nota: se b è negativo, anche il risultato sarà negativo

Il codice funziona molto più velocemente senza usare modulo:

public boolean isEven(int a){
    return ( (a & 1) == 0 );
}

public boolean isOdd(int a){
    return ( (a & 1) == 1 );
}

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

dovresti esaminare le specifiche prima di usare l'operatore 'remainder'%:

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

In Java è l' %operatore: 15.17.3. Operatore residuo%

Nota che c'è anche floorModnella java.lang.Mathclasse che darà un risultato diverso da %per argomenti con segni diversi:

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

Inoltre, la mod può essere utilizzata in questo modo:

int a = 7;
b = a % 2;

bequivarrebbe a 1. Perché 7 % 2 = 1.

L'operatore residuo in Java è %e l'operatore modulo può essere espresso come

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

Come altri hanno sottolineato, l' %operatore (resto) non è lo stesso moddell'operazione / funzione del modulo matematico .

mod vs %

La x mod nfunzione di mappe xper nla gamma di [0,n).
Considerando che l' x % noperatore di mappe xper nla gamma di (-n,n).

Per avere un metodo per usare l'operazione del modulo matematico e non preoccuparsi del segno davanti a xuno, puoi usare:

((x % n) + n) % n

Forse questa foto aiuta a capirla meglio (ho avuto difficoltà a avvolgere la mia testa per prima)

Un altro modo è:

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

Ma il modo più semplice è ancora:

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

Come ha detto @Steve Kuo.

In Java, l' operazione mod può essere eseguita come tale:

Math.floorMod(a, b)

Nota: l' operazione mod è diversa dall'operazione rimanente . In Java, l' operazione rimanente può essere eseguita come tale:

a % b

L'operatore modulo è% (segno di percentuale). Per verificare l'uniformità o in generale fare modulo per una potenza di 2, puoi anche usare & (l'operatore e) come isEven =! (A & 1).

Un'alternativa al codice di @Cody:

Utilizzando l'operatore modulo:

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

Penso che questo sia un codice leggermente migliore rispetto alla scrittura if / else, perché c'è meno duplicazione e flessibilità inutilizzata. Richiede un po 'più di potenza cerebrale da esaminare, ma la buona denominazione di isEvencompensa.