¿Cuál es la sintaxis para mod en java?

Como ejemplo en pseudocódigo:

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

En lugar del operador de módulo, que tiene una semántica ligeramente diferente, para enteros no negativos, puede usar el operador restante% . Para su ejemplo exacto:

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

Esto se puede simplificar a una línea:

isEven = (a % 2) == 0;

Aquí está la representación de su pseudocódigo en código Java mínimo;

boolean isEven = a % 2 == 0;

Ahora lo dividiré en sus componentes. El operador de módulo en Java es el carácter de porcentaje (%). Por lo tanto, tomar un int% int devuelve otro int. El operador de doble igual (==) se utiliza para comparar valores, como un par de entradas y devuelve un valor booleano. Esto se asigna a la variable booleana 'isEven'. Según la precedencia del operador, el módulo se evaluará antes de la comparación.

Como todos los demás ya dieron la respuesta, agregaré un poco de contexto adicional. % el operador "módulo" está realmente realizando la operación restante. La diferencia entre mod y rem es sutil, pero importante.

(-1 mod 2) normalmente daría 1. Más específicamente, dados dos enteros, X e Y, la operación (X mod Y) tiende a devolver un valor en el rango [0, Y). Dicho de otra manera, el módulo de X e Y siempre es mayor o igual que cero, y menor que Y.

Realizar la misma operación con el operador "%" o rem mantiene el signo del valor X. Si X es negativo, obtiene un resultado en el rango (-Y, 0]. Si X es positivo, obtiene un resultado en el rango [0, Y).

A menudo, esta sutil distinción no importa. Sin embargo, volviendo a su pregunta de código, hay varias formas de resolver la "uniformidad".

El primer enfoque es bueno para los principiantes, porque es especialmente detallado.

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

El segundo enfoque aprovecha mejor el lenguaje y conduce a un código más sucinto. (No olvide que el operador == devuelve un valor booleano).

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

El tercer enfoque es aquí para completar, y utiliza el operador ternario . Aunque el operador ternario suele ser muy útil, en este caso considero que el segundo enfoque es superior.

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

El cuarto y último enfoque es utilizar el conocimiento de la representación binaria de enteros . Si el bit menos significativo es 0, entonces el número es par. Esto puede verificarse utilizando el operador bit a bit (&). Si bien este enfoque es el más rápido (está haciendo un simple enmascaramiento de bits en lugar de una división), tal vez sea un poco avanzado / complicado para un principiante.

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

Aquí utilicé el operador bit a bit y lo representé en la forma sucinta que se muestra en la opción 2. Reescribirlo en la forma de la Opción 1 (y, alternativamente, la Opción 3) se deja como ejercicio para el lector. ;)

Espero que ayude.

Para que la operación% (REM) de Java funcione como MOD para valores negativos X e Y positivos, puede usar este método:

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

o con el operador ternario (más corto, pero no posible o menos eficiente en algunas situaciones):

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

Java en realidad no tiene un operador de módulo como C. % en Java es un operador restante. En enteros positivos, funciona exactamente como un módulo, pero funciona de manera diferente en enteros negativos y, a diferencia del módulo, también puede funcionar con números de coma flotante. Aún así, es raro usar% en cualquier cosa que no sean enteros positivos, así que si quieres llamarlo módulo, ¡no dudes en hacerlo!

Si bien es posible hacer un módulo adecuado comprobando si el valor es negativo y corregirlo si lo es (como muchos han sugerido), existe una solución más compacta.

(a % b + b) % b

Esto primero hará el módulo, limitando el valor al rango -b -> + b y luego agregará b para asegurar que el valor sea positivo, permitiendo que el siguiente módulo lo limite al rango 0 -> b.

Nota: Si b es negativo, el resultado también será negativo.

El código se ejecuta mucho más rápido sin usar módulo:

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

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

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

debe examinar la especificación antes de usar el operador 'resto'%:

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

En Java es el %operador: 15.17.3. Operador restante%

Tenga en cuenta que también hay floorModen la java.lang.Mathclase que dará un resultado diferente de los %argumentos con diferentes signos:

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

Además, mod se puede usar así:

int a = 7;
b = a % 2;

bsería igual a 1. Porque 7 % 2 = 1.

El operador restante en Java es %y el operador de módulo se puede expresar como

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

Como otros han señalado, el %operador (resto) no es lo mismo que la modoperación / función del módulo matemático .

mod vs %

La x mod nfunción se asigna xa nen el rango de [0,n).
Mientras que el x % noperador se asigna xa nen el rango de (-n,n).

Para tener un método para usar la operación de módulo matemático y no preocuparnos por el signo que está delante de xuno, puede usar:

((x % n) + n) % n

Tal vez esta imagen ayude a entenderla mejor (tuve dificultades para entender esto primero)

Otra forma es:

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

Pero la forma más fácil sigue siendo:

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

Como dijo @Steve Kuo.

En Java, la operación mod se puede realizar como tal:

Math.floorMod(a, b)

Nota: La operación de modificación es diferente de la operación restante . En Java, el resto de la operación se puede realizar como tal:

a % b

El operador del módulo es% (signo de porcentaje). Para probar la uniformidad o generalmente hacer un módulo para una potencia de 2, también puede usar & (el operador y) como isEven =! (A & 1).

Una alternativa al código de @Cody:

Usando el operador de módulo:

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

Creo que este es un código marginalmente mejor que escribir if / else, porque hay menos duplicación y flexibilidad no utilizada. Requiere un poco más de poder mental para examinar, pero el buen nombre de isEvencompensa.