Wat is de syntaxis voor mod in java

Als voorbeeld in pseudocode:

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

Antwoord 1, autoriteit 100%

In plaats van de modulo-operator, die een iets andere semantiek heeft, kunt u voor niet-negatieve gehele getallen de remainder-operator %gebruiken. Voor uw exacte voorbeeld:

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

Dit kan worden vereenvoudigd tot een one-liner:

isEven = (a % 2) == 0;

Antwoord 2, autoriteit 30%

Hier is de weergave van uw pseudo-code in minimale Java-code;

boolean isEven = a % 2 == 0;

Ik zal het nu opsplitsen in zijn componenten. De modulus-operator in Java is het procentteken (%). Daarom geeft het nemen van een int % int een andere int terug. De operator double is gelijk aan (==) wordt gebruikt om waarden te vergelijken, zoals een paar ints en retourneert een boolean. Deze wordt dan toegewezen aan de booleaanse variabele ‘isEven’. Op basis van operatorprioriteit wordt de modulus geëvalueerd vóór de vergelijking.

Antwoord 3, autoriteit 26%

Omdat iedereen het antwoord al heeft gegeven, zal ik wat extra context toevoegen. % de “modulus”-operator voert feitelijk de restbewerking uit. Het verschil tussen mod en rem is subtiel, maar belangrijk.

(-1 mod 2) zou normaal gesproken 1 opleveren. Meer specifiek gegeven twee gehele getallen, X en Y, heeft de bewerking (X mod Y) de neiging om een waarde te retourneren in het bereik [0, Y). Anders gezegd, de modulus van X en Y is altijd groter dan of gelijk aan nul en kleiner dan Y.

Als u dezelfde bewerking uitvoert met de operator “%” of rem, blijft het teken van de X-waarde behouden. Als X negatief is, krijg je een resultaat in het bereik (-Y, 0]. Als X positief is, krijg je een resultaat in het bereik [0, Y).

Vaak doet dit subtiele onderscheid er niet toe. Terugkomend op uw codevraag, er zijn echter meerdere manieren om “gelijkmatigheid” op te lossen.

De eerste benadering is goed voor beginners, omdat deze vooral uitgebreid is.

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

De tweede benadering maakt beter gebruik van de taal en leidt tot beknoptere code. (Vergeet niet dat de operator == een boolean retourneert.)

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

De derde benadering is hier voor de volledigheid en gebruikt de ternaire -operator. Hoewel de ternaire operator vaak erg handig is, beschouw ik in dit geval de tweede benadering als superieur.

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

De vierde en laatste benadering is het gebruik van kennis van de binaire representatie van gehele getallen. Als het minst significante bit 0 is, is het getal even. Dit kan worden gecontroleerd met behulp van de bitwise-and-operator( &). Hoewel deze aanpak het snelst is (je doet eenvoudige bitmaskering in plaats van deling), is het misschien een beetje geavanceerd/gecompliceerd voor een beginner.

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

Hier heb ik de bitwise-and-operator gebruikt en deze weergegeven in de beknopte vorm die wordt weergegeven in optie 2. Het herschrijven in de vorm van optie 1 (en alternatief die van optie 3) wordt overgelaten als een oefening voor de lezer. 😉

Hopelijk helpt dat.

Antwoord 4, autoriteit 9%

Om Java’s % (REM) bewerking te laten werken als MOD voor negatieve X- en positieve Y-waarden, kunt u deze methode gebruiken:

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

of met de ternaire operator (korter, maar niet mogelijk of minder efficiënt in sommige situaties):

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

Antwoord 5, autoriteit 3%

Java heeft eigenlijk geen modulo-operator zoals C. % in Java is een restoperator. Op positieve gehele getallen werkt het precies zoals modulo, maar het werkt anders op negatieve gehele getallen en, in tegenstelling tot modulo, kan het ook werken met drijvende-kommagetallen. Toch is het zeldzaam om % te gebruiken op iets anders dan positieve gehele getallen, dus als je het een modulo wilt noemen, voel je dan vrij!

Antwoord 6, autoriteit 3%

Hoewel het mogelijk is om een goede modulo uit te voeren door te controleren of de waarde negatief is en deze te corrigeren als dat zo is (zoals velen hebben gesuggereerd), is er een compactere oplossing.

(a % b + b) % b

Hiermee wordt eerst de modulo uitgevoerd, waarbij de waarde wordt beperkt tot de -b -> +b bereik en voeg vervolgens b toe om ervoor te zorgen dat de waarde positief is, en laat de volgende modulo het beperken tot de 0 -> b bereik.

Opmerking: als b negatief is, is het resultaat ook negatief

Antwoord 7, autoriteit 3%

De code werkt veel sneller zonder modulo te gebruiken:

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

Antwoord 8, autoriteit 2%

Zoals anderen al hebben opgemerkt, is de operator %(rest) niet hetzelfde als de wiskundige
modmodulus werking/functie.

modversus %

De functie x mod nwijst xtoe aan nin het bereik van [0,n).
Terwijl de operator x % nxtoewijst aan nin het bereik van (-n,n).

Om een methode te hebben om de wiskundige modulusbewerking te gebruiken en niet
Zorg voor het bord voor xéén kan gebruiken:

((x % n) + n) % n

Misschien helpt deze foto het beter te begrijpen (ik had het moeilijk om mijn hoofd rond deze eerste te wikkelen)

Antwoord 9

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

Antwoord 10

In Java is het de %operator:
15.17.3. Rest-operator%

Merk op dat er ook floorModin de java.lang.Mathklasse die een ander resultaat zal geven van %voor argumenten met verschillende tekens:

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

Antwoord 11

U moet de specificatie onderzoeken voordat u ‘resterende’ operator% gebruikt:

http: //java.sun. com / docs / boeken / 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);

Antwoord 12

Mod kan ook als volgt worden gebruikt:

int a = 7;
b = a % 2;

bzou gelijk zijn aan 1. Omdat 7 % 2 = 1.

Antwoord 13

De rest-operator in Java is %en de modulo-operator kan worden uitgedrukt 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;
}

Antwoord 14

Een andere manier is:

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

Maar de gemakkelijkste manier is nog steeds:

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

Zoals @Steve Kuo zei.

Antwoord 15

In Javakan de bewerking modals volgt worden uitgevoerd:

Math.floorMod(a, b)

Opmerking:
De bewerking modverschilt van de bewerking rest. In Javakan de bewerking restals volgt worden uitgevoerd:

a % b

Antwoord 16

De modulo-operator is % (procentteken). Om te testen op gelijkmatigheid of in het algemeen modulo te doen voor een macht van 2, kunt u ook & (de operator en) zoals isEven = !( a & 1 ).

Antwoord 17

Een alternatief voor de code van @Cody:

De modulus-operator gebruiken:

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

Ik denk dat dit iets betere code is dan het schrijven van if/else, omdat er minder duplicatie is & onbenutte flexibiliteit. Het vereist wat meer hersenkracht om te onderzoeken, maar de goede naamgeving van isEvencompenseert dit.