Carlos Fernández García

Ejercicio 1

Desarrolla un programa en Java que lea y muestre el contenido de un archivo de texto línea por línea utilizando un bucle while

Ejercicio 2

Escribe un programa en Java que lea un archivo de texto llamado 'datos.txt' que contiene una lista de nombres, uno por línea. El programa debe leer el archivo, almacenar los nombres en una lista y luego imprimirlos en orden inverso, es decir, desde el último nombre hasta el primero

Ejercicio 3

Desarrolla un programa en Java que lea un archivo de texto llamado 'numeros.txt' que contiene una lista de números enteros separados por comas. El programa debe calcular la suma de todos los números en el archivo y mostrar el resultado.

Ejercicio 4

Desarrolla un programa en Java que lea un archivo de texto llamado 'ventas.txt' que contiene una lista de ventas realizadas por un comercio, donde cada línea del archivo tiene el formato "producto,cantidad,precio_unitario". El programa debe calcular el total de ventas (cantidad * precio_unitario) para cada producto y mostrar el resultado en la consola.

package ficheros;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;

public class Ejercicio4 {

	public static void main(String[] args) {
		ArrayList<String> productos=new ArrayList<String>();
		ArrayList<Integer> cantidades=new ArrayList<Integer>();
		ArrayList<Double> precios=new ArrayList<Double>();
		
		
		try {
			BufferedReader br=new BufferedReader(new FileReader("ventas.txt"));
			try {
				String linea=br.readLine();
				
				while(linea!=null) {
					String[] datosLinea=new String[3];
					datosLinea=linea.split(",");
					if(datosLinea.length==3) {						
						productos.add(datosLinea[0]);
						try {
							cantidades.add(Integer.parseInt(datosLinea[1]));
						}catch (NumberFormatException e) {
							System.err.println("Cantidad no valida se agregara 0");
							cantidades.add(0);
						}
						try {
							precios.add(Double.parseDouble(datosLinea[2]));
						}catch (NumberFormatException e) {
							System.err.println("Precio no valido se agregara 0.0");
							precios.add(0.0);
						}
						linea=br.readLine();
					}else {
						System.err.println("Linea no valida");
					}
						
					
					
				}
				br.close();
				Iterator<String> itProductos=productos.iterator();
				Iterator<Integer> itCantidades=cantidades.iterator();
				Iterator<Double> itPrecios=precios.iterator();
				while(itProductos.hasNext()) {
					String producto=itProductos.next();
					int cantidad=itCantidades.next();
					double precio=itPrecios.next();
					System.out.println("Producto: "+ producto +" Cantidad: " + cantidad + " Precio Unidad: " + precio +"€ Total: " + String.format("%.2f",cantidad*precio)+"€");
				}
				
			} catch (IOException e) {

				System.err.println("Error de lectura del archivo");
			}
			
		} catch (FileNotFoundException e) {
			System.err.println("Archivo no ecnontrado");
		}

	}

}

Ejercicio 5

Desarrolla un programa en Java que lea un archivo de texto llamado 'empleados.txt' que contiene una lista de empleados con el siguiente formato en cada línea: "nombre,edad,salario". El programa debe calcular el promedio de salario de todos los empleados y mostrar el resultado en la consola.

package ficheros;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;

public class Ejercicio5 {

	public static void main(String[] args) {
		ArrayList<Empleado> empleados=new ArrayList<Empleado>();
		
		
		try {
			BufferedReader br=new BufferedReader(new FileReader("empleados.txt"));
			try {
				String linea=br.readLine();
				while(linea!=null) {
					String[] lineasDatos=new String[3];
					lineasDatos=linea.split(",");
					Empleado emple=new Empleado(lineasDatos[0],Integer.parseInt(lineasDatos[1]),Double.parseDouble(lineasDatos[2]));
					empleados.add(emple);
					linea=br.readLine();
				}
				br.close();
				Iterator<Empleado> it=empleados.iterator();
				double suma=0;
				while(it.hasNext()) {
					Empleado e=it.next();
					suma+=e.getSalario();

				}
				
				System.out.println("El sueldo medio del empleado es: " + String.format("%.2f", suma/empleados.size()));
			} catch (IOException e) {
				System.err.println("Error delectura del archivo empleados");
			}
			
		} catch (FileNotFoundException e) {
			
			System.err.println("Archivo no encontrado");
		}

	}

}

class Empleado{
	private String nombre;
	private int edad;
	private double salario;
	public Empleado(String nombre, int edad, double salario) {
		super();
		this.nombre = nombre;
		this.edad = edad;
		this.salario = salario;
	}
	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}
	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
	/**
	 * @return the edad
	 */
	public int getEdad() {
		return edad;
	}
	/**
	 * @param edad the edad to set
	 */
	public void setEdad(int edad) {
		this.edad = edad;
	}
	/**
	 * @return the salario
	 */
	public double getSalario() {
		return salario;
	}
	/**
	 * @param salario the salario to set
	 */
	public void setSalario(double salario) {
		this.salario = salario;
	}
	
	
}

Ejercicio 6

Desarrolla un programa en Java que lea un archivo de texto llamado 'productos.txt' que contiene una lista de productos con el siguiente formato en cada línea: "nombre_producto,precio_unitario,cantidad_disponible". El programa debe calcular el valor total del inventario (precio_unitario * cantidad_disponible) para cada producto y mostrar el resultado en la consola.

package ficheros;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;

public class Ejercicio6 {

	public static void main(String[] args) {
		ArrayList<Producto> productos=new ArrayList<Producto>();
		
		try {
			BufferedReader br =new BufferedReader(new FileReader("productos.txt"));
			try {
				String linea=br.readLine();
				while(linea!=null) {
					String[] lineaDatos=new String[3];
					lineaDatos=linea.split(",");
					Producto producto=new Producto(lineaDatos[0],Double.parseDouble(lineaDatos[1]),Integer.parseInt(lineaDatos[2]));
					productos.add(producto);
					linea=br.readLine();
				}
				br.close();
				
				Producto producto=new Producto();
				producto.sumarInventario(productos);
				
			} catch (IOException e) {
				System.err.println("Error de lectura del archivo");
			}
		} catch (FileNotFoundException e) {
			System.err.println("Archivo no encontrado");
		}

	}

}

class Producto{
	private String nombre;
	private int cantidad;
	private double precio;
	
	public Producto(String nombre,  double precio ,int cantidad) {

		this.nombre = nombre;
		this.cantidad = cantidad;
		this.precio = precio;
	}
	
	

	public Producto() {
		
	}



	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}

	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	/**
	 * @return the cantidad
	 */
	public int getCantidad() {
		return cantidad;
	}

	/**
	 * @param cantidad the cantidad to set
	 */
	public void setCantidad(int cantidad) {
		this.cantidad = cantidad;
	}

	/**
	 * @return the precio
	 */
	public double getPrecio() {
		return precio;
	}

	/**
	 * @param precio the precio to set
	 */
	public void setPrecio(double precio) {
		this.precio = precio;
	}
	
	public void sumarInventario(ArrayList<Producto> productos) {
		Iterator<Producto> it=productos.iterator();
		double total=0;
		
		while(it.hasNext()) {
			Producto pro=it.next();
			double subTotal=0;
			subTotal=pro.getPrecio()*pro.getCantidad();
			total+=subTotal;
		}
		System.out.println("La suma de todo el inventario asciende: " + String.format("%.2f", total)+"€");
	}
	
}

Ejercicio 7

Escribe un programa en Java que solicite al usuario que ingrese una lista de nombres separados por comas. Luego, el programa debe escribir estos nombres en un archivo de texto llamado "nombres.txt", uno por línea. Una vez que se hayan ingresado todos los nombres y se hayan guardado en el archivo, el programa debe mostrar un mensaje indicando que la operación se realizó correctamente.

Ejercicio 8

Escribe un programa en Java que solicite al usuario que ingrese una lista de números enteros separados por espacios. Luego, el programa debe escribir estos números en un archivo de texto llamado 'numeros.txt', uno por línea. Una vez que se hayan ingresado todos los números y se hayan guardado en el archivo, el programa debe mostrar un mensaje indicando que la operación se realizó correctamente.

Ejercicio 9

* * @return the nombre

package ficheros;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;

public class Ejercicio9 {

	public static void main(String[] args) {
		ArrayList<Emplead> empleados=new ArrayList<Emplead>();
		
		
		try {
			BufferedReader br=new BufferedReader(new FileReader("empleados.csv"));
			try {
				String linea=br.readLine();
				linea=br.readLine();
				while(linea!=null) {
					String[] lineasDatos=new String[3];
					lineasDatos=linea.split(",");
					Emplead emple=new Emplead(lineasDatos[0],Integer.parseInt(lineasDatos[1]),Double.parseDouble(lineasDatos[2]));
					empleados.add(emple);
					linea=br.readLine();
				}
				br.close();
				Iterator<Emplead> it=empleados.iterator();
				double suma=0;
				while(it.hasNext()) {
					Emplead e=it.next();
					suma+=e.getSalario();

				}
				
				System.out.println("El sueldo medio del empleado es: " + String.format("%.2f", suma/empleados.size()));
			} catch (IOException e) {
				System.err.println("Error delectura del archivo empleados");
			}
			
		} catch (FileNotFoundException e) {
			
			System.err.println("Archivo no encontrado");
		}

	}

}

class Emplead{
	private String nombre;
	private int edad;
	private double salario;
	public Emplead(String nombre, int edad, double salario) {
		
		this.nombre = nombre;
		this.edad = edad;
		this.salario = salario;
	}
	
	public String getNombre() {
		return nombre;
	}
	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
	/**
	 * @return the edad
	 */
	public int getEdad() {
		return edad;
	}
	/**
	 * @param edad the edad to set
	 */
	public void setEdad(int edad) {
		this.edad = edad;
	}
	/**
	 * @return the salario
	 */
	public double getSalario() {
		return salario;
	}
	/**
	 * @param salario the salario to set
	 */
	public void setSalario(double salario) {
		this.salario = salario;
	}
	
	
}

Ejercicio 10

Desarrolla un programa en Java que lea un archivo txt llamado "informe.txt" que contiene un informe de ventas trimestrales. El programa debe extraer la información relevante del informe, como el nombre del producto, la cantidad vendida y el precio unitario, y luego calcular el total de ventas para cada producto. Finalmente, debe mostrar el total de ventas por producto en la consola. Zanahorias | 150 | 10.500 Manzanas | 200 | 12.000 Melocotones | 100 | 7.500 Peras | 75 | 5.250


package ficheros;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;

public class Ejercicio10 {

    public static void main(String[] args) {
        ArrayList<Product> productos = new ArrayList<Product>();

        try {
            BufferedReader br = new BufferedReader(new FileReader("informe.txt"));
            try {
                String linea = br.readLine();
                linea = br.readLine(); // Saltar la primera línea, ya que parece ser la cabecera

                while (linea != null) {
                    String[] lineaDatos = linea.split("\\|");
                    String nombre = lineaDatos[0].strip();
                    int cantidad = Integer.parseInt(lineaDatos[1].strip());
                    double precio = Double.parseDouble(lineaDatos[2].strip());
                    Product producto = new Product(nombre, cantidad, precio);
                    productos.add(producto);
                    linea = br.readLine();
                }
                br.close();

                for (Product producto : productos) {
                    double totalPorProducto = producto.getPrecio() * producto.getCantidad();
                    System.out.println(producto.getNombre() + " | " + producto.getCantidad() + " | " + String.format("%.2f", totalPorProducto));
                }

            } catch (IOException e) {
                System.err.println("Error de lectura del archivo");
            }
        } catch (FileNotFoundException e) {
            System.err.println("Archivo no encontrado");
        }

    }

}

class Product {
    private String nombre;
    private int cantidad;
    private double precio;

    public Product(String nombre, int cantidad, double precio) {
        this.nombre = nombre;
        this.cantidad = cantidad;
        this.precio = precio;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public int getCantidad() {
        return cantidad;
    }

    public void setCantidad(int cantidad) {
        this.cantidad = cantidad;
    }

    public double getPrecio() {
        return precio;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }
}

Ejercicio 11

Crea un programa en Java que permita guardar y leer nombres desde un fichero de texto. Requisitos: Pide al usuario que introduzca 3 nombres por teclado. Guarda esos nombres en un fichero llamado nombres.txt (uno por línea). Cierra el fichero correctamente después de escribir. Después, vuelve a abrir el fichero en modo lectura. Muestra por pantalla todos los nombres guardados. Maneja posibles errores de fichero con try-catch.

package ficheros;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class Ejercicio11 {

	public static void main(String[] args) {

		// Variable temporal para guardar cada nombre introducido
		String nombre = "";

		// Array donde almacenaremos los 3 nombres antes de escribirlos en el fichero
		String[] nombres = new String[3];

		// Contador para saber cuántos nombres válidos llevamos
		int numNombres = 0;

		// try-with-resources: el Scanner se cerrará automáticamente al salir del bloque
		try (Scanner in = new Scanner(System.in)) {

			// Bucle que se repite hasta tener 3 nombres válidos
			do {
				System.out.println("Introduce el nombre numero " + (numNombres + 1) + ":");
				nombre = in.nextLine();

				// Validamos que no esté vacío
				if (nombre.isBlank()) {
					System.out.println("El nombre no puede quedar en blanco.");
				} else {
					// Guardamos el nombre en el array y aumentamos el contador
					nombres[numNombres++] = nombre;
				}

			} while (numNombres < 3);

			// ESCRITURA EN FICHERO
			// try-with-resources: el BufferedWriter se cerrará automáticamente
			try (BufferedWriter bw = new BufferedWriter(new FileWriter("nombres.txt"))) {

				// Recorremos el array y escribimos cada nombre en una línea
				for (String n : nombres) {
					bw.write(n);   // Escribe el nombre
					bw.newLine();  // Salto de línea
				}

			} catch (IOException e) {
				// Captura de errores al escribir en el fichero
				e.printStackTrace();
			}

			// LECTURA DEL FICHERO
			// try-with-resources para cerrar automáticamente el BufferedReader
			try (BufferedReader br = new BufferedReader(new FileReader("nombres.txt"))) {

				String linea;

				System.out.println("Contenido del fichero:");

				// Leemos línea a línea hasta que no haya más (null)
				while ((linea = br.readLine()) != null) {
					System.out.println(linea);
				}

			} catch (IOException e) {
				// Captura de errores al leer el fichero
				e.printStackTrace();
			}
		}
	}
}

Ejercicio 12

Ejercicio 12 – Gestión de números en un fichero Enunciado: Crea un programa en Java que gestione un fichero de números. Requisitos: 1. Pide al usuario que introduzca números enteros por teclado. 2. El usuario podrá escribir números hasta que introduzca -1 (ese valor no se guarda). 3. Guarda todos los números en un fichero llamado numeros.txt, uno por línea. 4. Después de guardar, abre el fichero en modo lectura. 5. Muestra por pantalla: - todos los números del fichero - la suma total - cuántos números hay - el número mayor y menor 6. Usa try-with-resources. 7. Maneja posibles errores de fichero con try-catch.


package ficheros;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio12 {

	public static void main(String[] args) {
		
		// Variable temporal para almacenar cada número introducido
		int numero;

		// ArrayList para guardar todos los números antes de escribirlos en el fichero
		ArrayList<Integer> numeros = new ArrayList<Integer>();
		
		// Scanner en try-with-resources para que se cierre automáticamente al terminar
		try (Scanner in = new Scanner(System.in)) {
			
			// Bucle que se repite hasta que el usuario introduce -1
			do {
				System.out.println("Introduce un numero entero (-1 para salir)");
				
				try {
					// Leemos la línea y la convertimos a entero
					numero = Integer.parseInt(in.nextLine());
					
					// Si no es -1, lo añadimos a la lista
					if (numero != -1) {
						numeros.add(numero);
					}
					
				} catch (NumberFormatException e) {
					// Captura de error si el usuario introduce algo que no es número
					System.out.println("Solo se admiten numeros");
					numero = 0; // para que el bucle continúe
				}
				
			} while (numero != -1);
			
			// Comprobamos que hay números para guardar
			if (!numeros.isEmpty()) {

				// Escritura de los números en el fichero
				// BufferedWriter con try-with-resources se cierra automáticamente
				try (BufferedWriter bw = new BufferedWriter(new FileWriter("numeros.txt"))) {
					for (Integer n : numeros) {
						bw.write(String.valueOf(n)); // Convertimos el entero a String
						bw.newLine(); // Salto de línea
					}
				} catch (IOException e) {
					// Captura de errores de escritura en el fichero
					e.printStackTrace();
				}
				
				// Lectura de los números desde el fichero
				try (BufferedReader br = new BufferedReader(new FileReader("numeros.txt"))) {
					String n;
					
					// Variables para cálculos
					int sumaTotal = 0;
					int maxNum = Integer.MIN_VALUE;
					int minNum = Integer.MAX_VALUE;
					int contadorNumeros = 0;
					
					// Lectura línea a línea hasta el final del fichero
					while ((n = br.readLine()) != null) {
						System.out.println(n); // Mostramos cada número
						
						int valor = Integer.parseInt(n); // Convertimos la línea a entero
						sumaTotal += valor; // Acumulamos la suma
						contadorNumeros++; // Contamos el número
						
						// Calculamos el máximo y mínimo
						if (valor > maxNum) maxNum = valor;
						if (valor < minNum) minNum = valor;
					}
					
					// Mostramos resultados finales
					System.out.println("La suma de todos los numeros del fichero es -> " + sumaTotal);
					System.out.println("El numero mayor es -> " + maxNum);
					System.out.println("El numero menor es -> " + minNum);
					System.out.println("En total hay " + contadorNumeros + " numeros en el fichero");
					
				} catch (IOException e) {
					// Captura de errores de lectura en el fichero
					e.printStackTrace();
				}
			} else {
				// Si no se introdujo ningún número
				System.out.println("No hay numeros en el fichero");
			}
			
		}
	}
}

Ejercicio 13

Crea un programa en Java que gestione un fichero de tareas. Requisitos Pide al usuario que introduzca tareas por teclado. Cada tarea tendrá: - texto de la tarea - prioridad (1-alta, 2-media, 3-baja) El usuario podrá seguir introduciendo tareas hasta escribir fin como nombre de tarea. Guarda todas las tareas en un fichero llamado tareas.txt con este formato: Comprar pan,1 Estudiar Java,2 Lavar coche,3 Después de guardar, lee el fichero. Muestra: - todas las tareas - cuántas tareas hay - cuántas son de prioridad 1 - la tarea de mayor prioridad (la de número más bajo) Usa try-with-resources. Maneja errores de conversión y de fichero con try-catch.


package ficheros;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio13 {

	public static void main(String[] args) {

		// Lista donde se almacenarán todas las tareas en memoria
		ArrayList<Tarea> listaTareas = new ArrayList<Tarea>();

		System.out.println("Introduce tareas, introduce 'fin' para finalizar");

		// Contadores por prioridad
		int contador1 = 0, contador2 = 0, contador3 = 0;

		// Scanner con try-with-resources (se cerrará automáticamente)
		try (Scanner in = new Scanner(System.in)) {

			// Bucle principal de entrada de tareas
			while (true) {

				String tar;
				int pri = 0;

				// Pedir descripción de tarea
				System.out.println("Descripcion de la tarea:");
				tar = in.nextLine();

				// Si el usuario escribe "fin", salimos del bucle
				if (tar.equalsIgnoreCase("fin")) {
					break;
				}

				// Bucle para pedir prioridad válida
				while (true) {
					try {
						System.out.println("Introduce la prioridad de la tarea:");
						pri = Integer.parseInt(in.nextLine());

						// Según la prioridad, se crea la tarea y se añade a la lista
						if (pri == 1) {
							Tarea tarea = new Tarea(tar, pri);
							listaTareas.add(tarea);
							contador1++;
							break;
						} else if (pri == 2) {
							Tarea tarea = new Tarea(tar, pri);
							listaTareas.add(tarea);
							contador2++;
							break;
						} else if (pri == 3) {
							Tarea tarea = new Tarea(tar, pri);
							listaTareas.add(tarea);
							contador3++;
							break;
						} else {
							// Si no es 1,2,3 se repite
							System.out.println("La prioridad tiene que ser 1,2 o 3");
						}

					} catch (NumberFormatException e) {
						// Si el usuario introduce texto en vez de número
						System.err.println("La prioridad debe ser un numero");
					}
				}
			}

			// ===== ESCRITURA EN FICHERO =====
			try (BufferedWriter bw = new BufferedWriter(new FileWriter("tareas.txt"))) {

				// Recorre la lista y guarda cada tarea en el fichero
				for (Tarea tarea : listaTareas) {
					bw.write(tarea.getTarea() + "," + tarea.getPrioridad());
					bw.newLine();
				}

			} catch (IOException e) {
				e.printStackTrace();
			}

			// ===== LECTURA DEL FICHERO =====
			try (BufferedReader br = new BufferedReader(new FileReader("tareas.txt"))) {

				String linea;
				int contadorTareas = 0;
				int contadorPrioridad = 0;

				// Leer línea por línea
				while ((linea = br.readLine()) != null) {

					// Mostrar tarea
					System.out.println(linea);

					// Contar tareas con prioridad 1 (mirando el final de la línea)
					if (linea.charAt(linea.length() - 1) == '1' && linea.charAt(linea.length() - 2) == ',') {
						contadorPrioridad++;
					}

					contadorTareas++;
				}

				// Mostrar totales
				System.out.println("Hay un total de " + contadorTareas + " tareas");
				System.out.println("Hay un total de " + contadorPrioridad + " tareas con prioridad 1");

				// Mostrar tareas de mayor prioridad existente
				if (contador1 != 0) {
					mostrarPrioridad(1);
				} else if (contador2 != 0) {
					mostrarPrioridad(2);
				} else {
					mostrarPrioridad(3);
				}

			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}

		} finally {
			// Mensaje final al cerrar programa
			System.out.println("Programa finalizado");
		}
	}

	// Método que muestra todas las tareas de una prioridad concreta
	static void mostrarPrioridad(int prioridad) {

		try (BufferedReader br = new BufferedReader(new FileReader("tareas.txt"))) {

			String linea;
			String numero[] = new String[2];

			while ((linea = br.readLine()) != null) {

				// Separar texto y prioridad
				numero = linea.split(",");

				// Si coincide la prioridad, mostrar la línea
				if (Integer.parseInt(numero[1]) == prioridad) {
					System.out.println(linea);
				}
			}

		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

// ===== CLASE TAREA =====
class Tarea {

	String tarea;
	int prioridad;

	// Constructor con parámetros
	public Tarea(String tarea, int prioridad) {
		this.tarea = tarea;
		this.prioridad = prioridad;
	}

	// Constructor vacío
	public Tarea() {
	}

	public String getTarea() {
		return tarea;
	}

	public void setTarea(String tarea) {
		this.tarea = tarea;
	}

	public int getPrioridad() {
		return prioridad;
	}

	public void setPrioridad(int prioridad) {
		this.prioridad = prioridad;
	}

	// Método toString para mostrar la tarea
	@Override
	public String toString() {
		return "Tarea -> " + tarea + "\nPrioridad=" + prioridad;
	}
}

Ejercicio 14

Crea un programa en Java que guarde nombres en un fichero. Requisitos: Pide al usuario que introduzca nombres por teclado. El usuario podrá seguir escribiendo nombres hasta que escriba fin. Guarda todos los nombres en un fichero llamado nombres.txt, uno por línea. Después de guardar, lee el fichero. Muestra por pantalla: todos los nombres cuántos nombres hay en total Condiciones: Usa BufferedWriter para escribir. Usa BufferedReader para leer. Usa try-with-resources. Maneja posibles errores de fichero con try-catch.

package ficheros;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio14 {

	public static void main(String[] args) {

		// Variable para guardar cada nombre que introduce el usuario
		String nombre = "";

		// Lista donde almacenaremos todos los nombres antes de escribirlos al fichero
		ArrayList<String> listaNombres = new ArrayList<String>();

		// Scanner con try-with-resources (se cierra automáticamente)
		try (Scanner in = new Scanner(System.in)) {

			// Bucle infinito para pedir nombres hasta que el usuario escriba "fin"
			while (true) {
				System.out.println("Introduce un nombre ('fin' para terminar):");
				nombre = in.nextLine();

				// Si el nombre NO es "fin", lo añadimos a la lista
				if (!nombre.equalsIgnoreCase("fin")) {
					listaNombres.add(nombre);
				} else {
					// Si el usuario escribe "fin", salimos del bucle
					break;
				}
			}
		}

		// =========================
		// ESCRITURA EN EL FICHERO
		// =========================

		// Abrimos el fichero en modo escritura con BufferedWriter
		try (BufferedWriter bw = new BufferedWriter(new FileWriter("nombres.txt"))) {

			// Recorremos la lista y escribimos cada nombre en una línea
			for (String nom : listaNombres) {
				bw.write(nom);   // escribe el nombre
				bw.newLine();    // salto de línea
			}

		} catch (IOException e) {
			// Manejo de errores de escritura
			e.printStackTrace();
		}

		// Contador para saber cuántos nombres hay en el fichero
		int contadorNombres = 0;

		// =========================
		// LECTURA DEL FICHERO
		// =========================

		try (BufferedReader br = new BufferedReader(new FileReader("nombres.txt"))) {

			String linea;

			// Leemos línea a línea hasta que llegue null (fin de fichero)
			while ((linea = br.readLine()) != null) {
				System.out.println(linea); // mostramos el nombre por pantalla
				contadorNombres++;         // aumentamos el contador
			}

		} catch (IOException e) {
			// Manejo de errores de lectura
			e.printStackTrace();
		}

		// Mostramos cuántos nombres hay en total
		System.out.println("Hay un total de " + contadorNombres + " nombres");
	}
}

Ejercicio 15

Crea un programa en Java que gestione un fichero de notas. Requisitos Pide al usuario que introduzca números decimales (notas). El usuario podrá seguir escribiendo notas hasta que escriba fin. Guarda todas las notas en un fichero llamado notas.txt, una por línea. Después de guardar, abre el fichero en modo lectura. Muestra por pantalla: - todas las notas - la media de las notas - cuántas notas hay - la nota más alta Condiciones - Usa BufferedWriter para escribir. - Usa BufferedReader para leer. - Usa try-with-resources. - Controla errores de conversión. - Maneja errores de fichero.


package ficheros;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio15 {

	public static void main(String[] args) {
		
		double nota = 0.0;      // nota temporal
		String n = "";          // texto que introduce el usuario
		ArrayList<Double> listaNotas = new ArrayList<>(); // lista donde guardamos las notas
		
		// === LECTURA POR TECLADO ===
		try (Scanner in = new Scanner(System.in)) {
			
			do {
				do {
					System.out.println("Introduce una nota: ('fin para terminar')");
					n = in.next();
					
					// Si escribe "fin", salimos del bucle
					if (n.equalsIgnoreCase("fin")) {
						break;
					}
					
					try {
						// Intentamos convertir a double
						nota = Double.parseDouble(n);
						
						// Validamos rango
						if (nota < 0 || nota > 10) {
							System.out.println("La nota tiene que ser entre 0 y 10, introdúcela de nuevo");
						} else {
							// Nota válida → se guarda en la lista
							listaNotas.add(nota);
						}
						
					} catch (NumberFormatException e) {
						// Si no es número
						System.err.println("Solo puedes introducir notas válidas o 'fin' para terminar.");
					}
					
				} while (nota < 0 || nota > 10); // repetir si la nota no es válida
				
			} while (!n.equalsIgnoreCase("fin"));
			
			
			// === ESCRITURA EN FICHERO ===
			try (BufferedWriter bw = new BufferedWriter(new FileWriter("notas.txt"))) {
				
				for (double notaLista : listaNotas) {
					bw.write(String.valueOf(notaLista)); // escribimos la nota
					bw.newLine(); // salto de línea
				}
				
			} catch (IOException e) {
				e.printStackTrace();
			}
			
			
			// === LECTURA DEL FICHERO ===
			try (BufferedReader br = new BufferedReader(new FileReader("notas.txt"))) {
				
				String linea;
				int contador = 0;
				double sumaNotas = 0.0;
				double notaMax = 0;
				double valor;
				
				while ((linea = br.readLine()) != null) {
					
					System.out.println(linea); // mostramos la nota
					
					valor = Double.parseDouble(linea); // convertimos
					sumaNotas += valor; // sumamos
					contador++;         // contamos
					
					// comprobamos máximo
					if (valor > notaMax) {
						notaMax = valor;
					}
				}
				
				// === RESULTADOS ===
				System.out.println("La media de las notas es -> " + String.format("%.2f", (sumaNotas / contador)));
				System.out.println("Hay un total de " + contador + " notas");
				System.out.println("La nota más alta es -> " + notaMax);
			
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

Ejercicio 16

Crea un programa en Java que gestione un fichero de palabras. Requisitos Pide al usuario que introduzca palabras por teclado. El usuario podrá seguir escribiendo hasta que escriba fin. Guarda todas las palabras en un fichero llamado palabras.txt, una por línea. Después de guardar: Abre el fichero en modo lectura. Muestra por pantalla: todas las palabras cuántas palabras hay cuántas tienen más de 5 letras Condiciones Usa BufferedWriter para escribir. Usa BufferedReader para leer. Usa try-with-resources. Maneja errores de fichero con try-catch.

package ficheros;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio16 {

	public static void main(String[] args) {
		
		// Variable para almacenar la palabra introducida por el usuario
		String palabra;
		
		// Lista para guardar todas las palabras introducidas antes de escribirlas en el fichero
		ArrayList<String> listaPalabras = new ArrayList<String>();
		
		// Scanner para leer la entrada del usuario, con try-with-resources para cerrar automáticamente
		try(Scanner in = new Scanner(System.in)) {
			do {
				System.out.println("Introduce una palabra:");
				palabra = in.nextLine();
				
				// Solo agregamos la palabra si no es "fin"
				if(!palabra.equalsIgnoreCase("fin")) {
					listaPalabras.add(palabra);
				}
				
			// El bucle continúa hasta que el usuario escriba "fin"
			} while(!palabra.equalsIgnoreCase("fin"));
		}
		
		// Escribir las palabras en el fichero "palabras.txt" usando BufferedWriter
		try (BufferedWriter bw = new BufferedWriter(new FileWriter("palabras.txt"))) {
			for (String string : listaPalabras) {
				bw.write(string); // Escribimos la palabra
				bw.newLine();     // Insertamos un salto de línea
			}
			
		} catch (IOException e) {
			// Manejo de errores al escribir el fichero
			e.printStackTrace();
		}
		
		// Leer el fichero "palabras.txt" usando BufferedReader
		try(BufferedReader br = new BufferedReader(new FileReader("palabras.txt"))) {
			
			String linea;
			int contadorPalabras = 0;  // Contador total de palabras
			int contadorLongitud = 0;  // Contador de palabras con más de 5 caracteres
			
			// Mientras haya líneas en el fichero
			while((linea = br.readLine()) != null) {
				System.out.println(linea); // Mostrar la palabra
				contadorPalabras++;         // Incrementar contador total
				
				// Contar las palabras con más de 5 caracteres
				if(linea.length() > 5) {
					contadorLongitud++;
				}
			}
			
			// Mensajes adaptativos según el número de palabras
			if(contadorPalabras == 0) {
				System.out.println("El fichero está vacío");
			} else if(contadorPalabras == 1) {
				System.out.println("Hay una palabra en el fichero");
			} else {
				System.out.println("Hay un total de " + contadorPalabras + " palabras");
			}
			
			// Mensajes adaptativos según cuántas palabras tengan más de 5 caracteres
			if(contadorLongitud == 0) {
				System.out.println("No hay palabras de más de 5 caracteres");
			} else if(contadorLongitud == 1) {
				System.out.println("Hay una palabra de más de 5 caracteres");
			} else {
				System.out.println("Hay " + contadorLongitud + " palabras de más de 5 caracteres");
			}
			
		} catch (IOException e) {
			// Manejo de errores al leer el fichero
			e.printStackTrace();
		}
	}
}

Ejercicio 17

Crea un programa en Java que gestione un fichero de palabras. Requisitos Pide al usuario que introduzca palabras por teclado. El usuario podrá seguir escribiendo hasta que escriba fin. Guarda todas las palabras en un fichero llamado palabras.txt, una por línea. Después de guardar: Abre el fichero en modo lectura. Muestra por pantalla: todas las palabras cuántas palabras hay cuántas tienen más de 5 letras Condiciones Usa BufferedWriter para escribir. Usa BufferedReader para leer. Usa try-with-resources. Maneja errores de fichero con try-catch.

package ficheros;

import java.io.BufferedReader;
import java.io.BufferedWriter;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio17 {

	public static void main(String[] args) {
		
		// Variable para guardar lo que escribe el usuario por teclado
		String temperatura="";
		
		// Lista donde guardamos todas las temperaturas válidas antes de escribir al fichero
		ArrayList<Double> listaTemperaturas=new ArrayList<Double>();
		
		// Scanner con try-with-resources para que se cierre automáticamente
		try(Scanner in = new Scanner(System.in)){
			
			// Bucle principal: se repite hasta que el usuario escriba "fin"
			do {
				System.out.println("Introduce una temperatura.('fin' para finalizar)");
				temperatura=in.nextLine();
				
				// Si no escribe "fin", intentamos convertir a número
				if(!temperatura.equalsIgnoreCase("fin")) {
					try {
						// Convertimos a double y lo añadimos a la lista
						listaTemperaturas.add(Double.parseDouble(temperatura));
						
					}catch(NumberFormatException e) {
						// Si no es un número válido, avisamos y pedimos otra
						System.err.println("No es una temperatura valida.Introducela de nuevo");
					}
					
				}
				
			}while(!temperatura.equalsIgnoreCase("fin"));
		}
		
		// Escritura del fichero usando BufferedWriter
		try(BufferedWriter bw = new BufferedWriter(new FileWriter("Temperaturas.txt"))){
			
			// Recorremos la lista y escribimos cada temperatura en una línea
			for (Double temp : listaTemperaturas) {
				bw.write(String.valueOf(temp));
				bw.newLine(); // salto de línea
			}
			
		} catch (IOException e) {
			// Error si falla la escritura del fichero
			e.printStackTrace();
		}
		
		// Lectura del fichero
		try (BufferedReader br=new BufferedReader(new FileReader("Temperaturas.txt"))){
			
			String linea;
			
			// Contadores
			int contador=0;      // total temperaturas
			int contador30=0;    // temperaturas > 30
			
			// Inicializamos el mínimo al valor más alto posible
			double tempMin=Double.MAX_VALUE;
			
			// Leemos línea a línea hasta fin de fichero
			while((linea=br.readLine())!=null) {
				
				try {
					// Convertimos la línea a double
					double valor=Double.parseDouble(linea);
					
					// Mostramos temperatura
					System.out.println(valor+ "ºC");
					
					// Calculamos mínimo
					if(valor<tempMin) {
						tempMin=valor;
					}
					
					// Contador total
					contador++;
					
					// Contador de temperaturas mayores de 30
					if(valor>30) {
						contador30++;
					}
					
				}catch(NumberFormatException e){
					// Si alguna línea del fichero está corrupta, se ignora
					System.err.println("Linea incorrecta en el fichero -> '" + linea + "'");
				}
				
			}
			
			// Mensajes según número de temperaturas
			if(contador==0) {
				System.out.println("No hay ninguna temperatura en el fichero");
			}else if(contador==1) {
				System.out.println("Hay una temperatura en el fichero");
			}else {
				System.out.println("Hay " + contador + " temperaturas en el fichero");
			}
			
			// Mensajes temperaturas > 30
			if(contador30==0) {
				System.out.println("No hay ninguna temperatura mayor de 30ºC en el fichero");
			}else if(contador30==1) {
				System.out.println("Hay una temperatura mayor de 30ºC en el fichero");
			}else {
				System.out.println("Hay " + contador30 + " temperaturas mayores de 30ºC en el fichero");
			}
			
			// Solo mostramos mínimo si hay datos
			if(contador!=0) {
				System.out.println("La temperatura mas baja es de " 
						+ String.format("%.2f", tempMin)  + "ºC");
			}
			
		
		} catch (IOException e) {
			// Error al leer el fichero
			e.printStackTrace();
		}
	}
}

Ejercicio 18

Crea un programa en Java que simule un registro de accesos a un sistema. Funcionamiento: - Pide al usuario nombres de usuario por teclado. - Cada vez que se introduce un nombre, se guarda en un fichero llamado accesos.txt junto con la hora actual. - El usuario podrá seguir introduciendo nombres hasta escribir "fin". Formato del fichero (ejemplo): ana - 18:32 luis - 18:33 ana - 18:35 Después de guardar: - Abre el fichero y muestra: - Todo el historial de accesos - Cuántos accesos hay en total - El primer usuario que accedió - El último usuario que accedió Condiciones: - Usa BufferedWriter para guardar. - Usa BufferedReader para leer. - Usa try-with-resources. - Maneja errores de fichero con try-catch. - No uses ArrayList para guardar antes: escribe directamente en el fichero cada acceso.


package ficheros;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.time.LocalDateTime;
import java.util.Scanner;

public class Ejercicio18 {

	public static void main(String[] args) {
		
		String nombre = ""; // Variable para almacenar el nombre de usuario ingresado
		
		// Bloque para leer nombres desde teclado
		try(Scanner in = new Scanner(System.in)) {
			do {
				System.out.println("Introduce un nombre de usuario:");
				nombre = in.nextLine(); // Lectura del nombre
				LocalDateTime hora = LocalDateTime.now(); // Hora actual
				int h = hora.getHour();
				int m = hora.getMinute();
				
				// Si no se introduce "fin", se guarda el acceso en el fichero
				if(!nombre.equalsIgnoreCase("fin")) {
					try(BufferedWriter bw = new BufferedWriter(new FileWriter("accesos.txt", true))) {
						bw.write(nombre + " - " + h + ":" + m); // Escribir nombre y hora
						bw.newLine();
					} catch (IOException e) {
						e.printStackTrace(); // Captura errores de escritura
					}
				}
				
			} while(!nombre.equalsIgnoreCase("fin")); // Repetir hasta que el usuario escriba "fin"
		}
		
		// Variables para leer el historial de accesos
		String linea;
		String primerUsuario = ""; // Primer usuario que accedió
		String ultimoUsuario = ""; // Último usuario que accedió
		int contador = 0;          // Contador de accesos totales
		
		// Bloque para leer el fichero
		try (BufferedReader br = new BufferedReader(new FileReader("accesos.txt"))) {
			while((linea = br.readLine()) != null) { // Leer línea por línea
				System.out.println(linea); // Mostrar el acceso por pantalla
				
				// Guardar primer usuario si aún no está definido
				if(primerUsuario.isBlank()) {
					primerUsuario = linea.substring(0, linea.indexOf(" "));
				}
				
				// Actualizar último usuario leído
				ultimoUsuario = linea.substring(0, linea.indexOf(" "));
				contador++; // Incrementar contador de accesos
			}
		} catch (IOException e) {
			e.printStackTrace(); // Captura errores de lectura
		}
		
		// Mostrar resultados finales
		if(contador != 0) {
			System.out.println("El primer usuario que accedió fue -> '" + primerUsuario + "'");
			System.out.println("El último usuario que accedió fue -> '" + ultimoUsuario + "'");
		}
		
		// Mensajes según la cantidad de accesos
		if(contador == 0) {
			System.out.println("No accedió ningún usuario");
		} else if(contador == 1) {
			System.out.println("Solo accedió un usuario");
		} else {
			System.out.println("Los diferentes usuarios accedieron en total " + contador + " veces");
		}
	}

}

Ejercicio 19

Ejercicio: Registro de temperaturas seguro Objetivo: Escribir y leer un fichero de temperaturas, manejando errores de entrada y del fichero de forma robusta. Enunciado: - Pedir al usuario temperaturas decimales hasta que escriba "fin". - Guardarlas en temperaturas_seguras.txt (una por línea). - Manejar errores de escritura. - Comprobar que el fichero existe antes de leerlo. - Leer línea a línea: - Convertir a double. - Ignorar líneas corruptas. - Mostrar: - Todas las temperaturas válidas. - Cantidad total. - Mínima. - Máxima. - Media. Condiciones: - Usar BufferedWriter y BufferedReader. - Usar try-with-resources. - Capturar excepciones de I/O y NumberFormatException.


package ficheros;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio19 {

    public static void main(String[] args) {

        // Variable para almacenar la entrada del usuario
        String temperatura = "";

        // Lista para guardar las temperaturas válidas introducidas
        ArrayList<Double> listaTemperaturas = new ArrayList<Double>();

        // Lectura de datos por teclado (se cierra automáticamente)
        try (Scanner in = new Scanner(System.in)) {

            do {
                try {
                    System.out.println("Ingresa una temperatura. ('fin' para terminar)");
                    temperatura = in.nextLine();

                    // Si no es "fin", intentamos convertir a double
                    if (!temperatura.equalsIgnoreCase("fin")) {
                        listaTemperaturas.add(Double.parseDouble(temperatura));
                    }

                } catch (NumberFormatException e) {
                    // Si el usuario introduce algo que no es número
                    System.err.println("No es una temperatura válida, introdúcela de nuevo");
                }

            } while (!temperatura.equalsIgnoreCase("fin"));
        }

        // Ruta del fichero
        Path ruta = Paths.get("temperaturas_seguras.txt");

        // Escritura en el fichero (sobrescribe el contenido)
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(ruta.toFile()))) {

            for (double temp : listaTemperaturas) {
                bw.write(String.valueOf(temp));
                bw.newLine(); // Salto de línea
            }

        } catch (IOException e) {
            // Error real de escritura (permiso, disco, etc.)
            System.err.println("Error al escribir en el archivo: " + e.getMessage());
            e.printStackTrace();
            return; // Si no se pudo escribir, no tiene sentido seguir
        }

        // Comprobamos que el fichero existe antes de leer
        if (!Files.exists(ruta)) {
            System.err.println("El archivo no existe");
        } else {

            // Lectura del fichero
            try (BufferedReader br = new BufferedReader(new FileReader("temperaturas_seguras.txt"))) {

                String linea;
                double tempe = 0.0;

                int contador = 0;
                double media = 0.0;

                // Inicialización correcta para min y max
                double temperaturaMaxima = Double.NEGATIVE_INFINITY;
                double temperaturaMinima = Double.POSITIVE_INFINITY;

                // Leemos línea a línea
                while ((linea = br.readLine()) != null) {

                    try {
                        // Intentamos convertir la línea a double
                        tempe = Double.parseDouble(linea);

                        contador++;
                        media += tempe;

                        // Actualizamos máxima
                        if (tempe > temperaturaMaxima) {
                            temperaturaMaxima = tempe;
                        }

                        // Actualizamos mínima
                        if (tempe < temperaturaMinima) {
                            temperaturaMinima = tempe;
                        }

                        // Mostramos temperatura válida
                        System.out.println(linea + "ºC");

                    } catch (NumberFormatException e) {
                        // Si la línea está corrupta
                        System.err.println("Línea corrupta ignorada: " + linea);
                    }
                }

                // Mensaje según cantidad de temperaturas válidas
                if (contador == 0) {
                    System.out.println("No hay ninguna temperatura válida en el fichero");
                } else if (contador == 1) {
                    System.out.println("Hay una temperatura válida en el fichero");
                } else {
                    System.out.println("Hay " + contador + " temperaturas válidas en el fichero");
                }

                // Mostrar estadísticas si hay al menos una válida
                if (contador != 0) {
                    System.out.println("Media -> " + String.format("%.2fºC", (media / contador)));
                    System.out.println("Temperatura mínima -> " + String.format("%.2fºC", temperaturaMinima));
                    System.out.println("Temperatura máxima -> " + String.format("%.2fºC", temperaturaMaxima));
                }

            } catch (IOException e) {
                // Error durante la lectura
                e.printStackTrace();
            }
        }
    }
}

Ejercicio 20

Enunciado Crea un programa en Java que: Pida al usuario una frase por teclado. Guarde esa frase en un fichero llamado frase.txt. Después abra el fichero y: Muestre la frase almacenada. Cuente cuántas palabras tiene. Cuente cuántos caracteres tiene (sin contar espacios). Indique si la frase está vacía. Condiciones Usa BufferedWriter para guardar. Usa BufferedReader para leer. Usa try-with-resources. Maneja posibles IOException. No uses ArrayList. Procesa la frase directamente al leerla.

package ficheros;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Scanner;

public class Ejercicio20 {

    public static void main(String[] args) {

        String frase;

        // Pedimos la frase al usuario
        try (Scanner in = new Scanner(System.in)) {
            System.out.println("Introduce una frase:");
            frase = in.nextLine();
        }

        Path ruta = Paths.get("frase.txt");

        // Guardamos la frase en el fichero
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(ruta.toFile()))) {
            bw.write(frase);
        } catch (IOException e) {
            System.err.println("Error al escribir en el archivo: " + e.getMessage());
            return; // Si no se puede escribir, no seguimos
        }

        // Leemos el fichero
        try (BufferedReader br = new BufferedReader(new FileReader(ruta.toFile()))) {

            String linea = br.readLine();

            if (linea == null || linea.trim().isEmpty()) {
                System.out.println("La frase está vacía");
            } else {

                System.out.println("Frase: " + linea);

                // Contar palabras (uno o más espacios)
                String[] palabras = linea.trim().split("\\s+");

                // Contar caracteres sin espacios
                int contadorCaracteres = 0;
                for (int i = 0; i < linea.length(); i++) {
                    if (linea.charAt(i) != ' ') {
                        contadorCaracteres++;
                    }
                }

                System.out.println("Palabras: " + palabras.length);
                System.out.println("Caracteres (sin espacios): " + contadorCaracteres);
            }

        } catch (IOException e) {
            System.err.println("Error al leer el archivo: " + e.getMessage());
        }
    }
}