Wie lautet die Syntax für Mod in Java?

Als ein Beispiel in pseudocode:

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

InformationsquelleAutor der Frage Bob | 2008-09-18

java modulo

318

Für nicht-negative Ganzzahlen verwenden, können Sie die Rest Betreiber %. Für Ihre exakte Beispiel:
```
if ((a % 2) == 0)
{
    isEven = true;
}
else
{
    isEven = false;
}
```
Kann dies vereinfacht werden zu einem one-liner:
```
isEven = (a % 2) == 0;
```
InformationsquelleAutor der Antwort Cody Hatch
105

Hier ist die Darstellung der pseudo-code in minimalen Java-code;
```
boolean isEven = a % 2 == 0;
```
Werde ich jetzt brechen Sie unten in Ihre Bestandteile auf. Der modulo operator in Java ist das Prozent-Zeichen (%). Daher geht ein int % int gibt ein weiteres int. Das doppelte Gleichheitszeichen ( = = ) - operator wird verwendet, um Werte zu vergleichen, wie ein paar ints und gibt einen booleschen Wert zurück. Diese wird dann zugewiesen, um die boolean-variable 'isEven'. Basierend auf der Rangfolge der E-Modul ausgewertet werden, bevor der Vergleich.

InformationsquelleAutor der Antwort martinatime
83

Da alle anderen schon gab die Antwort, ich werde fügen Sie ein wenig zusätzlichen Kontext. % der "modulo" - operator ist eigentlich die Durchführung der Rest-Betrieb. Der Unterschied zwischen mod und rem ist subtil, aber wichtig.

(-1 mod 2) würde in der Regel geben 1. Genauer gesagt zwei zahlen, X und Y, die operation (X mod Y) neigt dazu, einen Wert zurückzugeben, in den Bereich [0, Y). Anders gesagt, der modulus von X und Y ist immer größer als oder gleich null und kleiner als Y.

Wenn Sie den gleichen Vorgang mit dem " % " - oder rem-operator behält das Vorzeichen der X-Wert. Wenn X negativ ist, erhalten Sie ein Ergebnis im Bereich von (-Y, 0]. Wenn X positiv ist, erhalten Sie ein Ergebnis in den Bereich [0, Y).

Oft diese subtile Unterscheidung keine Rolle. Gehen Sie zurück zu Ihrem code-Frage, obwohl, es gibt mehrere Möglichkeiten, eine Lösung für die "Ebenheit".

Der erste Ansatz ist gut für Anfänger, weil Sie besonders ausführlich.
```
//Option 1: Clearest way for beginners
boolean isEven;
if ((a % 2) == 0)
{
  isEven = true
}
else
{
  isEven = false
}
```
Der zweite Ansatz nimmt besser den Vorteil der Sprache und führt zu mehr prägnanten code. (Vergessen Sie nicht, dass der = = - operator gibt einen booleschen Wert zurück.)
```
//Option 2: Clear, succinct, code
boolean isEven = ((a % 2) == 0);
```
Der Dritte Ansatz ist hier für die Vollständigkeit und nutzt die ternäre Betreiber. Obwohl der ternäre operator ist oft sehr nützlich, in diesem Fall betrachte ich den zweiten Ansatz überlegen.
```
//Option 3: Ternary operator
boolean isEven = ((a % 2) == 0) ? true : false;
```
Die vierte und Letzte Ansatz ist die Verwendung von Kenntnis der binäre Darstellung von Ganzzahlen. Wenn das niederwertigste bit ist 0, dann ist die Zahl gerade ist. Dies kann überprüft werden mit der bitweise und-Verknüpfung operator (&). Dieser Ansatz ist der Schnellste (Sie sind dabei einfache bit-Maskierung statt der Teilung), ist es vielleicht ein wenig erweitert/kompliziert für einen Anfänger.
```
//Option 4: Bitwise-and
boolean isEven = ((a & 1) == 0);
```
Hier habe ich den bitweisen und-operator, und vertreten Sie in die prägnante form gezeigt, in option 2. Schreiben Sie es in der Option 1 hat die form (und wahlweise Option 3) ist Links als übung für den Leser. 😉

Hoffe, das hilft.

InformationsquelleAutor der Antwort Rob Rolnick

Java " % (REM) der Betrieb zu arbeiten, wie die MOD für negative X-und positive Y-Werte, Sie können diese Methode 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 nicht möglich oder weniger effizient in manchen Situationen):

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

InformationsquelleAutor der Antwort Zom-B

11

Java hat eigentlich keinen modulo-operator der Weg C hat. % in Java ist eine Rest-operator. Auf positive Ganzzahlen, es funktioniert genau wie modulo, aber es funktioniert anders auf den negativen ganzen zahlen und, im Gegensatz zu modulo, kann die Arbeit mit floating-point-zahlen als gut. Dennoch ist es selten, zur Verwendung % auf alles andere als positive ganze zahlen, so dass, wenn Sie wollen, nennen es eine modulo, dann fühlen Sie sich frei!

InformationsquelleAutor der Antwort Greg Charles

Code läuft viel schneller, ohne Verwendung von modulo:

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

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

InformationsquelleAutor der Antwort michael

11

Während es möglich ist, um eine ordnungsgemäße modulo indem Sie prüfen, ob der Wert negativ ist, und korrigieren Sie Sie, wenn es (wie viele vorgeschlagen haben), gibt es eine kompaktere Lösung.
```
(a % b + b) % b
```
Dieser wird zuerst die modulo-Begrenzung der Wert auf der -b -> +b-Bereich und fügen Sie dann b, um sicherzustellen, dass der Wert positiv ist, lassen die nächsten modulo-Begrenzung auf die 0 -> b-Sortiment.

Hinweis: Wenn b negativ ist, wird das Ergebnis auch negativ sein

InformationsquelleAutor der Antwort Stefan T
6
```
if (a % 2 == 0) {
} else {
}
```
InformationsquelleAutor der Antwort J D OConal

überprüfen Sie die Spezifikationen, bevor Sie mit der 'Rest' - operator % :

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

InformationsquelleAutor der Antwort kioto

Den Rest-operator in Java ist % und der modulo-operator ausgedrückt werden kann, 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;
}

InformationsquelleAutor der Antwort eljenso

2

Auch, die mod kann z.B. so verwendet werden:
```
int a = 7;
b = a % 2;
```
b würde gleich 1 ist. Da 7 % 2 = 1.

InformationsquelleAutor der Antwort jjnguy
1

Den modulo-operator % (Prozentzeichen). Um zu testen, für die Ebenheit oder allgemein zu tun modulo für eine Potenz von 2 ist, können Sie auch mit & (der und-operator) wie isEven = !( ein & 1 ).

InformationsquelleAutor der Antwort jjrv
1

Andere Möglichkeit ist:
```
boolean isEven = false;
if((a % 2) == 0)
{
    isEven = true;
}
```
Aber einfachste Weg ist immer noch:
```
boolean isEven = (a % 2) == 0;
```
Wie @Steve Kuo sagte.

InformationsquelleAutor der Antwort brothers28
0

In Java ist es die % Betreiber:
15.17.3. Rest-Operator %

Beachten Sie, dass es auch floorMod in der java.lang.Math Klasse, die ein anderes Ergebnis aus % für Argumente, die mit verschiedenen Zeichen:

public static int floorMod(int x, int y)

InformationsquelleAutor der Antwort Roland
-2

Alternative zu dem code aus @Cody:

Mithilfe der modulo-operator:
```
bool isEven = (a % 2) == 0;
```
Ich denke, dies ist geringfügig besser als das schreiben von code, if/else, denn es gibt weniger Doppelarbeit & unbenutzt Flexibilität. Es erfordert ein bisschen mehr Gehirn-power zu untersuchen, aber die gute Benennung der isEven kompensiert.

InformationsquelleAutor der Antwort Jay Bazuzi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.