Qual é a sintaxe do mod em java

Como um exemplo no pseudocódigo:

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

Em vez do operador módulo, que tem semântica ligeiramente diferente, para números inteiros não negativos, você pode usar o operador restante% . Para seu exemplo exato:

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

Isso pode ser simplificado para uma linha:

isEven = (a % 2) == 0;

Aqui está a representação do seu pseudocódigo no código Java mínimo;

boolean isEven = a % 2 == 0;

Agora vou dividi-lo em seus componentes. O operador de módulo em Java é o caractere de porcentagem (%). Portanto, pegar um int% int retorna outro int. O operador double equals (==) é usado para comparar valores, como um par de ints e retorna um booleano. Isso é então atribuído à variável booleana 'isEven'. Com base na precedência do operador, o módulo será avaliado antes da comparação.

Como todo mundo já deu a resposta, adicionarei um pouco de contexto adicional. % o operador "módulo" está realmente executando a operação restante. A diferença entre mod e rem é sutil, mas importante.

(-1 mod 2) normalmente forneceria 1. Mais especificamente, dados dois números inteiros, X e Y, a operação (X mod Y) tende a retornar um valor no intervalo [0, Y). Dito de forma diferente, o módulo de X e Y é sempre maior ou igual a zero e menor que Y.

A execução da mesma operação com o operador "%" ou rem mantém o sinal do valor X. Se X for negativo, você obtém um resultado no intervalo (-Y, 0]. Se X é positivo, obtém um resultado no intervalo [0, Y).

Muitas vezes, essa distinção sutil não importa. Voltando à sua pergunta de código, no entanto, existem várias maneiras de resolver a "uniformidade".

A primeira abordagem é boa para iniciantes, porque é especialmente detalhada.

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

A segunda abordagem aproveita melhor o idioma e leva a um código mais sucinto. (Não esqueça que o operador == retorna um booleano.)

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

A terceira abordagem está aqui para garantir a integridade e usa o operador ternário . Embora o operador ternário seja frequentemente muito útil, neste caso, considero a segunda abordagem superior.

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

A quarta e última abordagem é usar o conhecimento da representação binária de números inteiros . Se o bit menos significativo for 0, o número será par. Isso pode ser verificado usando o operador bit a bit (&). Embora essa abordagem seja a mais rápida (você está usando máscaras de bits simples em vez de divisão), talvez seja um pouco avançada / complicada para um iniciante.

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

Aqui, usei o operador bit a bit e o representei da forma sucinta mostrada na opção 2. Reescrevendo-o na forma da opção 1 (e alternativamente na opção 3) é deixado como exercício para o leitor. ;)

Espero que ajude.

Para que a operação% (REM) do Java funcione como MOD para valores negativos de X e Y positivos, você pode usar este método:

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

ou com o operador ternário (mais curto, mas não possível ou menos eficiente em algumas situações):

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

Java, na verdade, não possui operador de módulo, como C. % em Java é um operador restante. Em números inteiros positivos, funciona exatamente como o módulo, mas funciona de maneira diferente em números inteiros negativos e, ao contrário do módulo, também pode funcionar com números de ponto flutuante. Ainda assim, é raro usar% em qualquer coisa, exceto números inteiros positivos; portanto, se você quiser chamá-lo de módulo, fique à vontade!

Embora seja possível fazer um módulo adequado, verificando se o valor é negativo e corrigindo-o se for (da maneira que muitos sugeriram), existe uma solução mais compacta.

(a % b + b) % b

Isso fará primeiro o módulo, limitando o valor ao intervalo -b -> + b e adicione b para garantir que o valor seja positivo, permitindo que o próximo módulo o limite ao intervalo 0 -> b.

Nota: Se b for negativo, o resultado também será negativo

O código roda muito mais rápido sem usar o 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 {
}

você deve examinar a especificação antes de usar o operador 'restante'%:

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

Em Java, é o %operador: 15.17.3. Operador restante%

Observe que também existe floorModna java.lang.Mathclasse que fornecerá um resultado diferente %para argumentos com sinais diferentes:

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

Além disso, o mod pode ser usado assim:

int a = 7;
b = a % 2;

bseria igual a 1. Porque 7 % 2 = 1.

O operador restante em Java é %e o operador módulo pode ser expresso 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 outros já apontaram, o %operador (restante) não é o mesmo que a modoperação / função do módulo matemático .

mod vs %

A x mod nfunção é mapeada xpara nno intervalo de [0,n).
Enquanto o x % noperador mapeia xpara nno intervalo de (-n,n).

Para ter um método para usar a operação do módulo matemático e não se importar com o sinal na frente de xum, pode-se usar:

((x % n) + n) % n

Talvez essa imagem ajude a entendê-la melhor (tive dificuldade em entender isso primeiro)

Outra maneira é:

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

Mas a maneira mais fácil ainda é:

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

Como o @Steve Kuo disse.

Em Java, a operação mod pode ser executada como tal:

Math.floorMod(a, b)

Nota: A operação mod é diferente da operação restante . Em Java, a operação restante pode ser executada como tal:

a % b

O operador do módulo é% (sinal de porcentagem). Para testar a uniformidade ou geralmente fazer o módulo com uma potência de 2, você também pode usar & (o operador e) como isEven =! (A & 1).

Uma alternativa ao código de @Cody:

Usando o operador de módulo:

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

Eu acho que este é um código marginalmente melhor do que escrever if / else, porque há menos duplicação e flexibilidade não utilizada. Requer um pouco mais de poder cerebral para examinar, mas a boa nomeação de isEvencompensa.