Los arreglos son colecciones de elementos del mismo tipo que funcionan como contenedores. En Java, se asignan índices automáticamente a partir de 0 para facilitar el acceso a los elementos. Una declaración básica se muestra a continuación:

int[] numeros = new int[5];

Inicialización Estática y Excepciones Comunes

La inicialización estática permite definir valores directamente. Un ejemplo simplificado es:

int[] valores = {10, 20, 30, 40, 50};

Dos excepciones frecuentes al manejar arreglos son:

• ArrayIndexOutOfBoundsException: ocurre al acceder a un índice fuera de los límites del arreglo.
• NullPointerException: se produce cuando se intenta operar sobre una referencia nula.

Recorrido de Arreglos

Para recorrer un arreglo y procesar sus elementos, se utiliza la propiedad length para obtener el número total de elementos. A continuación, un ejemplo que imprime los elementos separados por comas:

public static void imprimirElementos(int[] datos) {
    for (int i = 0; i < datos.length; i++) {
        if (i < datos.length - 1) {
            System.out.print(datos[i] + ", ");
        } else {
            System.out.println(datos[i]);
        }
    }
}

Obtener el Máximo y Mínimo en un Arreglo

Para hallar el valor máximo en un arreglo, se compara cada elemento con un valor temporal. La lógica similar aplica para el mínimo. Este código devuelve el máximo:

public static int buscarMaximo(int[] elementos) {
    int maximoActual = elementos[0];
    for (int i = 1; i < elementos.length; i++) {
        if (elementos[i] > maximoActual) {
            maximoActual = elementos[i];
        }
    }
    return maximoActual;
}

Algoritmos de Ordenamiento

Ordenamiento por Selección

Este algoritmo selecciona el elemento más grande (o más pequeño) y lo coloca en su posición correcta en cada iteración. Un ejemplo que ordena en orden descendente:

public static void ordenamientoSeleccion(int[] arreglo) {
    for (int i = 0; i < arreglo.length - 1; i++) {
        for (int j = i + 1; j < arreglo.length; j++) {
            if (arreglo[i] < arreglo[j]) {
                int temp = arreglo[i];
                arreglo[i] = arreglo[j];
                arreglo[j] = temp;
            }
        }
    }
}

Ordenamiento Burbuja

Compara elementos adyacentes y los intercambia si es necesario. El valer más grande "burbujea" hacia el final tras cada pasada. Una implementación básica:

public static void ordenamientoBurbuja(int[] arreglo) {
    for (int i = 0; i < arreglo.length - 1; i++) {
        for (int j = 0; j < arreglo.length - i - 1; j++) {
            if (arreglo[j] < arreglo[j + 1]) {
                int temp = arreglo[j];
                arreglo[j] = arreglo[j + 1];
                arreglo[j + 1] = temp;
            }
        }
    }
}

Para intercambiar posiciones de manera reutilizable, se puede extraer una función auxiliar:

public static void intercambiar(int[] arreglo, int posA, int posB) {
    int temp = arreglo[posA];
    arreglo[posA] = arreglo[posB];
    arreglo[posB] = temp;
}

En aplicaciones reales, se recomienda usar Arrays.sort(arreglo) de la biblioteca estándar de Java.

Búsqueda en Arreglos

Búsqueda Lineal

Recorre el arreglo secuencialmente para encontrar un valor. Si no se encuentra, devuelve -1:

public static int busquedaLineal(int[] datos, int clave) {
    for (int i = 0; i < datos.length; i++) {
        if (datos[i] == clave) {
            return i;
        }
    }
    return -1;
}

Búsqueda Binaria

Requiere que el arreglo esté ordenado. Divide repetidamente el espacio de búsqueda a la mitad. Ejemplo:

public static int busquedaBinaria(int[] arregloOrdenado, int clave) {
    int inferior = 0, superior = arregloOrdenado.length - 1, medio;
    while (inferior <= superior) {
        medio = (inferior + superior) / 2;
        if (clave > arregloOrdenado[medio]) {
            inferior = medio + 1;
        } else if (clave < arregloOrdenado[medio]) {
            superior = medio - 1;
        } else {
            return medio;
        }
    }
    return -1;
}

Para insertar un elemento manteniendo el orden, se puede adaptar la búsqueda binaria para hallar la posición adecuada:

public static int encontrarPosicionInsercion(int[] arregloOrdenado, int valor) {
    int inferior = 0, superior = arregloOrdenado.length - 1, medio;
    while (inferior <= superior) {
        medio = (inferior + superior) / 2;
        if (valor > arregloOrdenado[medio]) {
            inferior = medio + 1;
        } else if (valor < arregloOrdenado[medio]) {
            superior = medio - 1;
        } else {
            return medio;
        }
    }
    return inferior;
}

Conversiones de Bases Numéricas con Arreglos

Los arreglos pueden almacenar dígitos durante convertiones, como de decimal a binario:

public static void decimalABinario(int numero) {
    StringBuilder resultado = new StringBuilder();
    while (numero > 0) {
        resultado.append(numero % 2);
        numero = numero / 2;
    }
    System.out.println(resultado.reverse().toString());
}

Para decimal a hexadecimal:

public static void decimalAHexadecimal(int numero) {
    StringBuilder hexadecimal = new StringBuilder();
    for (int i = 0; i < 8; i++) {
        int residuo = numero & 15;
        if (residuo > 9) {
            hexadecimal.append((char)(residuo - 10 + 'A'));
        } else {
            hexadecimal.append(residuo);
        }
        numero = numero >>> 4;
    }
    System.out.println(hexadecimal.reverse().toString());
}

Arreglos Bidimensionales

Un arreglo bidimensional es una tabla o matriz. Puede declararse de formas variadas:

int[][] matriz = new int[3][4]; // 3 filas, 4 columnas
int[][] datos = {{1,2,3}, {4,5,6}}; // inicialización directa

Para recorrer y sumar todos los elementos de una matriz:

public static int sumarMatriz(int[][] tabla) {
    int sumaTotal = 0;
    for (int fila = 0; fila < tabla.length; fila++) {
        for (int columna = 0; columna < tabla[fila].length; columna++) {
            sumaTotal += tabla[fila][columna];
        }
    }
    return sumaTotal;
}

Notas sobre sintaxis: las declaraciones como int[] x, y[]; equivalen a definir x como un arreglo unidimensional e y como un arreglo bidimensional.