Arrays en Java

// Declaración e inicialización de arrays
int[] numeros = new int[5];          // array de 5 enteros, inicializados a 0
String[] nombres = new String[3];    // array de 3 referencias, inicializadas a null

// Inicialización con valores
int[] primos = {2, 3, 5, 7, 11};    // array literal
int[] pares  = new int[]{2, 4, 6};  // equivalente explícito

// Arrays multidimensionales (arrays de arrays)
int[][] matriz = new int[3][4];      // 3 filas, 4 columnas
int[][] irregular = {{1,2}, {3,4,5}, {6}}; // filas de distinto tamaño

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

// Acceso por índice (base 0)
int primero = datos[0];  // 10
int ultimo  = datos[datos.length - 1]; // 50

// datos.length: longitud (no método, es un campo)
for (int i = 0; i < datos.length; i++) {
    System.out.println(datos[i]);
}

// ArrayIndexOutOfBoundsException si se accede fuera de rango
datos[5]; // Error: índice válido es 0..4

// Copiar arrays
int[] copia = Arrays.copyOf(datos, datos.length);
int[] subcopia = Arrays.copyOfRange(datos, 1, 4); // {20, 30, 40}

// Ordenar
Arrays.sort(datos);

// Buscar en array ordenado
int pos = Arrays.binarySearch(datos, 30); // índice del elemento

// Arrays: limitaciones frente a las colecciones

// 1. Tamaño fijo: no se puede cambiar una vez creado
int[] arr = new int[3];
// arr.add(4); → no existe: usar ArrayList<Integer>

// 2. No implementan Iterable directamente para uso con generics
// 3. No tienen métodos de utilidad (add, remove, contains...)

// Convertir array a List (y viceversa)
String[] array = {"a", "b", "c"};
List<String> lista = Arrays.asList(array); // vista fija: no se puede añadir/eliminar
List<String> listaMutable = new ArrayList<>(Arrays.asList(array)); // mutable

// Arrays de primitivos NO pueden convertirse directamente a List<Integer>
// int[] no es lo mismo que Integer[] para los generics
int[] primitivos = {1, 2, 3};
Integer[] envolventes = {1, 2, 3}; // hay que usar el tipo wrapper
List<Integer> listaEntera = Arrays.asList(envolventes);

// Cuándo usar arrays en Java 8:

// SÍ: cuando el tamaño es fijo y el rendimiento importa
byte[] buffer = new byte[4096]; // buffer de E/S
int[] fibonacci = new int[n];   // tabla precalculada

// SÍ: la API lo requiere (varargs, bytes de red, criptografía...)
void escribir(byte[] datos) { ... }
MessageDigest.digest() // devuelve byte[]

// NO: para colecciones de tamaño variable → ArrayList
// NO: para búsquedas frecuentes → HashSet / HashMap
// NO: para colas o pilas → ArrayDeque / LinkedList