# Operador Java modulo: Tutorial

Quando uma divisão não é exata, sobra um valor de resto. Justamente para calcular esse valor de forma precisa na sua aplicação, o operador Java modulo é disponíbilizado. Ele é consideravelmente mais confiável do que métodos alternativos, sendo usado principalmente para determinar se os números são pares ou ímpares.

## O que é o operador Java modulo

Em todas as [linguagens de programação](https://www.ionos.com/digitalguide/websites/web-development/web-programming-languages/ "Linguagens de programação web"), você pode realizar as quatro operações aritméticas básicas: adição, subtração, multiplicação e divisão, e, por exemplo, resolver problemas matemáticos extensos com os [operadores Java](https://www.ionos.com/digitalguide/websites/web-development/java-operators/ "Operadores em Java"). No entanto, na divisão, não apenas na programação, há o risco de não obter um **resultado exato**. Quando dois números inteiros são divididos, sempre existe a possibilidade de que um valor de resto permaneça. Por exemplo, ao dividir 11 por 4, o resto é 3 (*2 x 4 = 8, 11 - 8 = 3*). Isso pode causar problemas durante a programação.

Portanto, o operador Java modulo é uma ferramenta que determina e exibe o **valor restante após a divisão de dois números**. Este operador também é conhecido como operador de resto. Há várias situações em que seu uso na programação pode ser muito importante. Por exemplo, ele pode determinar se um número esperado é par ou ímpar ou se é um número primo. Embora existam outros métodos para determinar o valor restante, esses podem rapidamente encontrar suas limitações. O exemplo a seguir ilustra isso.

## Para que serve o operador de resto?

Na divisão, verifica-se de forma simplificada quantas vezes um divisor cabe em um dividendo. O resultado é o quociente. Se o dividendo e o divisor forem ambos no [tipo de dado primitivo Java](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-primitives/) `int` (ou `Integer`), você pode calcular o resto facilmente sem usar o operador Java modulo. O código correspondente poderia ser assim:

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

Por meio do [comando Java](https://www.ionos.com/digitalguide/websites/web-development/java-commands/ "Comandos Java") `System.out.println`, você obterá a saída do valor restante após o cálculo:

```java
O resto é: 3
```

Isso é um pouco complicado, mas fundamentalmente possível. No entanto, torna-se problemático assim que pelo menos um dos operandos for do tipo `float` ou `double`, ou seja, um tipo de dado de ponto flutuante. Nesse caso, obtemos um resultado diferente na mesma operação:

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

```java
O resto é: 0.0
```

## Sintaxe e funcionalidade do Java modulo

O operador Java modulo, por outro lado, sempre retorna o **resto exato** de uma divisão. Na verdade, ele também realiza a divisão, mas não exibe o resultado da divisão, apenas o resto, ou seja, a sobra final. Ele é iniciado com um símbolo de porcentagem, então sua sintaxe é bastante simples e se parece com isto:

```java
Dividendo % Divisor
```

Para o nosso exemplo acima, o operador Java modulo funcionaria da seguinte maneira:

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

A saída é:

```java
O resto é: 3.0
```

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

O Java modulo permite determinar se um número é par ou ímpar. Para isso, utiliza-se uma lógica simples: se um dividendo qualquer é dividido por 2 e o resto é 0, o número é par. Caso contrário, o número é ímpar. Com uma **instrução if-else**, essa lógica pode ser ilustrada. Aqui está o código correspondente:

```java
public class Main {
	public static void main(String[] args) {
	int dividendo = 11;
	if (dividendo % 2 == 0) {
	System.out.println(dividendo + " é um número par.");
	}
	else {
	System.out.println(dividendo + " é um número ímpar.");
	}
	}
}
```

Como era de se esperar, obtemos a seguinte saída:

```java
11 é um número ímpar.
```

## Resto com números negativos

Em princípio, você também pode determinar o resto quando o dividendo ou o divisor são negativos. Aqui está um exemplo simples disso:

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

Como o dividendo é negativo, o resto também será sempre negativo. Portanto, a saída será:

```java
O resto é: -3
```

No entanto, nem sempre é desejado obter um resultado negativo. Se você ajustar o código um pouco, pode obter um **resto positivo**. Para isso, verifique inicialmente se o resto é menor que 0. Se for o caso, adicione o divisor para obter um resto positivo. O código para isso é o seguinte:

```java
public class Main {
	public static void main(String[] args) {
	int dividendo = -11;
	int divisor = 4;
	int resto = dividendo % divisor;
	System.out.println("O valor do resto anterior é: " + resto);
	while (dividendo < 0) dividendo += divisor;
	int resto_positivo = dividendo % divisor;
	System.out.println("O valor do resto posterior é: " + resto_positivo);
	}
}
```

Agora obtemos esta saída:

```java
O valor do resto anterior é: -3
O valor do resto posterior é: 1
```


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