Implementación de 16 Operaciones Fundamentales con Arrays en Java
Enviado por Chuletator online y clasificado en Informática y Telecomunicaciones
Escrito el en 
español con un tamaño de 11,33 KB
Introducción: Manipulación de Arrays en Java
El siguiente código fuente en Java demuestra la implementación de 16 módulos funcionales básicos para la manipulación y consulta de un arreglo (array) de 10 elementos enteros. Este ejemplo es fundamental para comprender las operaciones iterativas y condicionales aplicadas a estructuras de datos simples.
Código Fuente Java (Clase Arreglos4)
import java.io.*;
public class Arreglos4 {
public static void main (String[] args) throws Exception {
BufferedReader teclado = new BufferedReader (new InputStreamReader (System.in));
// Declaración de variables
int i, j, k, x; // x añadido para el módulo de búsqueda
int[] num = new int[10];
int mayor, menor, resi, ref;
double suma, prom;
// ===================================================================
// H4: Módulos de Entrada y Salida
// ===================================================================
// 1. Módulo de Captura
System.out.println("\nModulo 1: Captura de datos...");
for (i = 0; i <= 9; i++){
System.out.print("Número " + (i + 1) + ": ");
num[i] = Integer.parseInt(teclado.readLine());
}
// 2. Módulo de Escritura (Orden Normal)
System.out.println();
System.out.println("Modulo 2: Escritura (Orden Normal)...");
for (i = 0; i <= 9; i++){
System.out.print(num[i]);
if (i < 9) System.out.print(", ");
}
// 3. Módulo de Escritura al Revés
System.out.println();
System.out.println();
System.out.println("Modulo 3: Escritura al Revés...");
for (i = 9; i >= 0; i--){
System.out.print(num[i]);
if (i > 0) System.out.print(", ");
}
// ===================================================================
// H4: Módulos de Búsqueda de Extremos
// ===================================================================
// 4. Módulo Mayor
System.out.println();
System.out.println("\nModulo 4: Búsqueda del Mayor...");
// Inicialización correcta: se asume que el primer elemento es el mayor inicialmente
mayor = num[0];
for(i = 1; i <= 9; i++){
if (num[i] > mayor) mayor = num[i];
}
System.out.println("El mayor es: " + mayor);
// 5. Módulo Menor
System.out.println();
System.out.println("Modulo 5: Búsqueda del Menor...");
// Inicialización correcta: se asume que el primer elemento es el menor inicialmente
menor = num[0];
for(i = 1; i <= 9; i++){
if (menor > num[i]) menor = num[i];
}
System.out.println("El menor es: " + menor);
// ===================================================================
// H4: Módulos de Filtrado por Propiedades Numéricas
// ===================================================================
// 6. Módulo de Pares
System.out.println();
System.out.println();
System.out.println("Modulo 6: Números Pares...");
for (i = 0; i <= 9; i++){
resi = num[i] % 2;
if (resi == 0){
System.out.print(num[i]);
// Lógica de impresión de coma mejorada para evitar coma final
if (i < 9) System.out.print(", ");
}
}
// 7. Módulo de Impares
System.out.println();
System.out.println();
System.out.println("Modulo 7: Números Impares...");
for (i = 0; i <= 9; i++){
resi = num[i] % 2;
// Un número es impar si el residuo es 1 (o diferente de 0)
if (resi != 0){
System.out.print(num[i]);
if (i < 9) System.out.print(", ");
}
}
// 8. Módulo de Múltiplos de 5
System.out.println();
System.out.println();
System.out.println("Modulo 8: Múltiplos de 5...");
for (i = 0; i <= 9; i++){
resi = num[i] % 5;
if (resi == 0){
System.out.print(num[i]);
if (i < 9) System.out.print(", ");
}
}
// 9. Módulo de Divisores de 90
System.out.println();
System.out.println("Modulo 9: Divisores de 90 (presentes en el arreglo)...");
for(i = 0; i <= 9; i++){
// Se debe evitar la división por cero si el arreglo contiene 0
if (num[i] != 0) {
resi = 90 % num[i];
if(resi == 0) System.out.print(num[i] + " ");
}
}
// ===================================================================
// H4: Módulos de Clasificación por Edad
// ===================================================================
// 10. Módulo Mayores de Edad
System.out.println();
System.out.println();
System.out.println("Modulo 10: Mayores de Edad (>= 18)...");
for (i = 0; i <= 9; i++){
if (num[i] >= 18){
System.out.print(num[i]);
if (i < 9) System.out.print(", ");
}
}
// 11. Módulo Menores de Edad
System.out.println();
System.out.println();
System.out.println("Modulo 11: Menores de Edad (<= 18)...");
for (i = 0; i <= 9; i++){
// Nota: La condición original incluía 18. Se mantiene la lógica original (<= 18).
if (num[i] <= 18){
System.out.print(num[i]);
if (i < 9) System.out.print(", ");
}
}
// ===================================================================
// H4: Módulos de Clasificación Avanzada
// ===================================================================
// 12. Módulo de Primos
System.out.println();
System.out.println();
System.out.println("Modulo 12: Números Primos...");
for (i = 0; i <= 9; i++){
ref = 0; // Contador/bandera para divisores
// Los números 0 y 1 no son primos. Se ignoran.
if (num[i] <= 1) continue;
// Bucle de verificación de divisibilidad
for (j = 2; j <= num[i] - 1; j++){
resi = num[i] % j;
if (resi == 0) {
ref = 1; // Es divisible, no es primo
break; // Optimización: si encuentra un divisor, sale del bucle interno
}
}
if (ref == 0) { // Si ref sigue siendo 0, es primo
System.out.print(num[i]);
if (i < 9) System.out.print(", ");
}
}
// 13. Módulo de Compuestos
System.out.println();
System.out.println();
System.out.println("Modulo 13: Números Compuestos...");
for (i = 0; i <= 9; i++){
ref = 0;
// Los números 0 y 1 no son compuestos. Se ignoran.
if (num[i] <= 1) continue;
for (j = 2; j <= num[i] - 1; j++){
resi = num[i] % j;
if (resi == 0) {
ref = 1; // Es divisible, es compuesto
break;
}
}
if (ref == 1) { // Si ref es 1, es compuesto
System.out.print(num[i]);
if (i < 9) System.out.print(", ");
}
}
// 14. Módulo de Potencias de Base 2
System.out.println();
System.out.println();
System.out.println("Modulo 14: Potencias de Base 2...");
int base2;
for (i = 0; i <= 9; i++){
for (j = 0; j <= 15; j++){ // Se verifica hasta 2^15
base2 = 1;
for(k = 1; k <= j; k++){
base2 = base2 * 2;
}
if (num[i] == base2) {
System.out.print(num[i] + ", ");
}
}
}
// ===================================================================
// H4: Módulos de Agregación y Búsqueda
// ===================================================================
// 15. Módulo de Suma y Promedio
System.out.println();
System.out.println();
System.out.println("Modulo 15: Suma y Promedio...");
suma = 0.0;
prom = 0.0;
for (i = 0; i <= 9; i++){
suma = suma + num[i];
}
System.out.print("Suma: " + suma);
prom = suma / 10;
System.out.println(" Promedio: " + prom);
// 16. Módulo de Número Seleccionado (Búsqueda)
System.out.println();
System.out.println();
System.out.println("Modulo 16: Búsqueda de Número Seleccionado...");
System.out.print("Introduzca el número que desea buscar: ");
x = Integer.parseInt(teclado.readLine());
boolean encontrado = false;
for (i = 0; i <= 9; i++){
if (num[i] == x) {
System.out.print("El número: " + x + " sí existe en la posición " + i + ". ");
encontrado = true;
break;
}
}
if (!encontrado) {
System.out.print("El número: " + x + " no existe en el arreglo.");
}
}
}
Resumen de Funcionalidades Implementadas
El programa Arreglos4.java demuestra la versatilidad de los arrays en Java, cubriendo desde la entrada y salida de datos hasta operaciones matemáticas y lógicas complejas. A continuación, se listan los 16 módulos:
- Captura de Datos: Ingreso de 10 números enteros.
- Escritura Normal: Impresión de los elementos en el orden de captura.
- Escritura al Revés: Impresión de los elementos en orden inverso.
- Búsqueda del Mayor: Identificación del valor máximo en el arreglo.
- Búsqueda del Menor: Identificación del valor mínimo en el arreglo.
- Filtrado de Pares: Muestra solo los números divisibles por 2.
- Filtrado de Impares: Muestra solo los números no divisibles por 2.
- Múltiplos de 5: Identificación de los números divisibles por 5.
- Divisores de 90: Muestra qué números del arreglo son divisores exactos de 90.
- Mayores de Edad: Filtrado de valores mayores o iguales a 18.
- Menores de Edad: Filtrado de valores menores o iguales a 18.
- Números Primos: Identificación de números que solo son divisibles por 1 y por sí mismos.
- Números Compuestos: Identificación de números que tienen más de dos divisores.
- Potencias de Base 2: Identificación de números que son potencias exactas de 2 (ej. 1, 2, 4, 8...).
- Suma y Promedio: Cálculo de la suma total y el promedio aritmético de los elementos.
- Búsqueda Específica: Permite al usuario buscar la existencia de un número concreto dentro del arreglo.