Was ist die Syntax für Mod in Java

Als Beispiel im Pseudocode:

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

Anstelle des Modulo - Operator, der etwas andere Semantik hat, für nicht-negative ganze Zahlen sind , können Sie die Verwendung Rest Operator %. Für Ihr genaues Beispiel:

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

Dies kann zu einem Einzeiler vereinfacht werden:

isEven = (a % 2) == 0;

Hier ist die Darstellung Ihres Pseudocodes in minimalem Java-Code.

boolean isEven = a % 2 == 0;

Ich werde es jetzt in seine Komponenten zerlegen. Der Moduloperator in Java ist das Prozentzeichen (%). Daher gibt ein int% int ein anderes int zurück. Der Operator double equals (==) wird zum Vergleichen von Werten verwendet, z. B. eines Int-Paares, und gibt einen Booleschen Wert zurück. Dies wird dann der booleschen Variablen 'isEven' zugewiesen. Basierend auf der Priorität des Operators wird der Modul vor dem Vergleich bewertet.

Da alle anderen bereits die Antwort gegeben haben, werde ich einen zusätzlichen Kontext hinzufügen. % Der Operator "Modul" führt tatsächlich die Restoperation aus. Der Unterschied zwischen Mod und Rem ist subtil, aber wichtig.

(-1 mod 2) würde normalerweise 1 ergeben. Insbesondere bei zwei ganzen Zahlen, X und Y, gibt die Operation (X mod Y) tendenziell einen Wert im Bereich [0, Y] zurück. Anders gesagt, der Modul von X und Y ist immer größer oder gleich Null und kleiner als Y.

Wenn Sie dieselbe Operation mit dem Operator "%" oder rem ausführen, wird das Vorzeichen des X-Werts beibehalten. Wenn X negativ ist, erhalten Sie ein Ergebnis im Bereich (-Y, 0]. Wenn X positiv ist, erhalten Sie ein Ergebnis im Bereich [0, Y).

Oft spielt diese subtile Unterscheidung keine Rolle. Zurück zu Ihrer Code-Frage: Es gibt jedoch mehrere Möglichkeiten, nach "Gleichmäßigkeit" zu suchen.

Der erste Ansatz ist gut für Anfänger, weil er besonders ausführlich ist.

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

Der zweite Ansatz nutzt die Sprache besser aus und führt zu einem prägnanteren Code. (Vergessen Sie nicht, dass der Operator == einen Booleschen Wert zurückgibt.)

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

Der dritte Ansatz dient der Vollständigkeit und verwendet den ternären Operator. Obwohl der ternäre Operator oft sehr nützlich ist, halte ich in diesem Fall den zweiten Ansatz für überlegen.

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

Der vierte und letzte Ansatz besteht darin, das Wissen über die binäre Darstellung von ganzen Zahlen zu nutzen . Wenn das niedrigstwertige Bit 0 ist, ist die Zahl gerade. Dies kann mit dem bitweisen Operator (&) überprüft werden . Während dieser Ansatz der schnellste ist (Sie führen eine einfache Bitmaskierung anstelle einer Division durch), ist er für Anfänger möglicherweise etwas fortgeschritten / kompliziert.

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

Hier habe ich den bitweisen Operator und verwendet und ihn in der in Option 2 gezeigten prägnanten Form dargestellt. Das Umschreiben in Form von Option 1 (und alternativ in Option 3) bleibt dem Leser als Übung überlassen. ;)

Hoffentlich hilft das.

Mit dieser Methode können Sie die% (REM) -Operation von Java wie MOD für negative X- und positive Y-Werte verwenden:

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

oder mit dem ternären Operator (kürzer, aber in einigen Situationen nicht möglich oder weniger effizient):

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

Java hat eigentlich keinen Modulo-Operator wie C. % in Java ist ein Restoperator. Bei positiven Ganzzahlen funktioniert es genau wie Modulo, bei negativen Ganzzahlen jedoch anders und im Gegensatz zu Modulo auch bei Gleitkommazahlen. Trotzdem ist es selten,% für etwas anderes als positive ganze Zahlen zu verwenden. Wenn Sie es also als Modulo bezeichnen möchten, fühlen Sie sich frei!

Während es möglich ist, ein korrektes Modulo zu erstellen, indem überprüft wird, ob der Wert negativ ist, und wenn dies der Fall ist (wie von vielen vorgeschlagen), gibt es eine kompaktere Lösung.

(a % b + b) % b

Dies führt zuerst das Modulo aus, begrenzt den Wert auf den Bereich -b -> + b und addiert dann b, um sicherzustellen, dass der Wert positiv ist, und lässt das nächste Modulo ihn auf den Bereich 0 -> b begrenzen.

Hinweis: Wenn b negativ ist, ist das Ergebnis ebenfalls negativ

Der Code läuft viel schneller ohne Modulo:

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

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

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

Sie sollten die Spezifikation überprüfen, bevor Sie den Restoperator% verwenden:

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 ist es der %Operator: 15.17.3. Restbetreiber%

Beachten Sie, dass es auch floorModin der java.lang.MathKlasse gibt, die ein anderes Ergebnis als %für Argumente mit unterschiedlichen Vorzeichen liefert:

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

Mod kann auch so verwendet werden:

int a = 7;
b = a % 2;

bwürde gleich 1 sein. Weil 7 % 2 = 1.

Der Restoperator in Java ist %und der Modulo-Operator kann ausgedrückt werden als

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

Wie andere betont haben, ist der %(Rest-) Operator nicht derselbe wie die modOperation / Funktion des mathematischen Moduls.

mod vs. %

Die x mod nFunktion bildet xauf nim Bereich von [0,n).
Während der x % nBetreiber Karten xzu nim Bereich von (-n,n).

Um eine Methode zu haben, um die mathematische Moduloperation zu verwenden und sich nicht um das Vorzeichen vor xeinem zu kümmern, kann man verwenden:

((x % n) + n) % n

Vielleicht hilft dieses Bild, es besser zu verstehen (es fiel mir schwer, mich zuerst darum zu kümmern)

Ein anderer Weg ist:

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

Aber der einfachste Weg ist immer noch:

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

Wie @Steve Kuo sagte.

In Javakann die Mod- Operation als solche ausgeführt werden:

Math.floorMod(a, b)

Hinweis: Die Mod- Operation unterscheidet sich von der Restoperation . In Javadem Rest kann den Betrieb als solche durchgeführt werden:

a % b

Der Modulo-Operator ist% (Prozentzeichen). Um die Gleichmäßigkeit zu testen oder im Allgemeinen Modulo für eine Potenz von 2 auszuführen, können Sie auch & (den Operator und) wie isEven =! (A & 1) verwenden.

Eine Alternative zum Code von @Cody:

Verwenden des Moduloperators:

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

Ich denke, dies ist ein geringfügig besserer Code als das Schreiben von if / else, da weniger Duplizierung und ungenutzte Flexibilität vorhanden sind. Es erfordert etwas mehr Gehirnleistung, um zu untersuchen, aber die gute Benennung von isEvenkompensiert.