Arreglos en Java

tipo[] nombreArreglo;    // ✅ Sintaxis preferida en Java
tipo nombreArreglo[];    // Sintaxis estilo C (válida pero no recomendada)

int[] numeros;           // Arreglo de enteros
double[] temperaturas;   // Arreglo de doubles
char[] letras;           // Arreglo de caracteres
boolean[] banderas;      // Arreglo de booleanos
String[] nombres;        // Arreglo de Strings (referencias a objetos)

int[] numeros = new int[5];        // Arreglo de 5 enteros
double[] precios = new double[10]; // Arreglo de 10 doubles
char[] vocales = new char[5];      // Arreglo de 5 caracteres

int[] numeros = new int[3];
// numeros[0] = 0, numeros[1] = 0, numeros[2] = 0

boolean[] flags = new boolean[2];
// flags[0] = false, flags[1] = false

String[] palabras = new String[3];
// palabras[0] = null, palabras[1] = null, palabras[2] = null

int[] primos = {2, 3, 5, 7, 11};           // 5 elementos
double[] notas = {8.5, 9.0, 7.5, 10.0};    // 4 elementos
char[] vocales = {'a', 'e', 'i', 'o', 'u'}; // 5 elementos
String[] dias = {"Lunes", "Martes", "Miércoles"};

int[] primos = new int[5];
primos[0] = 2;
primos[1] = 3;
primos[2] = 5;
primos[3] = 7;
primos[4] = 11;

int[] numeros;
numeros = new int[5];              // OK: creación con tamaño

int[] datos;
datos = new int[]{1, 2, 3, 4, 5};  // OK: creación con valores
// Nota: new int[] es NECESARIO aquí, no podés usar solo {1, 2, 3, 4, 5}

// Útil cuando el arreglo depende de una condición:
int[] resultado;
if (modo == 1) {
    resultado = new int[]{1, 2, 3};
} else {
    resultado = new int[]{10, 20};
}

// Útil cuando el tamaño se conoce en tiempo de ejecución:
int[] dinamico;
int tamanio = obtenerTamanioDeUsuario();
dinamico = new int[tamanio];

int[] numeros = {10, 20, 30, 40, 50};
//              [0]  [1]  [2]  [3]  [4]  ← índices

// Lectura de elementos
int primero = numeros[0];   // 10
int tercero = numeros[2];   // 30
int ultimo = numeros[4];    // 50

// Escritura de elementos
numeros[1] = 25;            // Modifica: ahora es {10, 25, 30, 40, 50}

int[] datos = {1, 2, 3, 4, 5};
int tamanio = datos.length;        // 5

int ultimoIndice = datos.length - 1;  // 4 (índice del último elemento)
int ultimoElemento = datos[datos.length - 1];  // 5 (valor del último elemento)

int[] numeros = new int[5];  // Índices válidos: 0, 1, 2, 3, 4

numeros[5] = 10;   // ❌ ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
numeros[-1] = 10;  // ❌ ArrayIndexOutOfBoundsException: Index -1 out of bounds for length 5

int[] datos = {10, 20, 30};
int indice = 5;

// Forma segura: verificar antes de acceder
if (indice >= 0 && indice < datos.length) {
    System.out.println(datos[indice]);
} else {
    System.out.println("Índice fuera de rango: " + indice);
}

for (int i = 0; i < arreglo.length; i = i + 1) {
    // Usar arreglo[i]
}

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

// Recorrido para mostrar elementos
for (int i = 0; i < numeros.length; i = i + 1) {
    System.out.println("Elemento " + i + ": " + numeros[i]);
}
// Salida:
// Elemento 0: 10
// Elemento 1: 20
// Elemento 2: 30
// Elemento 3: 40
// Elemento 4: 50

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

// Recorrido para modificar elementos
for (int i = 0; i < numeros.length; i = i + 1) {
    numeros[i] = numeros[i] * 2;  // Duplica cada elemento
}
// numeros ahora es {20, 40, 60, 80, 100}

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

for (int numero : numeros) {
    System.out.println(numero);
}
// Salida: 10, 20, 30, 40, 50 (cada uno en su línea)

// Esto:
for (int numero : numeros) {
    System.out.println(numero);
}

// Es equivalente a esto:
for (int i = 0; i < numeros.length; i = i + 1) {
    int numero = numeros[i];  // Copia el valor en variable local
    System.out.println(numero);
}

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

// Recorrer solo del índice 2 al 4 (inclusive)
for (int i = 2; i <= 4; i = i + 1) {
    System.out.print(datos[i] + " ");  // Imprime: 30 40 50
}

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

for (int i = numeros.length - 1; i >= 0; i = i - 1) {
    System.out.print(numeros[i] + " ");  // Imprime: 50 40 30 20 10
}

int[] numeros = {10, 20, 30, 40, 50};
int i = 0;

while (i < numeros.length) {
    System.out.println(numeros[i]);
    i = i + 1;
}

int[] numeros = {10, 25, 30, 45, 50};
int buscado = 30;

boolean encontrado = false;
int posicion = -1;  // -1 indica "no encontrado"
int i = 0;

// Recorre mientras haya elementos Y no hayamos encontrado
while (i < numeros.length && !encontrado) {
    if (numeros[i] == buscado) {
        encontrado = true;
        posicion = i;
    }
    i = i + 1;
}

if (encontrado) {
    System.out.println("Encontrado en posición: " + posicion);
} else {
    System.out.println("No encontrado");
}

int[] original = {1, 2, 3};
int[] alias = original;    // alias apunta al MISMO arreglo, NO es una copia

alias[0] = 100;            // Modifica a través del alias

System.out.println(original[0]);  // Imprime: 100
System.out.println(alias[0]);     // Imprime: 100
// Ambos "ven" el mismo cambio porque apuntan al mismo arreglo

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};  // Mismo contenido, pero otro arreglo en memoria
int[] c = a;           // Alias: misma referencia que 'a'

System.out.println(a == b);  // false: diferentes referencias (diferentes arreglos)
System.out.println(a == c);  // true: misma referencia (mismo arreglo)

import java.util.Arrays;

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
int[] d = {1, 2, 4};

System.out.println(Arrays.equals(a, b));  // true: mismo contenido
System.out.println(Arrays.equals(a, d));  // false: contenido diferente

import java.util.Arrays;

int[] original = {1, 2, 3, 4, 5};

// Opción 1: Arrays.copyOf (recomendada)
// Copia todos los elementos a un nuevo arreglo
int[] copia1 = Arrays.copyOf(original, original.length);

// Opción 2: clone() (método heredado de Object)
int[] copia2 = original.clone();

// Opción 3: Copia manual con lazo
int[] copia3 = new int[original.length];
for (int i = 0; i < original.length; i = i + 1) {
    copia3[i] = original[i];
}

// Opción 4: System.arraycopy (más bajo nivel, más rápida para arreglos grandes)
int[] copia4 = new int[original.length];
System.arraycopy(original, 0, copia4, 0, original.length);

// Ahora las copias son independientes
copia1[0] = 100;
System.out.println(original[0]);  // 1 (no afectado)
System.out.println(copia1[0]);    // 100

int[] original = {1, 2, 3};

// Copia más grande: los nuevos espacios se llenan con 0
int[] masGrande = Arrays.copyOf(original, 5);  // {1, 2, 3, 0, 0}

// Copia más pequeña: se trunca
int[] masPequeno = Arrays.copyOf(original, 2);  // {1, 2}

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

// Copia desde índice 1 hasta índice 4 (sin incluir el 4)
int[] porcion = Arrays.copyOfRange(original, 1, 4);  // {20, 30, 40}

public static void duplicarElementos(int[] arr) {
    for (int i = 0; i < arr.length; i = i + 1) {
        arr[i] = arr[i] * 2;
    }
}

public static void main(String[] args) {
    int[] numeros = {1, 2, 3, 4, 5};
    
    System.out.println("Antes: " + Arrays.toString(numeros));  // [1, 2, 3, 4, 5]
    
    duplicarElementos(numeros);
    
    System.out.println("Después: " + Arrays.toString(numeros)); // [2, 4, 6, 8, 10]
    // ¡El arreglo original fue modificado!
}

public static int[] crearSecuencia(int inicio, int cantidad) {
    int[] resultado = new int[cantidad];  // Se crea en el heap
    for (int i = 0; i < cantidad; i = i + 1) {
        resultado[i] = inicio + i;
    }
    return resultado;  // Retorna la referencia al arreglo
}

public static void main(String[] args) {
    int[] secuencia = crearSecuencia(10, 5);
    // secuencia es {10, 11, 12, 13, 14}
    System.out.println(Arrays.toString(secuencia));
}

public static int[] duplicar(int[] original) {
    // Crear un NUEVO arreglo para el resultado
    int[] resultado = new int[original.length];
    
    // Copiar los valores duplicados al nuevo arreglo
    for (int i = 0; i < original.length; i = i + 1) {
        resultado[i] = original[i] * 2;
    }
    
    return resultado;  // Retorna el nuevo arreglo
}

public static void main(String[] args) {
    int[] numeros = {1, 2, 3};
    int[] duplicados = duplicar(numeros);
    
    System.out.println(Arrays.toString(numeros));     // [1, 2, 3] - sin cambios
    System.out.println(Arrays.toString(duplicados));  // [2, 4, 6] - nuevo arreglo
}

public static void intentarReemplazar(int[] arr) {
    arr = new int[]{100, 200, 300};  // Solo cambia la copia local
    // El arreglo original sigue intacto
}

public static void main(String[] args) {
    int[] datos = {1, 2, 3};
    intentarReemplazar(datos);
    System.out.println(Arrays.toString(datos));  // [1, 2, 3] - sin cambios
}

int[][] matriz = new int[3][4];  // 3 filas, 4 columnas

// Acceso: matriz[fila][columna]
matriz[0][0] = 1;   // Primera fila, primera columna
matriz[2][3] = 12;  // Tercera fila (índice 2), cuarta columna (índice 3)

// Dimensiones
int filas = matriz.length;        // 3 (cantidad de filas)
int columnas = matriz[0].length;  // 4 (cantidad de columnas en la fila 0)

int[][] matriz = {
    {1, 2, 3, 4},     // Fila 0: 4 columnas
    {5, 6, 7, 8},     // Fila 1: 4 columnas
    {9, 10, 11, 12}   // Fila 2: 4 columnas
};

// Acceso a elementos específicos
int valor = matriz[1][2];  // Fila 1, columna 2 → 7

int[][] matriz = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

int filas = matriz.length;         // 3 filas
int columnas = matriz[0].length;   // 3 columnas (asumiendo matriz rectangular)

// Recorrido fila por fila
for (int fila = 0; fila < filas; fila = fila + 1) {
    for (int col = 0; col < columnas; col = col + 1) {
        System.out.print(matriz[fila][col] + "\t");
    }
    System.out.println();  // Nueva línea después de cada fila
}
// Salida:
// 1    2    3
// 4    5    6
// 7    8    9

int[][] matriz = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

for (int[] fila : matriz) {           // Cada fila es un int[]
    for (int elemento : fila) {        // Cada elemento de la fila
        System.out.print(elemento + " ");
    }
    System.out.println();
}

// Crear solo el arreglo de filas (sin especificar columnas)
int[][] triangulo = new int[3][];

// Crear cada fila con tamaño diferente
triangulo[0] = new int[1];  // Primera fila: 1 elemento
triangulo[1] = new int[2];  // Segunda fila: 2 elementos
triangulo[2] = new int[3];  // Tercera fila: 3 elementos

// O con inicialización directa
int[][] pascal = {
    {1},
    {1, 1},
    {1, 2, 1},
    {1, 3, 3, 1}
};

public static int maximo(int[] arr) {
    // Precondición: el arreglo no debe estar vacío
    int max = arr[0];  // Asumir que el primero es el máximo
    
    for (int i = 1; i < arr.length; i = i + 1) {  // Empezar desde 1
        if (arr[i] > max) {
            max = arr[i];  // Encontramos uno mayor
        }
    }
    return max;
}

// Uso:
int[] datos = {3, 7, 2, 9, 1};
int mayor = maximo(datos);  // 9

public static int minimo(int[] arr) {
    int min = arr[0];
    for (int i = 1; i < arr.length; i = i + 1) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}

public static int sumar(int[] arr) {
    int suma = 0;  // Acumulador inicializado en el elemento neutro de la suma
    
    for (int i = 0; i < arr.length; i = i + 1) {
        suma = suma + arr[i];
    }
    return suma;
}

// También se puede usar for-each (más legible para este caso):
public static int sumarConForEach(int[] arr) {
    int suma = 0;
    for (int elemento : arr) {
        suma = suma + elemento;
    }
    return suma;
}

public static double promedio(int[] arr) {
    int suma = sumar(arr);
    // El cast a double evita división entera
    return (double) suma / arr.length;
}

// Uso:
int[] notas = {7, 8, 6, 9, 10};
double prom = promedio(notas);  // 8.0

public static int contarPares(int[] arr) {
    int contador = 0;
    for (int i = 0; i < arr.length; i = i + 1) {
        if (arr[i] % 2 == 0) {  // Condición: ser par
            contador = contador + 1;
        }
    }
    return contador;
}

// Más general: contar mayores a un umbral
public static int contarMayoresQue(int[] arr, int umbral) {
    int contador = 0;
    for (int i = 0; i < arr.length; i = i + 1) {
        if (arr[i] > umbral) {
            contador = contador + 1;
        }
    }
    return contador;
}

// ¿TODOS los elementos son positivos?
public static boolean todosSonPositivos(int[] arr) {
    boolean todosCumplen = true;
    int i = 0;
    
    while (i < arr.length && todosCumplen) {
        if (arr[i] <= 0) {
            todosCumplen = false;  // Encontramos uno que no cumple
        }
        i = i + 1;
    }
    return todosCumplen;
}

// ¿ALGÚN elemento es negativo?
public static boolean existeNegativo(int[] arr) {
    boolean encontrado = false;
    int i = 0;
    
    while (i < arr.length && !encontrado) {
        if (arr[i] < 0) {
            encontrado = true;
        }
        i = i + 1;
    }
    return encontrado;
}

public static void invertir(int[] arr) {
    int izq = 0;
    int der = arr.length - 1;
    
    while (izq < der) {
        // Intercambiar arr[izq] y arr[der]
        int temp = arr[izq];
        arr[izq] = arr[der];
        arr[der] = temp;
        
        izq = izq + 1;
        der = der - 1;
    }
}

// Ejemplo:
// Antes:  {1, 2, 3, 4, 5}
// Después: {5, 4, 3, 2, 1}

import java.util.Arrays;

int[] numeros = {5, 2, 8, 1, 9};

// ========== ORDENAMIENTO ==========
Arrays.sort(numeros);  
// numeros ahora es {1, 2, 5, 8, 9}
// Usa un algoritmo eficiente (Dual-Pivot Quicksort)

// ========== CONVERSIÓN A STRING ==========
String texto = Arrays.toString(numeros);
System.out.println(texto);  // Imprime: [1, 2, 5, 8, 9]
// Muy útil para debugging

// ========== LLENAR CON UN VALOR ==========
int[] ceros = new int[5];
Arrays.fill(ceros, 0);  // {0, 0, 0, 0, 0}

int[] unos = new int[3];
Arrays.fill(unos, 1);   // {1, 1, 1}

// ========== BÚSQUEDA BINARIA ==========
// IMPORTANTE: el arreglo DEBE estar ordenado
int[] ordenado = {1, 2, 5, 8, 9};
int pos = Arrays.binarySearch(ordenado, 5);  // Retorna 2 (índice de 5)
int noEncontrado = Arrays.binarySearch(ordenado, 7);  // Retorna negativo

// ========== COMPARACIÓN DE CONTENIDO ==========
int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
int[] c = {1, 2, 4};
boolean iguales1 = Arrays.equals(a, b);  // true
boolean iguales2 = Arrays.equals(a, c);  // false

// ========== COPIA ==========
int[] original = {1, 2, 3, 4, 5};
int[] copiaCompleta = Arrays.copyOf(original, original.length);  // {1, 2, 3, 4, 5}
int[] copiaParcial = Arrays.copyOf(original, 3);                 // {1, 2, 3}
int[] copiaExtendida = Arrays.copyOf(original, 7);               // {1, 2, 3, 4, 5, 0, 0}

// Copiar un rango específico
int[] rango = Arrays.copyOfRange(original, 1, 4);  // {2, 3, 4} (índices 1, 2, 3)