50 ejercicios progresivos de Java

De cero a pequeños programas de consola, con soluciones

Guía de práctica incremental: cada ejercicio introduce o refuerza un concepto de Java y, siempre que es posible, reutiliza lo
aprendido en ejercicios anteriores.
Recomendación: intenta resolver cada ejercicio antes de mirar la solución. Puedes compilar con javac [Link] y ejecutar
con java Main.

Parte I - Enunciados
Ejercicio 1. Hola mundo
Crea una clase Main que imprima por consola: Hola, mundo.
Requisitos: Usa public static void main(String[] args).

Ejercicio 2. Dos líneas

Partiendo del ejercicio anterior, imprime dos líneas: una bienvenida y tu nombre.
Requisitos: Usa dos llamadas a [Link].

Ejercicio 3. Variables básicas

Declara una variable String nombre y una int edad. Imprime una frase con ambas.
Requisitos: Repasa println y concatenación.

Ejercicio 4. Suma de enteros

Declara dos enteros, calcula la suma e imprime el resultado con un mensaje.
Requisitos: Reutiliza variables y concatenación.

Ejercicio 5. Área de un rectángulo

Calcula el área de un rectángulo con base y altura enteras.
Requisitos: Usa una variable para guardar el resultado.

Ejercicio 6. Decimales
Calcula el precio final de un producto con IVA del 21%.
Requisitos: Usa double y concatena el resultado.

Ejercicio 7. Leer texto

Pide el nombre al usuario y saluda usando ese nombre.
Requisitos: Usa Scanner. Cierra el Scanner al final.

Ejercicio 8. Leer números

Pide dos números enteros y muestra su suma.
Requisitos: Reutiliza Scanner y variables.

Ejercicio 9. Conversor de temperatura

Pide grados Celsius y conviértelos a Fahrenheit.
Requisitos: Fórmula: F = C * 9 / 5 + 32.

Ejercicio 10. Mayor de edad

Pide una edad e indica si la persona es mayor de edad.
Requisitos: Usa if/else.

Ejercicio 11. Número positivo

Página 1
Pide un número e indica si es positivo, negativo o cero.
Requisitos: Usa if, else if y else.

Ejercicio 12. Par o impar

Pide un entero y muestra si es par o impar.
Requisitos: Usa el operador %.

Ejercicio 13. Calculadora simple

Pide dos números y una operación (+, -, *, /). Muestra el resultado.
Requisitos: Usa switch. Controla la división por cero.

Ejercicio 14. Contar hasta N

Pide un número N y muestra los números del 1 al N.
Requisitos: Usa bucle for.

Ejercicio 15. Suma acumulada

Pide N y calcula la suma de 1 a N.
Requisitos: Repasa for y acumuladores.

Ejercicio 16. Tabla de multiplicar

Pide un número y muestra su tabla del 1 al 10.
Requisitos: Usa for y multiplicación.

Ejercicio 17. Validar entrada

Pide números hasta que el usuario introduzca un número positivo.
Requisitos: Usa while.

Ejercicio 18. Adivina el número

Define un número secreto y pide intentos hasta acertar, indicando mayor o menor.
Requisitos: Usa while, if y Scanner.

Ejercicio 19. Factorial

Pide un número y calcula su factorial con un bucle.
Requisitos: Usa long para evitar desbordamientos pequeños.

Ejercicio 20. Primo

Pide un número e indica si es primo.
Requisitos: Reutiliza bucles y condicionales.

Ejercicio 21. Método saludar

Crea un método saludar(String nombre) que imprima un saludo.
Requisitos: Llama al método desde main.

Ejercicio 22. Método sumar

Crea un método sumar(int a, int b) que devuelva la suma.
Requisitos: Devuelve un valor con return.

Ejercicio 23. Método esPar

Crea un método esPar(int n) y úsalo para validar varios números.
Requisitos: Repasa boolean y operador %.

Ejercicio 24. Array de enteros

Crea un array con cinco números y muestra todos sus elementos.
Requisitos: Usa for con índices.

Página 2
Ejercicio 25. Suma de array
Calcula la suma y la media de un array de enteros.
Requisitos: Reutiliza acumuladores.

Ejercicio 26. Mayor en array

Encuentra el valor mayor de un array.
Requisitos: Inicializa el mayor con el primer elemento.

Ejercicio 27. Buscar en array

Pide un número y di si está en un array predefinido.
Requisitos: Usa boolean encontrado.

Ejercicio 28. Invertir array

Muestra los elementos de un array en orden inverso.
Requisitos: Usa índices descendentes.

Ejercicio 29. Contar vocales

Pide una frase y cuenta cuántas vocales contiene.
Requisitos: Usa String, charAt y toLowerCase.

Ejercicio 30. Palíndromo

Pide una palabra e indica si se lee igual al revés.
Requisitos: Reutiliza bucles y String.

Ejercicio 31. ArrayList básico

Crea un ArrayList de nombres, añade tres y muéstralos.
Requisitos: Importa [Link].

Ejercicio 32. Lista de tareas

Permite añadir tareas a un ArrayList hasta escribir fin, y luego muéstralas numeradas.
Requisitos: Usa Scanner, while y ArrayList.

Ejercicio 33. Eliminar de lista

Pide un nombre y elimínalo de un ArrayList si existe.
Requisitos: Usa remove y contains.

Ejercicio 34. Ordenar números

Guarda números en un ArrayList, ordénalos y muéstralos.
Requisitos: Usa [Link].

Ejercicio 35. Matriz 3x3

Crea una matriz 3x3 de enteros y muestra su contenido en forma de tabla.
Requisitos: Usa bucles anidados.

Ejercicio 36. Suma de matriz

Calcula la suma total de una matriz.
Requisitos: Reutiliza bucles anidados y acumuladores.

Ejercicio 37. Menú por consola

Crea un menú con opciones: saludar, sumar dos números y salir.
Requisitos: Usa do while y switch.

Ejercicio 38. Validar contraseña

Página 3
Pide una contraseña hasta que coincida con una constante. Limita a 3 intentos.
Requisitos: Usa while, contador y [Link].

Ejercicio 39. Método de media

Crea un método media(int[] nums) que devuelva la media.
Requisitos: Reutiliza arrays, bucles y return.

Ejercicio 40. Método filtrar pares

Crea un método que reciba un array y devuelva un ArrayList con los pares.
Requisitos: Combina arrays, ArrayList y esPar.

Ejercicio 41. Frecuencia de letras

Pide una palabra y cuenta cuántas veces aparece cada letra.
Requisitos: Usa HashMap<Character, Integer>.

Ejercicio 42. Control de errores

Pide un entero. Si el usuario escribe algo no numérico, muestra un mensaje de error.
Requisitos: Usa try/catch.

Ejercicio 43. División segura

Crea un método dividir que lance ArithmeticException si el divisor es cero. Captura el error en main.
Requisitos: Repasa métodos, excepciones y condicionales.

Ejercicio 44. Escribir archivo

Crea un archivo [Link] y escribe tres líneas.
Requisitos: Usa FileWriter y try-with-resources.

Ejercicio 45. Leer archivo

Lee el archivo [Link] y muestra su contenido.
Requisitos: Usa BufferedReader.

Ejercicio 46. Copiar pares a archivo

Dado un array de enteros, escribe en [Link] solo los números pares.
Requisitos: Combina arrays, método esPar y FileWriter.

Ejercicio 47. Mini agenda

Crea una agenda con HashMap<String,String>: nombre -> teléfono. Permite buscar por nombre.
Requisitos: Usa Scanner, HashMap y containsKey.

Ejercicio 48. Notas de alumnos

Guarda alumnos y notas en un HashMap. Muestra la media y los aprobados.
Requisitos: Combina HashMap, bucles y condicionales.

Ejercicio 49. Mini aplicación final

Crea una aplicación de consola para gestionar tareas: añadir, listar, eliminar y salir.
Requisitos: Integra menú, ArrayList, Scanner, switch y validaciones básicas.

Ejercicio 50. Inventario con menú

Amplía la mini aplicación final para gestionar un inventario: añadir producto, listar productos y calcular el valor total.
Requisitos: Integra menú, ArrayList, métodos, validaciones y acumuladores.

Página 4
Parte II - Soluciones
Solución 1. Hola mundo
public class Main {
public static void main(String[] args) {
[Link]("Hola, mundo");
}
}

Solución 2. Dos líneas

public class Main {
public static void main(String[] args) {
[Link]("Bienvenido a Java");
[Link]("Jacobo");
}
}

Solución 3. Variables básicas

public class Main {
public static void main(String[] args) {
String nombre = "Ana";
int edad = 25;
[Link](nombre + " tiene " + edad + " años");
}
}

Solución 4. Suma de enteros

public class Main {
public static void main(String[] args) {
int a = 8, b = 12;
int suma = a + b;
[Link]("La suma es " + suma);
}
}

Solución 5. Área de un rectángulo

public class Main {
public static void main(String[] args) {
int base = 7, altura = 4;
int area = base * altura;
[Link]("Área: " + area);
}
}

Solución 6. Decimales
public class Main {
public static void main(String[] args) {
double precio = 100.0;
double iva = 0.21;
double total = precio + precio * iva;
[Link]("Precio final: " + total);
}
}

Solución 7. Leer texto

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
[Link]("Nombre: ");
String nombre = [Link]();
[Link]("Hola, " + nombre);
[Link]();
}
}

Solución 8. Leer números

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
[Link]("Primer número: ");
int a = [Link]();

Página 5
 [Link]("Segundo número: ");
int b = [Link]();
[Link]("Suma: " + (a + b));
[Link]();
}
}

Solución 9. Conversor de temperatura

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
[Link]("Celsius: ");
double c = [Link]();
double f = c * 9 / 5 + 32;
[Link]("Fahrenheit: " + f);
[Link]();
}
}

Solución 10. Mayor de edad

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int edad = [Link]();
if (edad >= 18) {
[Link]("Mayor de edad");
} else {
[Link]("Menor de edad");
}
[Link]();
}
}

Solución 11. Número positivo

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int n = [Link]();
if (n > 0) [Link]("Positivo");
else if (n < 0) [Link]("Negativo");
else [Link]("Cero");
[Link]();
}
}

Solución 12. Par o impar

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int n = [Link]();
[Link](n % 2 == 0 ? "Par" : "Impar");
[Link]();
}
}

Solución 13. Calculadora simple

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
double a = [Link]();
double b = [Link]();
char op = [Link]().charAt(0);
switch (op) {
case '+': [Link](a + b); break;
case '-': [Link](a - b); break;
case '*': [Link](a * b); break;
case '/':
if (b != 0) [Link](a / b);

Página 6
 else [Link]("No se puede dividir por cero");
break;
default: [Link]("Operación no válida");
}
[Link]();
}
}

Solución 14. Contar hasta N

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int n = [Link]();
for (int i = 1; i <= n; i++) {
[Link](i);
}
[Link]();
}
}

Solución 15. Suma acumulada

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int n = [Link]();
int suma = 0;
for (int i = 1; i <= n; i++) suma += i;
[Link]("Suma: " + suma);
[Link]();
}
}

Solución 16. Tabla de multiplicar

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int n = [Link]();
for (int i = 1; i <= 10; i++) {
[Link](n + " x " + i + " = " + (n * i));
}
[Link]();
}
}

Solución 17. Validar entrada

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int n;
do {
[Link]("Introduce un positivo: ");
n = [Link]();
} while (n <= 0);
[Link]("Correcto: " + n);
[Link]();
}
}

Solución 18. Adivina el número

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int secreto = 7;
int intento = 0;
while (intento != secreto) {
[Link]("Intento: ");
intento = [Link]();
if (intento < secreto) [Link]("Mayor");

Página 7
 else if (intento > secreto) [Link]("Menor");
}
[Link]("Acertaste");
[Link]();
}
}

Solución 19. Factorial

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int n = [Link]();
long factorial = 1;
for (int i = 2; i <= n; i++) factorial *= i;
[Link]("Factorial: " + factorial);
[Link]();
}
}

Solución 20. Primo

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int n = [Link]();
boolean primo = n > 1;
for (int i = 2; i <= [Link](n); i++) {
if (n % i == 0) { primo = false; break; }
}
[Link](primo ? "Primo" : "No primo");
[Link]();
}
}

Solución 21. Método saludar

public class Main {
static void saludar(String nombre) {
[Link]("Hola, " + nombre);
}
public static void main(String[] args) {
saludar("Ana");
}
}

Solución 22. Método sumar

public class Main {
static int sumar(int a, int b) {
return a + b;
}
public static void main(String[] args) {
[Link](sumar(4, 6));
}
}

Solución 23. Método esPar

public class Main {
static boolean esPar(int n) { return n % 2 == 0; }
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
[Link](i + ": " + esPar(i));
}
}
}

Solución 24. Array de enteros

public class Main {
public static void main(String[] args) {
int[] nums = {3, 6, 9, 12, 15};
for (int i = 0; i < [Link]; i++) {
[Link](nums[i]);
}
}
}

Página 8
Solución 25. Suma de array
public class Main {
public static void main(String[] args) {
int[] nums = {4, 8, 10, 2};
int suma = 0;
for (int n : nums) suma += n;
double media = (double) suma / [Link];
[Link]("Suma: " + suma + ", media: " + media);
}
}

Solución 26. Mayor en array

public class Main {
public static void main(String[] args) {
int[] nums = {4, 18, 2, 31, 9};
int mayor = nums[0];
for (int n : nums) if (n > mayor) mayor = n;
[Link]("Mayor: " + mayor);
}
}

Solución 27. Buscar en array

import [Link];

public class Main {

public static void main(String[] args) {
int[] nums = {5, 10, 15, 20};
Scanner sc = new Scanner([Link]);
int buscado = [Link]();
boolean encontrado = false;
for (int n : nums) if (n == buscado) encontrado = true;
[Link](encontrado ? "Encontrado" : "No encontrado");
[Link]();
}
}

Solución 28. Invertir array

public class Main {
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4, 5};
for (int i = [Link] - 1; i >= 0; i--) {
[Link](nums[i]);
}
}
}

Solución 29. Contar vocales

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
String frase = [Link]().toLowerCase();
int contador = 0;
for (int i = 0; i < [Link](); i++) {
char c = [Link](i);
if ("aeiou".indexOf(c) >= 0) contador++;
}
[Link]("Vocales: " + contador);
[Link]();
}
}

Solución 30. Palíndromo

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
String palabra = [Link]().toLowerCase();
String invertida = "";
for (int i = [Link]() - 1; i >= 0; i--) invertida += [Link](i);
[Link]([Link](invertida) ? "Palíndromo" : "No");
[Link]();
}
}

Página 9
Solución 31. ArrayList básico
import [Link];

public class Main {

public static void main(String[] args) {
ArrayList<String> nombres = new ArrayList<>();
[Link]("Ana"); [Link]("Luis"); [Link]("Eva");
for (String nombre : nombres) [Link](nombre);
}
}

Solución 32. Lista de tareas

import [Link].*;

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
ArrayList<String> tareas = new ArrayList<>();
String entrada;
while (true) {
entrada = [Link]();
if ([Link]("fin")) break;
[Link](entrada);
}
for (int i = 0; i < [Link](); i++) {
[Link]((i + 1) + ". " + [Link](i));
}
[Link]();
}
}

Solución 33. Eliminar de lista

import [Link].*;

public class Main {

public static void main(String[] args) {
ArrayList<String> nombres = new ArrayList<>([Link]("Ana", "Luis", "Eva"));
Scanner sc = new Scanner([Link]);
String nombre = [Link]();
if ([Link](nombre)) [Link]("Eliminado");
else [Link]("No estaba");
[Link](nombres);
[Link]();
}
}

Solución 34. Ordenar números

import [Link].*;

public class Main {

public static void main(String[] args) {
ArrayList<Integer> nums = new ArrayList<>([Link](9, 2, 7, 1));
[Link](nums);
[Link](nums);
}
}

Solución 35. Matriz 3x3

public class Main {
public static void main(String[] args) {
int[][] m = {{1,2,3},{4,5,6},{7,8,9}};
for (int i = 0; i < [Link]; i++) {
for (int j = 0; j < m[i].length; j++) {
[Link](m[i][j] + " ");
}
[Link]();
}
}
}

Solución 36. Suma de matriz

public class Main {
public static void main(String[] args) {
int[][] m = {{1,2,3},{4,5,6}};
int suma = 0;
for (int[] fila : m) for (int n : fila) suma += n;
[Link]("Suma: " + suma);

Página 10
 }
}

Solución 37. Menú por consola

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int opcion;
do {
[Link]("1 Saludar | 2 Sumar | 0 Salir");
opcion = [Link]();
switch (opcion) {
case 1 -> [Link]("Hola");
case 2 -> {
int a = [Link](); int b = [Link]();
[Link](a + b);
}
case 0 -> [Link]("Adiós");
default -> [Link]("Opción no válida");
}
} while (opcion != 0);
[Link]();
}
}

Solución 38. Validar contraseña

import [Link];

public class Main {

public static void main(String[] args) {
final String CLAVE = "java123";
Scanner sc = new Scanner([Link]);
int intentos = 0;
boolean ok = false;
while (intentos < 3 && !ok) {
String clave = [Link]();
ok = [Link](CLAVE);
intentos++;
}
[Link](ok ? "Acceso concedido" : "Bloqueado");
[Link]();
}
}

Solución 39. Método de media

public class Main {
static double media(int[] nums) {
int suma = 0;
for (int n : nums) suma += n;
return (double) suma / [Link];
}
public static void main(String[] args) {
int[] datos = {5, 7, 9};
[Link](media(datos));
}
}

Solución 40. Método filtrar pares

import [Link].*;

public class Main {

static boolean esPar(int n) { return n % 2 == 0; }
static ArrayList<Integer> pares(int[] nums) {
ArrayList<Integer> res = new ArrayList<>();
for (int n : nums) if (esPar(n)) [Link](n);
return res;
}
public static void main(String[] args) {
[Link](pares(new int[]{1,2,3,4,5,6}));
}
}

Solución 41. Frecuencia de letras

import [Link].*;

public class Main {

Página 11
 public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
String palabra = [Link]().toLowerCase();
HashMap<Character, Integer> mapa = new HashMap<>();
for (char c : [Link]()) {
if ([Link](c)) [Link](c, [Link](c, 0) + 1);
}
[Link](mapa);
[Link]();
}
}

Solución 42. Control de errores

import [Link];

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
try {
int n = [Link]([Link]());
[Link]("Número: " + n);
} catch (NumberFormatException e) {
[Link]("Entrada no válida");
}
[Link]();
}
}

Solución 43. División segura

public class Main {
static int dividir(int a, int b) {
if (b == 0) throw new ArithmeticException("Divisor cero");
return a / b;
}
public static void main(String[] args) {
try {
[Link](dividir(10, 0));
} catch (ArithmeticException e) {
[Link]("Error: " + [Link]());
}
}
}

Solución 44. Escribir archivo

import [Link];
import [Link];

public class Main {

public static void main(String[] args) {
try (FileWriter fw = new FileWriter("[Link]")) {
[Link]("Línea 1\n");
[Link]("Línea 2\n");
[Link]("Línea 3\n");
} catch (IOException e) {
[Link]("Error: " + [Link]());
}
}
}

Solución 45. Leer archivo

import [Link].*;

public class Main {

public static void main(String[] args) {
try (BufferedReader br = new BufferedReader(new FileReader("[Link]"))) {
String linea;
while ((linea = [Link]()) != null) {
[Link](linea);
}
} catch (IOException e) {
[Link]("Error: " + [Link]());
}
}
}

Solución 46. Copiar pares a archivo

import [Link].*;

public class Main {

Página 12
 static boolean esPar(int n) { return n % 2 == 0; }
public static void main(String[] args) {
int[] nums = {1,2,3,4,5,6};
try (FileWriter fw = new FileWriter("[Link]")) {
for (int n : nums) if (esPar(n)) [Link](n + "\n");
} catch (IOException e) {
[Link]([Link]());
}
}
}

Solución 47. Mini agenda

import [Link].*;

public class Main {

public static void main(String[] args) {
HashMap<String, String> agenda = new HashMap<>();
[Link]("Ana", "600111222");
[Link]("Luis", "600333444");
Scanner sc = new Scanner([Link]);
String nombre = [Link]();
if ([Link](nombre)) [Link]([Link](nombre));
else [Link]("No encontrado");
[Link]();
}
}

Solución 48. Notas de alumnos

import [Link].*;

public class Main {

public static void main(String[] args) {
HashMap<String, Double> notas = new HashMap<>();
[Link]("Ana", 8.5); [Link]("Luis", 4.0); [Link]("Eva", 6.5);
double suma = 0;
for (double nota : [Link]()) suma += nota;
[Link]("Media: " + suma / [Link]());
for (String alumno : [Link]()) {
if ([Link](alumno) >= 5) [Link]("Aprobado: " + alumno);
}
}
}

Solución 49. Mini aplicación final

import [Link].*;

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
ArrayList<String> tareas = new ArrayList<>();
int op;
do {
[Link]("1 Añadir | 2 Listar | 3 Eliminar | 0 Salir");
op = [Link]([Link]());
switch (op) {
case 1 -> {
[Link]("Tarea: ");
[Link]([Link]());
}
case 2 -> {
for (int i = 0; i < [Link](); i++)
[Link]((i + 1) + ". " + [Link](i));
}
case 3 -> {
[Link]("Número: ");
int pos = [Link]([Link]()) - 1;
if (pos >= 0 && pos < [Link]()) [Link](pos);
else [Link]("Posición no válida");
}
}
} while (op != 0);
[Link]();
}
}

Solución 50. Inventario con menú

import [Link].*;

public class Main {

Página 13
 static double valorTotal(ArrayList<Double> precios) {
double total = 0;
for (double p : precios) total += p;
return total;
}
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
ArrayList<String> nombres = new ArrayList<>();
ArrayList<Double> precios = new ArrayList<>();
int op;
do {
[Link]("1 Añadir | 2 Listar | 3 Total | 0 Salir");
op = [Link]([Link]());
switch (op) {
case 1 -> {
[Link]("Nombre: " );
[Link]([Link]());
[Link]("Precio: " );
[Link]([Link]([Link]()));
}
case 2 -> {
for (int i = 0; i < [Link](); i++)
[Link]([Link](i) + " - " + [Link](i));
}
case 3 -> [Link]("Total: " + valorTotal(precios));
}
} while (op != 0);
[Link]();
}
}

Página 14