Eliminar Redundancias en el Acceso a Matrices

El acceso a matrices y estructuras de datos como listas o arreglos puede ser costoso en términos de rendimiento si se accede repetidamente a los mismos elementos en un bucle sin necesidad. Para optimizar el código, es importante almacenar los valores en variables temporales en lugar de acceder varias veces al mismo índice.

Ejemplo incorrecto: Acceso repetitivo a un índice en un bucle

Cuando accedemos múltiples veces a la misma posición de un arreglo dentro de un bucle, el rendimiento se ve afectado negativamente.

1public class AccesoMatriz {
2    void ejemploIncorrecto(int[] array) {
3        for (int i = 0; i < array.length; i++) {
4            array[i] = array[i] * 2 + array[i]; // Accede a array[i] tres veces innecesariamente
5            System.out.println(array[i]);
6        }
7    }
8}

Problema

Se accede al mismo índice de la matriz múltiples veces en la misma iteración.
Se pierde tiempo recalculando el mismo valor.
Se incrementa el costo de acceso a memoria.

Ejemplo optimizado: Uso de variable temporal para evitar accesos redundantes

Podemos optimizar el código almacenando el valor en una variable antes de realizar operaciones repetidas sobre él.

1public class AccesoMatriz {
2    void ejemploOptimizado(int[] array) {
3        for (int i = 0; i < array.length; i++) {
4            int valor = array[i];  // Se almacena en una variable temporal
5            array[i] = valor * 2 + valor;
6            System.out.println(array[i]);
7        }
8    }
9}

Beneficios de la optimización

Se evita el acceso repetido al mismo índice de la matriz.
El código es más eficiente y más fácil de leer.
Mejora el rendimiento, especialmente en estructuras de datos grandes.

Ejemplo incorrecto: Cálculo redundante dentro de un bucle

A continuación, un ejemplo en el que se accede varias veces a una matriz para realizar cálculos repetitivos.

1public class AccesoMatriz {
2    void ejemploIncorrecto(int[][] matriz) {
3        for (int i = 0; i < matriz.length; i++) {
4            for (int j = 0; j < matriz[0].length; j++) {
5                matriz[i][j] = matriz[i][j] * 2 + matriz[i][j]; // Se accede dos veces al mismo índice
6                System.out.println(matriz[i][j]);
7            }
8        }
9    }
10}

Ejemplo optimizado: Uso de variable temporal en bucles anidados

Optimizamos el acceso a la matriz almacenando el valor en una variable antes de modificarlo.

1public class AccesoMatriz {
2    void ejemploOptimizado(int[][] matriz) {
3        for (int i = 0; i < matriz.length; i++) {
4            for (int j = 0; j < matriz[0].length; j++) {
5                int valor = matriz[i][j];  // Se almacena en una variable temporal
6                matriz[i][j] = valor * 2 + valor;
7                System.out.println(matriz[i][j]);
8            }
9        }
10    }
11}

Beneficios

Se reduce el número de accesos a la matriz, lo que mejora el rendimiento.
Se evitan cálculos innecesarios.
Se mejora la claridad del código.

Optimización de código