¿Cómo crear arreglos en Java con tamaño fijo?

Introducción

Este tutorial explora las técnicas esenciales para crear y usar arreglos de tamaño fijo en Java. Los arreglos son estructuras de datos fundamentales que le permiten almacenar múltiples elementos del mismo tipo en una sola variable. Al dominar los arreglos en Java, obtendrá una habilidad de programación crucial que sirve como base para temas más avanzados.

En este laboratorio, aprenderá a declarar, inicializar y manipular arreglos a través de la práctica. Cada paso se basa en el anterior, proporcionándole una comprensión completa de las operaciones de arreglos en Java.

Creando tu Primer Arreglo en Java

Los arreglos en Java son objetos que almacenan múltiples variables del mismo tipo. A diferencia de otras estructuras de datos, una vez que se crea un arreglo, su tamaño no se puede cambiar. Esto hace que los arreglos sean particularmente eficientes para almacenar un número predeterminado de elementos.

Declaración e Inicialización de Arreglos

Los arreglos se pueden crear de diferentes maneras. Exploremos los métodos más comunes.

Creando un Arreglo de Enteros Simple

Primero, creemos un nuevo archivo Java en el directorio de nuestro proyecto. En el WebIDE, haga clic en el menú "Archivo", seleccione "Nuevo archivo" y asígnele el nombre ArrayDemo.java.

Agregue el siguiente código a su archivo:

public class ArrayDemo {
    public static void main(String[] args) {
        // Método 1: Declarar e inicializar un arreglo por separado
        int[] numbers;       // Declaración del arreglo
        numbers = new int[5]; // Inicialización del arreglo con tamaño 5

        // Se asignan valores predeterminados (todos ceros para el arreglo de enteros)
        System.out.println("Elementos del arreglo después de la inicialización:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        System.out.println("\nLongitud del arreglo: " + numbers.length);
    }
}

Para compilar y ejecutar su programa Java, abra una terminal en el WebIDE (si aún no está abierta) y ejecute los siguientes comandos:

javac ArrayDemo.java
java ArrayDemo

Debería ver una salida similar a esta:

Array elements after initialization:
numbers[0] = 0
numbers[1] = 0
numbers[2] = 0
numbers[3] = 0
numbers[4] = 0

Array length: 5

Como puede ver, Java inicializa automáticamente todos los elementos en un arreglo de enteros a cero.

Inicialización de Arreglos con Valores

Ahora, modifiquemos nuestro archivo ArrayDemo.java para incluir otra forma de crear arreglos: la inicialización con valores específicos:

public class ArrayDemo {
    public static void main(String[] args) {
        // Método 1: Declarar e inicializar un arreglo por separado
        int[] numbers;       // Declaración del arreglo
        numbers = new int[5]; // Inicialización del arreglo con tamaño 5

        // Se asignan valores predeterminados (todos ceros para el arreglo de enteros)
        System.out.println("Elementos del arreglo después de la inicialización:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        System.out.println("\nLongitud del arreglo: " + numbers.length);

        // Método 2: Inicializar con valores específicos
        int[] scores = {85, 90, 75, 88, 92};

        System.out.println("\nElementos del arreglo scores:");
        for (int i = 0; i < scores.length; i++) {
            System.out.println("scores[" + i + "] = " + scores[i]);
        }
    }
}

Compile y ejecute el programa actualizado:

javac ArrayDemo.java
java ArrayDemo

Ahora debería ver una salida adicional:

Array elements after initialization:
numbers[0] = 0
numbers[1] = 0
numbers[2] = 0
numbers[3] = 0
numbers[4] = 0

Array length: 5

Scores array elements:
scores[0] = 85
scores[1] = 90
scores[2] = 75
scores[3] = 88
scores[4] = 92

Creando Arreglos de Diferentes Tipos

Creemos un nuevo archivo llamado ArrayTypes.java para demostrar arreglos de diferentes tipos de datos. En el WebIDE, cree un nuevo archivo y agregue el siguiente código:

public class ArrayTypes {
    public static void main(String[] args) {
        // Arreglo de String
        String[] names = new String[3];
        names[0] = "Alice";
        names[1] = "Bob";
        names[2] = "Charlie";

        System.out.println("Elementos del arreglo de String:");
        for (int i = 0; i < names.length; i++) {
            System.out.println("names[" + i + "] = " + names[i]);
        }

        // Arreglo de Double con inicialización
        double[] prices = {19.99, 29.99, 15.50, 99.99};

        System.out.println("\nElementos del arreglo de Double:");
        for (int i = 0; i < prices.length; i++) {
            System.out.println("prices[" + i + "] = " + prices[i]);
        }

        // Arreglo de Boolean
        boolean[] flags = new boolean[3];
        flags[0] = true;

        System.out.println("\nElementos del arreglo de Boolean:");
        for (int i = 0; i < flags.length; i++) {
            System.out.println("flags[" + i + "] = " + flags[i]);
        }
    }
}

Compile y ejecute este programa:

javac ArrayTypes.java
java ArrayTypes

Verá la siguiente salida:

String array elements:
names[0] = Alice
names[1] = Bob
names[2] = Charlie

Double array elements:
prices[0] = 19.99
prices[1] = 29.99
prices[2] = 15.5
prices[3] = 99.99

Boolean array elements:
flags[0] = true
flags[1] = false
flags[2] = false

Observe que los diferentes tipos de datos tienen diferentes valores predeterminados:

• Los tipos numéricos (int, double, etc.) por defecto son cero
• Boolean por defecto es false
• Los tipos de referencia (String, objetos) por defecto son null

Este paso le ha mostrado los conceptos básicos de la creación de arreglos en Java. Ha aprendido a declarar arreglos, inicializarlos con y sin valores, y crear arreglos de diferentes tipos de datos.

Trabajando con Elementos de Arreglos

Ahora que sabemos cómo crear arreglos, exploremos cómo trabajar con los elementos de los arreglos. Esto incluye establecer valores, acceder a elementos y modificar el contenido del arreglo.

Acceso y Modificación de Elementos de Arreglos

Cree un nuevo archivo llamado ArrayOperations.java en su WebIDE con el siguiente código:

public class ArrayOperations {
    public static void main(String[] args) {
        // Crear un arreglo de enteros
        int[] numbers = new int[5];

        // Asignar valores a los elementos del arreglo
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;

        // Mostrar el arreglo original
        System.out.println("Elementos del arreglo original:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        // Acceder a elementos específicos
        int firstElement = numbers[0];
        int thirdElement = numbers[2];

        System.out.println("\nAccediendo a elementos específicos:");
        System.out.println("Primer elemento: " + firstElement);
        System.out.println("Tercer elemento: " + thirdElement);

        // Modificar elementos del arreglo
        numbers[1] = 25;    // Cambiar el segundo elemento
        numbers[4] = 55;    // Cambiar el último elemento

        // Mostrar el arreglo modificado
        System.out.println("\nArreglo después de la modificación:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }
    }
}

Compile y ejecute este programa:

javac ArrayOperations.java
java ArrayOperations

Debería ver esta salida:

Original array elements:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

Accessing specific elements:
First element: 10
Third element: 30

Array after modification:
numbers[0] = 10
numbers[1] = 25
numbers[2] = 30
numbers[3] = 40
numbers[4] = 55

Límites del Arreglo y Manejo de Excepciones

Al trabajar con arreglos, es crucial comprender los límites del arreglo. Los arreglos de Java tienen un tamaño fijo, e intentar acceder a un elemento fuera de estos límites causará una excepción.

Cree un nuevo archivo llamado ArrayBoundaries.java con el siguiente código:

public class ArrayBoundaries {
    public static void main(String[] args) {
        int[] numbers = new int[3];  // Arreglo con 3 elementos (índices 0, 1, 2)

        // Establecer valores dentro de los límites
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;

        System.out.println("Elementos del arreglo dentro de los límites:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        // Demostrando la verificación de límites con try-catch
        System.out.println("\nIntentando acceder a elementos fuera de los límites:");

        try {
            // Esto es válido
            System.out.println("Accediendo a numbers[2]: " + numbers[2]);

            // Esto causará una ArrayIndexOutOfBoundsException
            System.out.println("Intentando acceder a numbers[3]: " + numbers[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Error: " + e.getMessage());
            System.out.println("No se puede acceder a un índice fuera de los límites del arreglo (0 a " + (numbers.length-1) + ")");
        }
    }
}

Compile y ejecute este programa:

javac ArrayBoundaries.java
java ArrayBoundaries

Debería ver una salida como esta:

Array elements within boundaries:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30

Attempting to access elements outside boundaries:
Accessing numbers[2]: 30
Error: Index 3 out of bounds for length 3
Cannot access an index outside the array bounds (0 to 2)

Esto demuestra que Java realiza una verificación de límites en los arreglos. Intentar acceder a numbers[3] lanza una excepción porque el arreglo solo tiene elementos en los índices 0, 1 y 2.

Calcular y Almacenar Valores en Arreglos

Creemos un ejemplo práctico donde calculamos valores y los almacenamos en un arreglo. Cree un archivo llamado TemperatureConverter.java:

public class TemperatureConverter {
    public static void main(String[] args) {
        // Arreglo para almacenar temperaturas en Celsius
        double[] celsiusTemps = {0, 10, 20, 30, 40};

        // Arreglo para almacenar temperaturas en Fahrenheit convertidas
        double[] fahrenheitTemps = new double[celsiusTemps.length];

        // Convertir cada temperatura Celsius a Fahrenheit
        for (int i = 0; i < celsiusTemps.length; i++) {
            // Fórmula: F = C * 9/5 + 32
            fahrenheitTemps[i] = celsiusTemps[i] * 9/5 + 32;
        }

        // Mostrar la tabla de conversión
        System.out.println("Tabla de Conversión de Temperatura:");
        System.out.println("---------------------------");
        System.out.println("Celsius    |    Fahrenheit");
        System.out.println("---------------------------");

        for (int i = 0; i < celsiusTemps.length; i++) {
            System.out.printf("%-10.1f |    %-10.1f\n",
                             celsiusTemps[i],
                             fahrenheitTemps[i]);
        }
    }
}

Compile y ejecute este programa:

javac TemperatureConverter.java
java TemperatureConverter

La salida será una tabla de conversión de temperatura:

Temperature Conversion Table:
---------------------------
Celsius    |    Fahrenheit
---------------------------
0.0        |    32.0
10.0       |    50.0
20.0       |    68.0
30.0       |    86.0
40.0       |    104.0

Este ejemplo demuestra cómo se pueden usar los arreglos para almacenar datos relacionados y realizar cálculos en múltiples valores de manera eficiente.

En este paso, ha aprendido a acceder y modificar elementos de arreglos, manejar los límites de los arreglos y usar arreglos para cálculos prácticos. Estas habilidades forman la base para operaciones de arreglos más complejas.

Operaciones Avanzadas con Arreglos

Ahora que comprende los conceptos básicos de los arreglos, exploremos operaciones más sofisticadas, incluyendo la iteración de arreglos, la búsqueda y el uso de arreglos con métodos.

Técnicas de Iteración de Arreglos

Java proporciona múltiples formas de iterar a través de los elementos de un arreglo. Cree un nuevo archivo llamado ArrayIteration.java con el siguiente código:

public class ArrayIteration {
    public static void main(String[] args) {
        // Crear un arreglo de muestra
        String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};

        System.out.println("Métodos de Iteración de Arreglos:");

        // Método 1: Bucle for estándar
        System.out.println("\n1. Usando el bucle for estándar:");
        for (int i = 0; i < fruits.length; i++) {
            System.out.println("fruits[" + i + "] = " + fruits[i]);
        }

        // Método 2: Bucle for mejorado (foreach)
        System.out.println("\n2. Usando el bucle for mejorado (foreach):");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // Método 3: Bucle while
        System.out.println("\n3. Usando el bucle while:");
        int index = 0;
        while (index < fruits.length) {
            System.out.println("fruits[" + index + "] = " + fruits[index]);
            index++;
        }
    }
}

Compile y ejecute este programa:

javac ArrayIteration.java
java ArrayIteration

Debería ver esta salida:

Array Iteration Methods:

1. Using standard for loop:
fruits[0] = Apple
fruits[1] = Banana
fruits[2] = Cherry
fruits[3] = Date
fruits[4] = Elderberry

2. Using enhanced for loop (foreach):
Apple
Banana
Cherry
Date
Elderberry

3. Using while loop:
fruits[0] = Apple
fruits[1] = Banana
fruits[2] = Cherry
fruits[3] = Date
fruits[4] = Elderberry

Cada método de iteración tiene sus ventajas:

• Bucle for estándar: Proporciona acceso a los índices y elementos del arreglo
• Bucle for mejorado: Sintaxis más limpia cuando solo necesita los elementos
• Bucle while: Útil cuando la condición de iteración es más compleja

Búsqueda de Elementos en un Arreglo

Creemos un programa que busque elementos en un arreglo. Cree un archivo llamado ArraySearch.java:

public class ArraySearch {
    public static void main(String[] args) {
        // Crear un arreglo de números
        int[] numbers = {10, 25, 33, 47, 52, 68, 79};

        // Valores a buscar
        int[] searchValues = {33, 50, 79};

        for (int valueToFind : searchValues) {
            boolean found = false;
            int position = -1;

            // Buscar en el arreglo
            for (int i = 0; i < numbers.length; i++) {
                if (numbers[i] == valueToFind) {
                    found = true;
                    position = i;
                    break;  // Salir del bucle una vez encontrado
                }
            }

            // Mostrar el resultado
            if (found) {
                System.out.println(valueToFind + " encontrado en la posición " + position);
            } else {
                System.out.println(valueToFind + " no encontrado en el arreglo");
            }
        }
    }
}

Compile y ejecute este programa:

javac ArraySearch.java
java ArraySearch

Debería ver una salida como esta:

33 encontrado en la posición 2
50 no encontrado en el arreglo
79 encontrado en la posición 6

Esto demuestra un algoritmo de búsqueda lineal básico, que verifica cada elemento hasta que se encuentra el valor objetivo o se agota el arreglo.

Pasar Arreglos a Métodos

Los arreglos se pueden pasar a métodos como cualquier otra variable. Cree un archivo llamado ArrayMethods.java:

public class ArrayMethods {
    public static void main(String[] args) {
        // Crear un arreglo
        int[] values = {5, 10, 15, 20, 25};

        // Mostrar el arreglo original
        System.out.println("Arreglo original:");
        displayArray(values);

        // Calcular y mostrar la suma
        int sum = calculateSum(values);
        System.out.println("\nSuma de todos los elementos: " + sum);

        // Calcular y mostrar el promedio
        double average = calculateAverage(values);
        System.out.println("Promedio de todos los elementos: " + average);

        // Duplicar todos los valores en el arreglo
        doubleValues(values);

        // Mostrar el arreglo modificado
        System.out.println("\nArreglo después de duplicar todos los valores:");
        displayArray(values);
    }

    // Método para mostrar un arreglo
    public static void displayArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    // Método para calcular la suma de los elementos del arreglo
    public static int calculateSum(int[] arr) {
        int sum = 0;
        for (int value : arr) {
            sum += value;
        }
        return sum;
    }

    // Método para calcular el promedio de los elementos del arreglo
    public static double calculateAverage(int[] arr) {
        int sum = calculateSum(arr);
        return (double) sum / arr.length;
    }

    // Método para duplicar todos los valores en el arreglo
    public static void doubleValues(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * 2;
        }
    }
}

Compile y ejecute este programa:

javac ArrayMethods.java
java ArrayMethods

Debería ver una salida como esta:

Arreglo original:
5 10 15 20 25

Suma de todos los elementos: 75
Promedio de todos los elementos: 15.0

Arreglo después de duplicar todos los valores:
10 20 30 40 50

Este ejemplo demuestra varios conceptos importantes:

1. Los arreglos se pueden pasar a métodos como parámetros
2. Los métodos pueden devolver valores calculados a partir de arreglos
3. Los cambios realizados en los elementos del arreglo dentro de un método se reflejan fuera del método (los arreglos se pasan por referencia)

Encontrar los Valores Máximo y Mínimo

Creemos un programa para encontrar los valores máximo y mínimo en un arreglo. Cree un archivo llamado ArrayMinMax.java:

public class ArrayMinMax {
    public static void main(String[] args) {
        // Crear un arreglo de números
        int[] numbers = {42, 17, 88, 23, 56, 9, 71, 33};

        // Encontrar los valores mínimo y máximo
        int min = findMinimum(numbers);
        int max = findMaximum(numbers);

        // Mostrar el arreglo
        System.out.print("Valores del arreglo: ");
        for (int num : numbers) {
            System.out.print(num + " ");
        }
        System.out.println();

        // Mostrar los resultados
        System.out.println("Valor mínimo: " + min);
        System.out.println("Valor máximo: " + max);
    }

    // Método para encontrar el valor mínimo en un arreglo
    public static int findMinimum(int[] arr) {
        // Comenzar con el primer elemento como el mínimo
        int min = arr[0];

        // Comparar con otros elementos
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }

        return min;
    }

    // Método para encontrar el valor máximo en un arreglo
    public static int findMaximum(int[] arr) {
        // Comenzar con el primer elemento como el máximo
        int max = arr[0];

        // Comparar con otros elementos
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        return max;
    }
}

Compile y ejecute este programa:

javac ArrayMinMax.java
java ArrayMinMax

Debería ver una salida como esta:

Valores del arreglo: 42 17 88 23 56 9 71 33
Valor mínimo: 9
Valor máximo: 88

En este paso, ha aprendido varias operaciones avanzadas con arreglos, incluyendo diferentes técnicas de iteración, búsqueda de elementos, pasar arreglos a métodos y encontrar los valores mínimo y máximo. Estas habilidades le ayudarán a trabajar de manera más efectiva con arreglos en sus programas Java.

Aplicaciones Prácticas de Arreglos

En este paso final, exploraremos aplicaciones prácticas de los arreglos a través de un ejemplo completo. Crearemos un sistema simple de gestión de calificaciones que demuestra cómo se pueden usar los arreglos en escenarios de programación del mundo real.

Creación de un Rastreador de Calificaciones de Estudiantes

Construyamos un programa que gestione las calificaciones de los estudiantes. Este programa:

1. Almacenará los nombres de los estudiantes y sus calificaciones
2. Calculará la calificación promedio
3. Encontrará las calificaciones más altas y más bajas
4. Determinará cuántos estudiantes obtuvieron una calificación superior al promedio

Cree un nuevo archivo llamado GradeTracker.java en su WebIDE:

public class GradeTracker {
    public static void main(String[] args) {
        // Arreglos para almacenar la información de los estudiantes
        String[] studentNames = {"Alice", "Bob", "Charlie", "David", "Emma",
                                "Frank", "Grace", "Hannah", "Ian", "Julia"};

        int[] studentGrades = {85, 92, 78, 65, 88, 72, 95, 83, 79, 91};

        // Mostrar todos los registros de estudiantes
        System.out.println("Registros de Calificaciones de Estudiantes:");
        System.out.println("---------------------");
        System.out.println("Nombre\t\tCalificación");
        System.out.println("---------------------");

        for (int i = 0; i < studentNames.length; i++) {
            // Agregar una pestaña adicional para nombres cortos para alinear las columnas
            String tab = studentNames[i].length() <= 5 ? "\t\t" : "\t";
            System.out.println(studentNames[i] + tab + studentGrades[i]);
        }

        // Calcular estadísticas
        int sum = 0;
        int highest = studentGrades[0];
        int lowest = studentGrades[0];
        String highestStudent = studentNames[0];
        String lowestStudent = studentNames[0];

        for (int i = 0; i < studentGrades.length; i++) {
            // Sumar para el cálculo del promedio
            sum += studentGrades[i];

            // Verificar la calificación más alta
            if (studentGrades[i] > highest) {
                highest = studentGrades[i];
                highestStudent = studentNames[i];
            }

            // Verificar la calificación más baja
            if (studentGrades[i] < lowest) {
                lowest = studentGrades[i];
                lowestStudent = studentNames[i];
            }
        }

        // Calcular el promedio
        double average = (double) sum / studentGrades.length;

        // Contar los estudiantes por encima del promedio
        int aboveAverageCount = 0;
        for (int grade : studentGrades) {
            if (grade > average) {
                aboveAverageCount++;
            }
        }

        // Mostrar estadísticas
        System.out.println("\nEstadísticas de la Clase:");
        System.out.println("----------------");
        System.out.printf("Promedio de la Clase: %.2f\n", average);
        System.out.println("Calificación más alta: " + highest + " (" + highestStudent + ")");
        System.out.println("Calificación más baja: " + lowest + " (" + lowestStudent + ")");
        System.out.println("Número de estudiantes por encima del promedio: " + aboveAverageCount);
    }
}

Compile y ejecute este programa:

javac GradeTracker.java
java GradeTracker

Debería ver una salida como esta:

Student Grade Records:
---------------------
Name		Grade
---------------------
Alice		85
Bob		92
Charlie	78
David		65
Emma		88
Frank		72
Grace		95
Hannah		83
Ian		79
Julia		91

Class Statistics:
----------------
Class Average: 82.80
Highest Grade: 95 (Grace)
Lowest Grade: 65 (David)
Number of students above average: 5

Este programa demuestra cómo se pueden usar los arreglos para gestionar datos relacionados (nombres y calificaciones de estudiantes) y realizar cálculos sobre esos datos.

Agregar Categorías de Calificaciones

Ahora, mejoremos nuestro rastreador de calificaciones agregando categorías de calificaciones. Cree un nuevo archivo llamado EnhancedGradeTracker.java:

public class EnhancedGradeTracker {
    public static void main(String[] args) {
        // Arreglos para almacenar la información de los estudiantes
        String[] studentNames = {"Alice", "Bob", "Charlie", "David", "Emma",
                                "Frank", "Grace", "Hannah", "Ian", "Julia"};

        int[] studentGrades = {85, 92, 78, 65, 88, 72, 95, 83, 79, 91};

        // Crear arreglos para contar las calificaciones en cada categoría
        int[] gradeCounts = new int[5]; // A, B, C, D, F

        // Mostrar todos los registros de estudiantes con categorías de calificaciones
        System.out.println("Registros de Calificaciones de Estudiantes:");
        System.out.println("------------------------------");
        System.out.println("Nombre\t\tPuntuación\tCalificación");
        System.out.println("------------------------------");

        for (int i = 0; i < studentNames.length; i++) {
            // Calcular la calificación con letras
            char letterGrade = calculateGrade(studentGrades[i]);

            // Contar las calificaciones por categoría
            switch (letterGrade) {
                case 'A': gradeCounts[0]++; break;
                case 'B': gradeCounts[1]++; break;
                case 'C': gradeCounts[2]++; break;
                case 'D': gradeCounts[3]++; break;
                case 'F': gradeCounts[4]++; break;
            }

            // Agregar una pestaña adicional para nombres cortos para alinear las columnas
            String tab = studentNames[i].length() <= 5 ? "\t\t" : "\t";
            System.out.println(studentNames[i] + tab + studentGrades[i] + "\t" + letterGrade);
        }

        // Calcular estadísticas
        double average = calculateAverage(studentGrades);

        // Mostrar estadísticas
        System.out.println("\nEstadísticas de la Clase:");
        System.out.println("----------------");
        System.out.printf("Promedio de la Clase: %.2f\n", average);

        // Mostrar la distribución de calificaciones
        System.out.println("\nDistribución de Calificaciones:");
        System.out.println("------------------");
        System.out.println("A: " + displayStars(gradeCounts[0]));
        System.out.println("B: " + displayStars(gradeCounts[1]));
        System.out.println("C: " + displayStars(gradeCounts[2]));
        System.out.println("D: " + displayStars(gradeCounts[3]));
        System.out.println("F: " + displayStars(gradeCounts[4]));
    }

    // Método para calcular la calificación con letras a partir de una puntuación numérica
    public static char calculateGrade(int score) {
        if (score >= 90) {
            return 'A';
        } else if (score >= 80) {
            return 'B';
        } else if (score >= 70) {
            return 'C';
        } else if (score >= 60) {
            return 'D';
        } else {
            return 'F';
        }
    }

    // Método para calcular el promedio de un arreglo de enteros
    public static double calculateAverage(int[] arr) {
        int sum = 0;
        for (int value : arr) {
            sum += value;
        }
        return (double) sum / arr.length;
    }

    // Método para crear una cadena de estrellas que represente un conteo
    public static String displayStars(int count) {
        StringBuilder stars = new StringBuilder();
        for (int i = 0; i < count; i++) {
            stars.append("*");
        }
        return stars.toString() + " (" + count + ")";
    }
}

Compile y ejecute este programa:

javac EnhancedGradeTracker.java
java EnhancedGradeTracker

Debería ver una salida como esta:

Student Grade Records:
------------------------------
Name		Score	Grade
------------------------------
Alice		85	B
Bob		92	A
Charlie	78	C
David		65	D
Emma		88	B
Frank		72	C
Grace		95	A
Hannah		83	B
Ian		79	C
Julia		91	A

Class Statistics:
----------------
Class Average: 82.80

Grade Distribution:
------------------
A: *** (3)
B: *** (3)
C: *** (3)
D: * (1)
F:  (0)

Este ejemplo mejorado demuestra:

1. Usar múltiples arreglos para almacenar datos relacionados
2. Crear métodos de utilidad para cálculos y formateo
3. Contar y categorizar datos
4. Crear una representación visual de los datos del arreglo

Procesamiento de Datos de Arreglos Basado en Condiciones

Para nuestro ejemplo final, creemos un programa que procese datos de arreglos basados en condiciones. Cree un archivo llamado FilteredGrades.java:

public class FilteredGrades {
    public static void main(String[] args) {
        // Arreglos para almacenar la información de los estudiantes
        String[] studentNames = {"Alice", "Bob", "Charlie", "David", "Emma",
                                "Frank", "Grace", "Hannah", "Ian", "Julia"};

        int[] studentGrades = {85, 92, 78, 65, 88, 72, 95, 83, 79, 91};

        // Crear un umbral para aprobar
        int passingGrade = 75;

        // Mostrar todos los registros de estudiantes con estado de aprobado/reprobado
        System.out.println("Registros de Calificaciones de Estudiantes:");
        System.out.println("------------------------------");
        System.out.println("Nombre\t\tPuntuación\tEstado");
        System.out.println("------------------------------");

        // Contar los estudiantes aprobados y reprobados
        int passingCount = 0;

        for (int i = 0; i < studentNames.length; i++) {
            String status = (studentGrades[i] >= passingGrade) ? "APROBADO" : "REPROBADO";

            // Contar los estudiantes aprobados
            if (studentGrades[i] >= passingGrade) {
                passingCount++;
            }

            // Agregar una pestaña adicional para nombres cortos para alinear las columnas
            String tab = studentNames[i].length() <= 5 ? "\t\t" : "\t";
            System.out.println(studentNames[i] + tab + studentGrades[i] + "\t" + status);
        }

        // Crear arreglos para almacenar solo los estudiantes aprobados
        String[] passingStudents = new String[passingCount];
        int[] passingScores = new int[passingCount];

        // Llenar los arreglos de estudiantes aprobados
        int index = 0;
        for (int i = 0; i < studentNames.length; i++) {
            if (studentGrades[i] >= passingGrade) {
                passingStudents[index] = studentNames[i];
                passingScores[index] = studentGrades[i];
                index++;
            }
        }

        // Mostrar solo los estudiantes aprobados
        System.out.println("\nEstudiantes Aprobados (Puntuación >= 75):");
        System.out.println("------------------------------");
        System.out.println("Nombre\t\tPuntuación");
        System.out.println("------------------------------");

        for (int i = 0; i < passingStudents.length; i++) {
            // Agregar una pestaña adicional para nombres cortos para alinear las columnas
            String tab = passingStudents[i].length() <= 5 ? "\t\t" : "\t";
            System.out.println(passingStudents[i] + tab + passingScores[i]);
        }

        // Calcular y mostrar estadísticas
        System.out.println("\nEstadísticas de la Clase:");
        System.out.println("----------------");
        System.out.println("Total de Estudiantes: " + studentNames.length);
        System.out.println("Aprobados: " + passingCount);
        System.out.println("Reprobados: " + (studentNames.length - passingCount));
        System.out.printf("Tasa de Aprobación: %.1f%%\n",
                         (double) passingCount / studentNames.length * 100);
    }
}

Compile y ejecute este programa:

javac FilteredGrades.java
java FilteredGrades

Debería ver una salida como esta:

Student Grade Records:
------------------------------
Name		Score	Status
------------------------------
Alice		85	PASS
Bob		92	PASS
Charlie	78	PASS
David		65	FAIL
Emma		88	PASS
Frank		72	FAIL
Grace		95	PASS
Hannah		83	PASS
Ian		79	PASS
Julia		91	PASS

Passing Students (Score >= 75):
------------------------------
Name		Score
------------------------------
Alice		85
Bob		92
Charlie	78
Emma		88
Grace		95
Hannah		83
Ian		79
Julia		91

Class Statistics:
----------------
Total Students: 10
Passing: 8
Failing: 2
Pass Rate: 80.0%

Este ejemplo demuestra:

1. Usar lógica condicional con arreglos
2. Crear arreglos filtrados basados en condiciones
3. Calcular estadísticas a partir de datos de arreglos
4. Presentar información de manera formateada

En este paso, ha visto cómo se pueden aplicar los arreglos para resolver problemas prácticos. Ha aprendido a gestionar datos relacionados, realizar cálculos y crear vistas filtradas de datos de arreglos basadas en condiciones. Estas habilidades servirán como una base sólida para trabajar con arreglos en aplicaciones Java del mundo real.

Resumen

En este laboratorio, ha explorado las técnicas esenciales para crear y trabajar con arreglos de tamaño fijo en Java. Aprendió a:

• Declarar e inicializar arreglos de diferentes tipos de datos
• Acceder y modificar elementos de arreglos respetando los límites del arreglo
• Iterar a través de arreglos utilizando diferentes técnicas de bucle
• Pasar arreglos a métodos y procesar datos de arreglos
• Encontrar los valores mínimo y máximo en arreglos
• Aplicar arreglos a problemas prácticos como el seguimiento de calificaciones

Los arreglos forman la base de muchas estructuras de datos en Java y son esenciales para el almacenamiento y la manipulación eficiente de datos. Las habilidades que ha desarrollado en este laboratorio servirán como bloques de construcción para conceptos de programación más avanzados, como estructuras de datos dinámicas, algoritmos y programación orientada a objetos.

Continúe practicando con arreglos modificando los ejemplos proporcionados, creando sus propias aplicaciones basadas en arreglos y explorando la documentación de Java para obtener utilidades de arreglos adicionales en la clase java.util.Arrays.