Ejercicios prácticos con arreglos en Java: vectores, desplazamientos y operaciones comunes

Arreglo de números pares (2 a 12)

Objetivo: Cargar un arreglo con 6 elementos que contenga los números pares del 2 al 12 e imprimirlos verticalmente.

Clase

package paquete;

public class ArregloPares {
    private int[] pares = {2, 4, 6, 8, 10, 12};

    public int mostrarElemento(int i) {
        return pares[i];
    }
}

Main

import paquete.ArregloPares;

class Main {
    public static void main(String[] args) {
        ArregloPares obj = new ArregloPares();

        System.out.println("Elementos del arreglo:");
        for (int i = 0; i < 6; i++) {
            System.out.println(obj.mostrarElemento(i));
        }
    }
}

Vector de 10 elementos: impresión y suma

Objetivo: Cargar un vector con 10 elementos, imprimir el vector y calcular la suma de sus elementos.

Clase

package paquete;

public class Vector10 {
    private int[] v = new int[10];

    // Constructor: carga el vector con valores (1 al 10 como ejemplo)
    public Vector10() {
        for (int i = 0; i < 10; i++) {
            v[i] = i + 1; // Puedes cambiar estos valores si quieres
        }
    }

    // Retorna elemento i
    public int mostrarElemento(int i) {
        return v[i];
    }

    // Suma todos los elementos
    public int sumarElementos() {
        int suma = 0;
        for (int i = 0; i < 10; i++) {
            suma += v[i];
        }
        return suma;
    }
}

Main

import paquete.Vector10;

class Main {
    public static void main(String[] args) {
        Vector10 obj = new Vector10();

        System.out.println("Elementos del vector:");
        for (int i = 0; i < 10; i++) {
            System.out.println("v[" + i + "] = " + obj.mostrarElemento(i));
        }

        System.out.println("\nLa suma de los elementos es: " + obj.sumarElementos());
    }
}

Vectores de cadenas: copia inversa y cadena más larga

Objetivo: Crear un vector de 5 elementos de cadenas de caracteres, copiar los elementos del vector en otro vector en orden inverso, imprimir la cadena más larga y finalmente mostrar ambos vectores uno al lado del otro.

Clase

package paquete;

public class VectorCadenas {
    private String[] cadenas = {"Hola", "Programación", "Java", "Arreglo", "Ejemplo"};
    private String[] inverso = new String[5];

    // Constructor: copia en orden inverso
    public VectorCadenas() {
        for (int i = 0; i < 5; i++) {
            inverso[i] = cadenas[4 - i];
        }
    }

    // Retorna un elemento del vector original
    public String getCadena(int i) {
        return cadenas[i];
    }

    // Retorna un elemento del vector inverso
    public String getCadenaInversa(int i) {
        return inverso[i];
    }

    // Buscar la cadena más larga
    public String cadenaMasLarga() {
        String mayor = cadenas[0];
        for (int i = 1; i < 5; i++) {
            if (cadenas[i].length() > mayor.length()) {
                mayor = cadenas[i];
            }
        }
        return mayor;
    }
}

Main

import paquete.VectorCadenas;

class Main {
    public static void main(String[] args) {
        VectorCadenas obj = new VectorCadenas();

        System.out.println("Vector original    |    Vector inverso");
        System.out.println("-----------------------------------------");
        for (int i = 0; i < 5; i++) {
            System.out.println(obj.getCadena(i) + "    |    " + obj.getCadenaInversa(i));
        }

        System.out.println("\nLa cadena más larga es: " + obj.cadenaMasLarga());
    }
}

Promedios pluviales por región (Meteorología)

Contexto: En el centro meteorológico ubicado en Baja California Sur, México, se registran los promedios totales pluviales de las principales regiones del país: Norte, Centro y Sur. Escriba un programa Java que obtenga:

• El promedio general de las tres regiones.
• La región con mayor promedio total.

Clase

package paquete;

public class Meteorologia {
    // Promedios pluviales por región (ejemplo)
    private float[] regiones = {120.5f, 98.3f, 150.7f};
    // Índices: 0 = Norte, 1 = Centro, 2 = Sur

    // Obtener promedio general de las tres regiones
    public float promedioGeneral() {
        float suma = 0;
        for (int i = 0; i < 3; i++) {
            suma += regiones[i];
        }
        return suma / 3;
    }

    // Regresa el nombre de la región con mayor promedio
    public String regionMayor() {
        int mayorIdx = 0;
        for (int i = 1; i < 3; i++) {
            if (regiones[i] > regiones[mayorIdx]) {
                mayorIdx = i;
            }
        }
        if (mayorIdx == 0) return "Norte";
        if (mayorIdx == 1) return "Centro";
        return "Sur";
    }

    // Obtener promedio específico de una región
    public float getPromedio(int i) {
        return regiones[i];
    }
}

Main

import paquete.Meteorologia;

class Main {
    public static void main(String[] args) {
        Meteorologia obj = new Meteorologia();
        String[] nombres = {"Norte", "Centro", "Sur"};

        System.out.println("Promedios pluviales por región:");
        for (int i = 0; i < 3; i++) {
            System.out.println(nombres[i] + ": " + obj.getPromedio(i) + " mm");
        }

        System.out.println("\nPromedio general de las 3 regiones: " + obj.promedioGeneral() + " mm");
        System.out.println("La región con mayor promedio es: " + obj.regionMayor());
    }
}

Desplazar arreglo hacia la derecha

Objetivo: Cargar un arreglo con n elementos y desplazar sus elementos un lugar hacia la derecha, teniendo en cuenta que el último componente se ha de desplazar al primer lugar.

Clase

package paquete;

public class DesplazarDerecha {
    private int[] v;
    private int n;

    // Constructor: recibe n y llena el arreglo con valores de ejemplo
    public DesplazarDerecha(int n) {
        this.n = n;
        v = new int[n];
        // Cargar arreglo (ejemplo: valores 1,2,3,...)
        for (int i = 0; i < n; i++) {
            v[i] = i + 1;
        }
    }

    // Método para desplazar a la derecha
    public void desplazarDerecha() {
        int ultimo = v[n - 1]; // Guardar el último elemento
        // Mover todos hacia la derecha
        for (int i = n - 1; i > 0; i--) {
            v[i] = v[i - 1];
        }
        // Colocar el último en la primera posición
        v[0] = ultimo;
    }

    // Mostrar elemento i
    public int getElemento(int i) {
        return v[i];
    }
}

Main

import paquete.DesplazarDerecha;
import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Ingrese la cantidad de elementos (n): ");
        int n = sc.nextInt();

        DesplazarDerecha obj = new DesplazarDerecha(n);

        System.out.println("\nArreglo original:");
        for (int i = 0; i < n; i++) {
            System.out.print(obj.getElemento(i) + " ");
        }

        obj.desplazarDerecha();

        System.out.println("\n\nArreglo desplazado a la derecha:");
        for (int i = 0; i < n; i++) {
            System.out.print(obj.getElemento(i) + " ");
        }
    }
}

Diferencia máxima entre elementos consecutivos (vector de 50 reales)

Objetivo: Dado un vector A de 50 números reales, obtener la diferencia más grande entre dos elementos consecutivos de este vector.

Clase

package paquete;

public class VectorDiferencias {
    private float[] A = new float[50];

    // Constructor: llenamos el vector con valores de ejemplo
    public VectorDiferencias() {
        for (int i = 0; i < 50; i++) {
            A[i] = (float)(Math.random() * 100); // números aleatorios 0–100
        }
    }

    // Retorna el mayor valor absoluto de diferencias consecutivas
    public float mayorDiferencia() {
        float mayor = Math.abs(A[1] - A[0]);
        for (int i = 1; i < 49; i++) {
            float diferencia = Math.abs(A[i+1] - A[i]);
            if (diferencia > mayor) {
                mayor = diferencia;
            }
        }
        return mayor;
    }

    // Retornar un elemento
    public float getElemento(int i) {
        return A[i];
    }
}

Main

import paquete.VectorDiferencias;

class Main {
    public static void main(String[] args) {
        VectorDiferencias obj = new VectorDiferencias();

        System.out.println("Vector A (50 elementos):");
        for (int i = 0; i < 50; i++) {
            System.out.println("A[" + i + "] = " + obj.getElemento(i));
        }

        System.out.println("\nLa mayor diferencia entre elementos consecutivos es: " + obj.mayorDiferencia());
    }
}

Arreglo inicializado con datos: imprimir y obtener mayor

Ejemplo: Cargue un arreglo con los valores x = {1.85, 500.59, 3.56, 7.00, 1.90, 8.7}, imprima verticalmente el arreglo, imprima el mayor elemento. Los elementos se retornan uno a uno al programa principal.

Clase

package paquete;

// Ejemplo de un arreglo inicializado con datos
// Cargue un arreglo con los valores x = {1.85, 500.59, 3.56, 7.00, 1.90, 8.7}
// Imprima verticalmente el arreglo
// Imprima el mayor elemento
// Los elementos se retornan uno a uno al programa principal
public class Arreglo1 {
    private static final float[] x = {1.85f, 500.59f, 3.56f, 7.00f, 1.90f, 8.7f};

    public float mayor() {
        int i;
        float max = x[0];
        for (i = 1; i < 6; i++) {
            if (x[i] > max) {
                max = x[i];
            }
        }
        return max;
    }

    public float mostrarElemento(int i) {
        return x[i];
    }
}

Main

import paquete.Arreglo1;

class Main {
    public static void main(String[] args) {
        Arreglo1 obj = new Arreglo1();
        int i;
        System.out.println("Los elementos del arreglo x son:");
        for (i = 0; i < 6; i++) {
            System.out.println(" x[" + i + "]= " + obj.mostrarElemento(i));
        }
        System.out.println("\nEl elemento mayor es: " + obj.mayor());
    }
}

Arreglo como atributo de clase: asignación y visualización

Clase

package paquete;

public class Arreglo2 {
    private int[] x = new int[10]; // Define el arreglo como atributo de la clase

    public void asignar(int i) {
        x[i] = 3;
    }

    public int mostrarElemento(int i) {
        return x[i];
    }

    public int[] getX() {
        return x;
    }
}

Main

import paquete.Arreglo2;

public class Main {
    public static void main(String[] args) {
        Arreglo2 obj = new Arreglo2();
        int ip, elemento;
        int[] x = obj.getX();

        System.out.println("x contiene = " + x);

        // Imprime horizontalmente todos los elementos del arreglo
        System.out.println("Elementos del arreglo una vez se crea");
        for (ip = 0; ip < 10; ip = ip + 1) {
            elemento = obj.mostrarElemento(ip);
            System.out.print(elemento + "\t");
        }

        // Carga el arreglo, asignándole el número 3 a todos sus elementos
        for (ip = 0; ip < 10; ip = ip + 1)
            obj.asignar(ip);

        // Imprime verticalmente todos los elementos del arreglo
        System.out.println("\nElementos del arreglo después de la carga con el valor de 3");
        for (ip = 0; ip < 10; ip = ip + 1) {
            elemento = x[ip];
            System.out.println(elemento);
        }
    }
}

Arreglo dinámico: asignación por entrada del usuario y visualización

Objetivo: Cargar un arreglo con n elementos, asignar valores desde la entrada estándar, imprimir verticalmente y mostrar la longitud física del arreglo.

Clase

package paquete;

// *************************************************
// Cargue un arreglo con n cantidad de elementos e
// imprima (verticalmente) después de asignarle datos
// imprima cuántos elementos tiene el arreglo
// *************************************************
public class Arreglo3 {
    private double[] x; // Declara el arreglo x
    private int lim;

    public Arreglo3(int lim) {
        this.lim = lim; // constructor
        x = new double[lim]; // Crea el arreglo con límite cantidad de elementos
    }

    public void asignar(double dato, int i) {
        x[i] = dato;
    }

    public double mostrarElemento(int i) {
        return x[i];
    }

    public double[] getX() {
        return x;
    }

    public int getLim() {
        return lim;
    }
}

Main

import paquete.Arreglo3;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int i;
        double dato;
        int limite = 0;
        boolean error;

        do {
            try {
                System.out.println("\n\n\nEntre la cantidad de elementos que necesita:");
                limite = Integer.parseInt(br.readLine());
                if (limite <= 0) {
                    error = true;
                    System.out.println("Error... la cantidad de elementos debe ser positiva y no cero");
                } else
                    error = false;
            } catch (IOException e) {
                System.out.print("\nError... de entrada de datos");
                error = true;
            } catch (NumberFormatException e) {
                System.out.print("\nError... de conversión de datos");
                error = true;
            }
        } while (error);

        Arreglo3 obj = new Arreglo3(limite);

        for (i = 0; i < obj.getLim(); i++) {
            try {
                System.out.println("\nEntre un número de tipo double:");
                dato = Double.parseDouble(br.readLine());
                obj.asignar(dato, i);
            } catch (IOException e) {
                System.out.print("\nError... de entrada de datos");
                i--;
            } catch (NumberFormatException e) {
                System.out.print("\nError... de conversión de datos");
                i--;
            }
        }

        System.out.println("\n\nLos elementos del arreglo después de asignar\n");
        for (i = 0; i < obj.getLim(); i++)
            System.out.println(obj.mostrarElemento(i));

        System.out.println("\n\nLongitud física del arreglo: " + obj.getX().length + " elementos");
    }
}

Se han corregido errores ortográficos, gramática y uso de mayúsculas en las descripciones y comentarios para mejorar la claridad. Los fragmentos de código se conservan funcionales y se han mantenido todos los contenidos originales, respetando las imágenes marcadas como .