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:
- Los arreglos se pueden pasar a métodos como parámetros
- Los métodos pueden devolver valores calculados a partir de arreglos
- 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:
- Almacenará los nombres de los estudiantes y sus calificaciones
- Calculará la calificación promedio
- Encontrará las calificaciones más altas y más bajas
- 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:
- Usar múltiples arreglos para almacenar datos relacionados
- Crear métodos de utilidad para cálculos y formateo
- Contar y categorizar datos
- 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:
- Usar lógica condicional con arreglos
- Crear arreglos filtrados basados en condiciones
- Calcular estadísticas a partir de datos de arreglos
- 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.
