Descubre el poder del operador % en Java: ¿cómo debes usarlo?

Cuando iniciamos en el mundo de la programación, muchas veces nos topamos con errores que parecen de difícil solución, cuando lo único que en realidad necesitamos es tener algunos conocimientos básicos sobre ciertos temas. El operador % en Java, dentro de los operadores usados en programación, es uno de esos temas que sí o sí debes conocer. También llamado módulo o mod, este operador representa un símbolo que nos permite realizar operaciones aritméticas, relacionar elementos o hacer preguntas donde se involucra más de una condición.

Veamos, pues, todos los secretos sobre el operador % en Java y cómo podemos sacarle el mayor provecho para programar en Java.

Operadores en Java

Existen tres tipos de operadores en Java: los aritméticos, los relacionales y los lógicos. Pues bien, el operador & en Java pertenece al grupo de los operadores aritméticos y es usado para obtener el resto de una división. Veamos un ejemplo básico para entender de qué va todo esto:

int r = 7;
int s = 2;
int modulo = r % s;
System.out.println("El módulo de " + r + " dividido por " + s + " es: " + modulo);

En este caso, el resultado sería 1, ya que es el residuo de dividir 7 entre 2.

El operador % en Java

El operador % en Java puede ser usado en diferentes contextos. Algunos de ellos son:

Verificación de paridad

Este operador % en Java es usado muchas veces para verificar si un número es par o impar. La regla es: un número es par si el resultado de su módulo por 2 es 0 (mod * 2 = 0), o es impar si el resultado es 1 (mod * 2 = 1).

Vamos a nuestro ejemplo:

int numero = 7;
boolean esPar = (numero % 2) == 0; // esPar es false

En este caso, el número 7 es impar, por lo que el resultado de la operación (numero % 2) es 1.

Ciclos en listas o arreglos

El operador % en Java ambién es usado en el contexto de las listas circulares o arreglos, o si necesitamos pedir índices. Por ejemplo, si tenemos un arreglo de tamaño 5, podemos usar el mod para mantener el índice dentro de los límites permitidos. ¿Y cómo es eso? ¡Vamos a ello!:

int[] arreglo = {0, 1, 2, 3, 4};
int indice = 6;
int valorReal = arreglo[indice % arreglo.length]; // valorReal es 1

En este ejemplo, aunque el índice original es 6, la operación indice % arreglo.length devuelve 1, manteniendo el índice dentro del rango del arreglo.

Generación de patrones repetitivos

El operador % en Java tiene la capacidad de ayudarte a generar patrones repetitivos o programar eventos que ocurran en intervalos regulares dentro de un ciclo. Verbi gracia, si quieres alternar colores en una tabla cada tres filas, puedes usar el operador % en Java del siguiente modo:

int totalFilas = 9; // número total de filas en la tabla

for (int i = 0; i < totalFilas; i++) {
    int color = i % 3; // Usamos el operador % para alternar entre 0, 1 y 2
    
    switch(color) {
        case 0:
            System.out.println("Fila " + i + ": color1");
            break;
        case 1:
            System.out.println("Fila " + i + ": color2");
            break;
        case 2:
            System.out.println("Fila " + i + ": color3");
            break;
    }
}

Este operador se usa para alternar colores en filas de una tabla. Al dividir el índice de cada fila por 3 y tomar el residuo, se obtiene un patrón repetitivo de 0, 1 y 2. Esto permite asignar colores cíclicamente: color1, color2, color3, y repetir.

Aplicaciones en gráficos de Gantt

El operador % en Java también puede aplicarse en gráficos de Gantt

En gráficos de Gantt, podrías necesitar separar cursos en diferentes filas basándote en la fecha. Si sabes que habrá a lo mucho 3 cursos en la misma fecha, puedes separar los cursos en 3 filas usando el operador %:

int cursos = 10;
int filas = 3;

for (int i = 0; i < cursos; i++) {
    int fila = i % filas;
    System.out.println("Curso " + i + " está en la fila " + fila);
}

Desglosemos el código para entenderlo mejor:

1. Inicialización del total de cursos y filas:
   • int cursos=10; define el número total de cursos.
   • int filas=3; define el número de filas en el gráfico de Gantt.
2. Bucle for: for (int i=0; i<cursos; i++) { ... } recorre cada curso.
3. Uso del operador %: int fila=i % filas; calcula en qué fila debe ir el curso usando el operador de módulo %. Aquí, i % filas devuelve el residuo de dividir i entre 3, que siempre será uno de estos valores: 0, 1 o 2.
   • Cuando i es 0, 3, 6, 9, etc., fila será 0.
   • Cuando i es 1, 4, 7, etc., fila será 1.
   • Cuando i es 2, 5, 8, etc., fila será 2.

Al ejecutar el código, la salida esperada es:

Curso 0 está en la fila 0
Curso 1 está en la fila 1
Curso 2 está en la fila 2
Curso 3 está en la fila 0
Curso 4 está en la fila 1
Curso 5 está en la fila 2
Curso 6 está en la fila 0
Curso 7 está en la fila 1
Curso 8 está en la fila 2
Curso 9 está en la fila 0

En caso de que el divisor sea cero en una operación con mod, Java arrojará una ArithmeticException, esto debido a que la división por cero no está pre definida.

Como viste, el operador % en Java tiene infinidad de utilidades y puede usarse en muchos contextos. Este operador, claro está, es solo la punta del iceberg y existen muchísimos otros que debes conocer; esto puedes hacerlo a través de nuestro Bootcamp de programación en Java, que te brindará todas las bases teóricas y prácticas para ingresar en un mercado laboral que reconoce la valía de los programadores Java en el sector. ¡Únete a nosotros ahora e inicia tu camino en el mundo de la programación!