Risposte:
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;
%
fosse valutato prima di ==
cercarlo, quindi non sarebbe chiaro se l'espressione sia equivalente a (a%2)==0
o a%(2==0)
. Immagino sia meno importante in Java dove un booleano non è uguale a un intero
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!
array[x mod array.length]
acceda sempre a un elemento nel mio array piuttosto che cercare di indicizzare posizioni negative.
(x % y + y) % y
o a partire da Java 8,Math.floorMod(x, y)
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 );
}
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 floorMod
nella java.lang.Math
classe che darà un risultato diverso da %
per argomenti con segni diversi:
%
a quando funziona correttamente anche quando l'argomento è negativo. Nessuna delle altre risposte è davvero corretta poiché presentano la dichiarazione di non responsabilità che% non è realmente modulo a meno che gli argomenti non siano positivi. In particolare, se si desidera mappare ogni numero intero su una posizione consecutiva in un array, allora array[floorMod(i, array.length)
funziona correttamente anche se l'indice i
va in territorio negativo. Non così con %
.
Inoltre, la mod può essere utilizzata in questo modo:
int a = 7;
b = a % 2;
b
equivarrebbe a 1. Perché 7 % 2 = 1
.
Come altri hanno sottolineato, l' %
operatore (resto) non è lo stesso mod
dell'operazione / funzione del modulo matematico
.
mod
vs%
La
x mod n
funzione di mappex
pern
la gamma di[0,n)
.
Considerando che l'x % n
operatore di mappex
pern
la gamma di(-n,n)
.
Per avere un metodo per usare l'operazione del modulo matematico e non preoccuparsi del segno davanti a x
uno, puoi usare:
((x % n) + n) % n
Forse questa foto aiuta a capirla meglio (ho avuto difficoltà a avvolgere la mia testa per prima)
int
variabile stessa. Il floorMod
metodo lo fa correttamente (ma potresti aver bisogno di calcoli aggiuntivi se n
è negativo).
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
Math.floorMod()
ha: 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).
Quindi non è esattamente lo stesso del modulo matematico. Ma c'è un modo per ottenere un risultato positivo, anche nel Javadoc dello stesso metodo: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
operazione funziona come previsto. C'è anche il floorMod
per i long
valori e altrimenti c'è BigInteger
per i valori più grandi.
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 isEven
compensa.