Aprende Java con esta recopilación de ejercicios

chatFP

Bienvenidos a la sección de Java de nuestro recopilatorio de ejercicios. Java es un lenguaje de programación versátil y potente, ampliamente utilizado para construir aplicaciones web, móviles y de escritorio. Su capacidad para funcionar en cualquier dispositivo a través de la máquina virtual de Java (JVM) lo convierte en una opción ideal para desarrolladores que buscan crear soluciones robustas y multiplataforma.

En esta sección, exploraremos los fundamentos de Java, desde la sintaxis básica y las estructuras de control hasta conceptos más avanzados como la programación orientada a objetos. Los ejercicios están diseñados para reforzar el aprendizaje teórico con práctica real, permitiéndote aplicar lo que has aprendido en proyectos concretos.

Ya sea que estés dando tus primeros pasos en la programación o buscando ampliar tus conocimientos en Java, esta sección te proporcionará una base sólida para desarrollar tus habilidades en este lenguaje de programación.

Ejercicio 1: "Hola Mundo" en Java

Enunciado: Escribe un programa en Java que imprima "Hola Mundo" en la consola.

Solución:

public class HolaMundo {
    public static void main(String[] args) {
        System.out.println("Hola Mundo");
    }
}

Ejercicio 2: Java - Programa Básico de Calculadora

Enunciado: Escribe un programa en Java que actúe como una calculadora básica. Debe permitir al usuario ingresar dos números y seleccionar una operación (suma, resta, multiplicación, división). Después de realizar la operación, el programa debe mostrar el resultado.

Solución:

import java.util.Scanner;

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

        System.out.print("Ingrese el primer número: ");
        double num1 = scanner.nextDouble();

        System.out.print("Ingrese el segundo número: ");
        double num2 = scanner.nextDouble();

        System.out.print("Ingrese la operación (+, -, *, /): ");
        char operacion = scanner.next().charAt(0);

        double resultado;

        switch (operacion) {
            case '+':
                resultado = num1 + num2;
                break;
            case '-':
                resultado = num1 - num2;
                break;
            case '*':
                resultado = num1 * num2;
                break;
            case '/':
                if (num2 != 0) {
                    resultado = num1 / num2;
                } else {
                    System.out.println("División por cero no permitida.");
                    return;
                }
                break;
            default:
                System.out.println("Operación no reconocida.");
                return;
        }

        System.out.printf("Resultado: %.2f\n", resultado);
    }
}

Ejercicio 3: Cálculo del Factorial

Enunciado: Escribe un programa en Java que calcule el factorial de un número entero introducido por el usuario. El factorial de un número n es el producto de todos los números enteros positivos desde 1 hasta n.

Solución:

import java.util.Scanner;

public class Factorial {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Introduce un número para calcular su factorial: ");
        int numero = scanner.nextInt();
        System.out.println("El factorial de " + numero + " es: " + calcularFactorial(numero));
    }

    public static long calcularFactorial(int n) {
        if (n >= 1) {
            return n * calcularFactorial(n - 1);
        } else {
            return 1;
        }
    }
}

Ejercicio 4: Ordenamiento de un Array

Enunciado: Crea un programa en Java que ordene un array de números enteros en orden ascendente. Puedes implementar cualquier algoritmo de ordenamiento que prefieras (por ejemplo, burbuja, selección, inserción).

Solución (Usando el algoritmo de burbuja):

import java.util.Arrays;

public class OrdenamientoBurbuja {
    public static void main(String[] args) {
        int[] numeros = {5, 2, 8, 3, 1};
        ordenarBurbuja(numeros);
        System.out.println("Array ordenado: " + Arrays.toString(numeros));
    }

    public static void ordenarBurbuja(int[] array) {
        int n = array.length;
        int temp = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 1; j < (n - i); j++) {
                if (array[j - 1] > array[j]) {
                    // Intercambiar elementos
                    temp = array[j - 1];
                    array[j - 1] = array[j];
                    array[j] = temp;
                }
            }
        }
    }
}

Ejercicio 5: Búsqueda Binaria en un Array Ordenado

Enunciado: Implementa un programa en Java que realice la búsqueda binaria en un array de números enteros ordenados. El usuario debe introducir el número que desea buscar, y el programa debe indicar si el número está presente en el array y en qué posición.

Solución:

import java.util.Scanner;

public class BusquedaBinaria {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] numerosOrdenados = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
        System.out.print("Introduce el número a buscar: ");
        int objetivo = scanner.nextInt();
        int resultado = busquedaBinaria(numerosOrdenados, objetivo);
        if (resultado == -1) {
            System.out.println("Número no encontrado.");
        } else {
            System.out.println("Número encontrado en la posición: " + resultado);
        }
    }

    public static int busquedaBinaria(int[] array, int objetivo) {
        int izquierda = 0, derecha = array.length - 1;
        while (izquierda <= derecha) {
            int medio = izquierda + (derecha - izquierda) / 2;

            if (array[medio] == objetivo) {
                return medio;
            }

            if (array[medio] < objetivo) {
                izquierda = medio + 1;
            } else {
                derecha = medio - 1;
            }
        }
        return -1; // Elemento no encontrado
    }
}

Estos ejercicios están pensados para empezar a familiarizarse con la programación en Java, abarcando desde la salida de datos simples hasta la toma de decisiones con estructuras condicionales. Introducen a los estudiantes a conceptos algo más avanzados como la recursividad, algoritmos de ordenamiento y búsqueda, fundamentales en el desarrollo de software eficiente. La práctica con estos problemas ayudará a fortalecer la lógica de programación y el manejo de estructuras de datos en Java.

En la próxima publicación repasaremos ejercicios con clases, colecciones y excepciones.

A medida que avances, incrementaremos la complejidad y te introduciremos a conceptos más avanzados. ¡Feliz codificación!

chatFP

Avanzando en la complejidad, aquí tienes tres ejercicios de Java diseñados para desafiar aún más tu comprensión de conceptos avanzados, incluyendo la programación orientada a objetos, el manejo de excepciones y el uso de colecciones.

Ejercicio 6: Clase CuentaBancaria

Enunciado: Diseña una clase CuentaBancaria que modele el comportamiento de una cuenta bancaria, permitiendo depositar, retirar dinero y consultar el saldo actual. La cuenta no debe permitir retiros que superen el saldo disponible.

Solución:

public class CuentaBancaria {
    private double saldo;

    public CuentaBancaria(double saldoInicial) {
        this.saldo = saldoInicial;
    }

    public void depositar(double cantidad) {
        if (cantidad > 0) {
            saldo += cantidad;
            System.out.println("Depósito exitoso. Saldo actual: " + saldo);
        } else {
            System.out.println("La cantidad a depositar debe ser positiva.");
        }
    }

    public void retirar(double cantidad) {
        if (cantidad <= saldo) {
            saldo -= cantidad;
            System.out.println("Retiro exitoso. Saldo restante: " + saldo);
        } else {
            System.out.println("Fondos insuficientes para realizar el retiro.");
        }
    }

    public void consultarSaldo() {
        System.out.println("Saldo actual: " + saldo);
    }
}

Ejercicio 7: Manejo de Excepciones en Entrada de Datos

Enunciado: Implementa un programa que solicite al usuario ingresar un número entero. Utiliza manejo de excepciones para validar que la entrada es un número entero válido y vuelve a solicitar el número hasta que se ingrese correctamente.

Solución:

import java.util.InputMismatchException;
import java.util.Scanner;

public class EntradaSegura {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        boolean entradaValida = false;
        int numero = 0;

        while (!entradaValida) {
            try {
                System.out.print("Por favor, ingresa un número entero: ");
                numero = scanner.nextInt();
                entradaValida = true;
            } catch (InputMismatchException e) {
                System.out.println("Entrada inválida. Por favor, intenta nuevamente.");
                scanner.next(); // Limpiar el buffer
            }
        }

        System.out.println("Número ingresado correctamente: " + numero);
    }
}

Ejercicio 8: Uso de Colecciones para Filtrar Datos

Enunciado: Dada una lista de cadenas que representan nombres de ciudades, escribe un programa que elimine los nombres duplicados y los imprima en orden alfabético.

Solución:

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class FiltroCiudades {
    public static void main(String[] args) {
        List<String> ciudades = new ArrayList<>();
        Collections.addAll(ciudades, "Madrid", "Granada", "Valencia", "Madrid", "Granada");

        Set<String> ciudadesSinDuplicados = new HashSet<>(ciudades);
        List<String> listaOrdenada = new ArrayList<>(ciudadesSinDuplicados);
        Collections.sort(listaOrdenada);

        System.out.println("Ciudades sin duplicados y en orden alfabético:");
        for (String ciudad : listaOrdenada) {
            System.out.println(ciudad);
        }
    }
}

Estos ejercicios abarcan conceptos intermedios y avanzados de Java, promoviendo una comprensión más profunda de la programación orientada a objetos, el manejo de excepciones para crear programas más robustos y seguros, y el uso eficiente de colecciones para manejar datos de manera efectiva. La práctica con estos problemas te preparará para enfrentar desafíos de programación más complejos.