Clases en Java de utilidad

// Dos formas de declarar (la segunda es preferida)
int vector1[];     // estilo C
int[] vector2;     // estilo Java (recomendado)

// Crear con tamaño fijo (30 elementos, inicializados a 0)
int[] numeros = new int[30];

// Crear e inicializar con valores entre llaves
int[] notas = {8, 9, 7, 10, 6, 8};

// Es equivalente a:
int[] notas2 = new int[6];
notas2[0] = 8;
notas2[1] = 9;
notas2[2] = 7;
notas2[3] = 10;
notas2[4] = 6;
notas2[5] = 8;

int[] notas = {8, 9, 7, 10, 6, 8};

// Acceder por índice (0 a length-1)
System.out.println("Primera nota: " + notas[0]);   // 8
System.out.println("Última nota: " + notas[notas.length - 1]); // 8

// Recorrido con for clásico
System.out.println("Notas con for:");
for (int i = 0; i < notas.length; i++) {
    System.out.println("  Nota " + i + ": " + notas[i]);
}

// Recorrido con for-each (más limpio)
System.out.println("Notas con for-each:");
for (int nota : notas) {
    System.out.println("  → " + nota);
}

public class Imprime {
    public static void main(String[] args) {
        for (String arg : args) {
            System.out.print(arg + " ");
        }
    }
}
// Ejecución: java Imprime hola que tal estas
// Salida:    hola que tal estas

import java.util.Arrays;

public class DemoArrays {
    public static void main(String[] args) {
        int[] numeros = {42, 15, 8, 99, 23, 67, 4};

        // toString: representación legible
        System.out.println("Original: " + Arrays.toString(numeros));
        // [42, 15, 8, 99, 23, 67, 4]

        // sort: ordenar
        Arrays.sort(numeros);
        System.out.println("Ordenado: " + Arrays.toString(numeros));
        // [4, 8, 15, 23, 42, 67, 99]

        // binarySearch: buscar (requiere array ordenado)
        int pos = Arrays.binarySearch(numeros, 23);
        System.out.println("23 está en posición: " + pos);  // 3

        // copyOf: copiar
        int[] copia = Arrays.copyOf(numeros, 4);
        System.out.println("Copia: " + Arrays.toString(copia));
        // [4, 8, 15, 23]

        // fill: rellenar
        int[] relleno = new int[5];
        Arrays.fill(relleno, -1);
        System.out.println("Relleno: " + Arrays.toString(relleno));
        // [-1, -1, -1, -1, -1]

        // equals: comparar contenido
        int[] a = {1, 2, 3};
        int[] b = {1, 2, 3};
        System.out.println("¿Iguales? " + Arrays.equals(a, b));  // true
        System.out.println("¿Mismo objeto? " + (a == b));         // false

        // stream: programación funcional
        double media = Arrays.stream(numeros).average().orElse(0);
        System.out.printf("Media: %.1f%n", media);  // 36.9
    }
}

String texto = "  Programación en Java  ";

String limpio = texto.trim();                   // "Programación en Java"
String mayus  = limpio.toUpperCase();            // "PROGRAMACIÓN EN JAVA"
String[] palabras = limpio.split(" ");           // ["Programación", "en", "Java"]
boolean contiene = limpio.contains("Java");      // true
String reemplazo = limpio.replace("Java", "Python"); // "Programación en Python"

System.out.println("Palabras: " + palabras.length);  // 3
System.out.println("Contiene Java: " + contiene);     // true
System.out.println("Reemplazo: " + reemplazo);

// ❌ Ineficiente: crea un nuevo String en cada iteración
String resultado = "";
for (int i = 1; i <= 1000; i++) {
    resultado += i + ", ";  // 1000 objetos String temporales
}

// ✅ Eficiente: un solo objeto StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 1000; i++) {
    sb.append(i);
    if (i < 1000) sb.append(", ");
}
String resultado2 = sb.toString();

// Otros métodos útiles
StringBuilder sb2 = new StringBuilder("Hola");
sb2.append(" Mundo");          // "Hola Mundo"
sb2.insert(5, " Buen");       // "Hola Buen Mundo"
sb2.replace(0, 4, "¡Hola");   // "¡Hola Buen Mundo"
sb2.reverse();                 // "odnuM neuB aloH¡"
System.out.println(sb2.length()); // 17

// Área de un círculo
double radio = 5.0;
double area = Math.PI * Math.pow(radio, 2);
System.out.printf("Área: %.2f%n", area);  // 78.54

// Distancia entre dos puntos (teorema de Pitágoras)
double x1 = 3, y1 = 4, x2 = 7, y2 = 1;
double distancia = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
System.out.printf("Distancia: %.2f%n", distancia);  // 5.00

// Número aleatorio entre 1 y 100
int aleatorio = (int) (Math.random() * 100) + 1;
System.out.println("Aleatorio: " + aleatorio);

// Autoboxing: primitivo → objeto (automático)
Integer numObj = 42;           // equivale a Integer.valueOf(42)
Double piObj = 3.14;           // equivale a Double.valueOf(3.14)

// Unboxing: objeto → primitivo (automático)
int num = numObj;              // equivale a numObj.intValue()
double pi = piObj;

// Conversión String → primitivo
int edad = Integer.parseInt("25");
double precio = Double.parseDouble("19.99");

// Conversión primitivo → String
String edadStr = Integer.toString(25);       // "25"
String precioStr = String.valueOf(19.99);    // "19.99"

// Constantes útiles
System.out.println("int máximo: " + Integer.MAX_VALUE);  // 2147483647
System.out.println("int mínimo: " + Integer.MIN_VALUE);  // -2147483648

// Métodos de Character
System.out.println(Character.isDigit('5'));      // true
System.out.println(Character.isLetter('A'));     // true
System.out.println(Character.toUpperCase('a'));  // 'A'

import java.util.*;

public class DemoCollections {
    public static void main(String[] args) {
        List<String> ciudades = new ArrayList<>(
            Arrays.asList("Madrid", "Barcelona", "Sevilla", "Valencia", "Bilbao")
        );

        // sort: ordenar alfabéticamente
        Collections.sort(ciudades);
        System.out.println("Ordenadas: " + ciudades);
        // [Barcelona, Bilbao, Madrid, Sevilla, Valencia]

        // reverse: invertir el orden
        Collections.reverse(ciudades);
        System.out.println("Invertidas: " + ciudades);
        // [Valencia, Sevilla, Madrid, Bilbao, Barcelona]

        // shuffle: mezclar aleatoriamente
        Collections.shuffle(ciudades);
        System.out.println("Mezcladas: " + ciudades);

        // min y max
        System.out.println("Mín: " + Collections.min(ciudades));
        System.out.println("Máx: " + Collections.max(ciudades));

        // frequency: contar ocurrencias
        List<Integer> nums = Arrays.asList(1, 3, 5, 3, 7, 3, 9);
        System.out.println("Veces que aparece 3: " + Collections.frequency(nums, 3));  // 3

        // unmodifiableList: lista de solo lectura
        List<String> soloLectura = Collections.unmodifiableList(ciudades);
        // soloLectura.add("Málaga");  // ¡UnsupportedOperationException!
    }
}

import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class GestorCalificaciones {

    public static void main(String[] args) {
        // Datos de entrada como cadenas (simula lectura de archivo)
        String datos = "Ana:8,9,7;Luis:6,5,8;María:10,9,10;Pedro:4,6,3";

        // Procesar cada estudiante
        String[] estudiantes = datos.split(";");
        List<String> resultados = new ArrayList<>();
        StringBuilder informe = new StringBuilder();
        informe.append("╔══════════════════════════════════════════╗\n");
        informe.append("║     INFORME DE CALIFICACIONES            ║\n");
        informe.append("╠══════════════════════════════════════════╣\n");

        double mediaGlobal = 0;
        int totalEstudiantes = estudiantes.length;

        for (String est : estudiantes) {
            // Separar nombre y notas
            String nombre = est.split(":")[0].trim();
            String[] notasStr = est.split(":")[1].split(",");

            // Convertir String[] a int[] usando wrapper Integer
            int[] notas = new int[notasStr.length];
            for (int i = 0; i < notasStr.length; i++) {
                notas[i] = Integer.parseInt(notasStr[i].trim());
            }

            // Cálculos con Arrays y Math
            double media = Arrays.stream(notas).average().orElse(0);
            int maxNota = Arrays.stream(notas).max().orElse(0);
            int minNota = Arrays.stream(notas).min().orElse(0);
            String estado = media >= 5 ? "APROBADO ✅" : "SUSPENDIDO ❌";

            // Construir línea del informe con StringBuilder
            informe.append(String.format("║ %-8s | Notas: %-10s | Media: %.1f %s%n",
                nombre, Arrays.toString(notas), media, estado));

            resultados.add(nombre + ": " + String.format("%.1f", media));
            mediaGlobal += media;
        }

        informe.append("╠══════════════════════════════════════════╣\n");
        informe.append(String.format("║ Media global: %.2f%n", mediaGlobal / totalEstudiantes));
        informe.append("╚══════════════════════════════════════════╝");

        System.out.println(informe);

        // Ordenar resultados con Collections
        Collections.sort(resultados);
        System.out.println("\nRanking alfabético: " + resultados);
    }
}

String a = new String("Java");
String b = new String("Java");

// ❌ Compara referencias (direcciones de memoria), NO contenido
System.out.println(a == b);          // false

// ✅ Compara contenido
System.out.println(a.equals(b));     // true

int[] nums = {10, 20, 30};

// ❌ Índice 3 no existe (válidos: 0, 1, 2)
System.out.println(nums[3]);  // 💥 ArrayIndexOutOfBoundsException

// ✅ Usar length para evitarlo
for (int i = 0; i < nums.length; i++) {  // length = 3, itera 0, 1, 2
    System.out.println(nums[i]);
}

int[] datos = {42, 15, 8, 99};

// ❌ binarySearch requiere array ORDENADO
int pos = Arrays.binarySearch(datos, 15);  // Resultado impredecible

// ✅ Ordenar primero
Arrays.sort(datos);                         // [8, 15, 42, 99]
int pos2 = Arrays.binarySearch(datos, 15);  // 1 (correcto)