# Operador módulo em Java: funcionalidade e vantagens

Se uma divisão não for exata, fica um valor residual. Para calculá-lo corretamente no seu programa, Java dispõe do operador módulo. É muito mais fiável do que as soluções alternativas e é usado principalmente para determinar se os números são pares ou ímpares.

## O Módulo Operator em Java

Em todas as linguagens de programação, é possível realizar as quatro operações aritméticas básicas de adição, subtração, multiplicação e divisão e, por exemplo, utilizar os operadores Java para visualizar e resolver até mesmo problemas aritméticos extensos. No entanto, não é apenas no âmbito da programação que existe o risco de **não haver um resultado inteiro**. Quando divide dois números inteiros, existe sempre a possibilidade de sobrar um resto. Por exemplo, ao dividir 11 por 4, sobra um resto de 3 (*2 x 4 = 8, 11 - 8 = 3*). Isso pode causar problemas na programação.

Para isso, existe uma ferramenta em Java, o operador módulo, que determina e retorna o **valor residual após dividir dois números**. Existem várias situações em que o seu uso pode ser muito importante na programação. Por exemplo, pode determinar se um número é par ou ímpar ou se é um número primo. Embora existam outras formas de calcular esse resíduo, elas às vezes podem atingir rapidamente os seus limites, como ilustra o exemplo que apresentamos.

## Para que serve o operador módulo?

Em termos simples, a divisão consiste em verificar quantas vezes um divisor cabe num dividendo. O resultado é o quociente. Se tanto o dividendo quanto o divisor estiverem armazenados num [tipo de dados primitivo Java](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/primitivos-de-java/) int (ou Integer), também é possível calcular o resíduo sem problemas, sem usar o operador módulo Java. O código seria o seguinte:

```java
public class Main { 
public static void main(String[] args) { 
int dividend = 11; 
int divisor = 4; 
int resto = dividend - (divisor * (dividend / divisor)); 
System.out.println("El resto es: " + resto); 
} 
}
```

O comando Java `System.out.println` dá este resultado:

```java
El resto es: 3
```

Embora isso seja um pouco complicado, em princípio é possível. No entanto, torna-se problemático quando pelo menos um dos operandos é do tipo `float` ou `double`, ou seja, um tipo de dados de vírgula flutuante. Neste caso, obtemos um resultado diferente para o mesmo cálculo:

```java
public class Main { 
public static void main(String[] args) { 
int dividend = 11; 
double divisor = 4; 
double resto = dividend - (divisor * (dividend / divisor)); 
System.out.println("El resto es: " + resto); 
} 
}
```

```java
El resto es: 0,0
```

## Sintaxe e funcionalidade do operador módulo Java

Por outro lado, o operador módulo do Java sempre mostra o **resto exato**. Embora também realize a divisão, ele não mostra o resultado, mas apenas o resto que sobra. Ele começa com um sinal de porcentagem, portanto sua sintaxe terá esta estrutura:

```java
Dividend % Divisor
```

Para o nosso exemplo anterior, o operador módulo do Java funcionaria assim:

```java
public class Main { 
public static void main(String[] args) { 
int dividend = 11; 
double divisor = 4; 
double resto = dividend % divisor; 
System.out.println("El resto es: " + resto); 
} 
}
```

O resultado seria:

```java
El resto es: 3.0
```

## Determinar se os números são pares ou ímpares

O operador módulo do Java permite descobrir se um número é par ou ímpar. Para isso, utiliza-se uma lógica simples: se qualquer dividendo for dividido por 2 e o resto for 0, o número é par. Caso contrário, o número é ímpar. Essa suposição pode ser ilustrada com uma instrução **if-else**. Este seria o código para isso:

```java
public class Main { 
public static void main(String[] args) { 
int dividend = 11; 
if (dividend % 2 == 0) { 
System.out.println("El " + dividend + " es un número par."); 
} 
else { 
System.out.println("El " + dividend + " es un número impar."); 
} 
}
```

Como era de se esperar, obtivemos este resultado:

```java
11 es un número impar.
```

## Resto com números negativos

Em princípio, também é possível determinar o resto se o dividendo ou o divisor forem negativos. Este é um exemplo simples:

```java
public class Main { 
public static void main(String[] args) { 
int dividend = -11; 
int divisor = 4; 
int resto = dividend % divisor; 
System.out.println("El resto es: " + resto); 
} 
}
```

Como o dividendo é negativo, o resto também será negativo. O resultado é:

```java
El resto es: -3
```

No entanto, nem sempre é desejável obter um resultado negativo. Portanto, se o código for ligeiramente adaptado, é possível obter um **resto positivo**. Para isso, verifique primeiro se o resto é menor que 0. Se for, adicione o divisor para obter um resto positivo. O código seria o seguinte:

```java
public class Main { 
public static void main(String[] args) { 
int dividend = -11; 
int divisor = 4; 
int resto = dividend % divisor; 
System.out.println("El resto antes del cambio es: " + resto); 
while (dividend < 0) dividend += divisor; 
int resto_positivo = dividend % divisor; 
System.out.println("El resto después del cambio es: " + resto_positivo); 
} 
}
```

Obtemos este resultado:

```java
El resto antes del cambio es: -3 
El resto después del cambio es: 1
```


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/operador-modulo-em-java/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/operador-modulo-em-java/) for AI/LLM consumption.