Java – Leer un archivo de texto

Hay tres formas, y la diferencia entre ellas es cuánta memoria gastan. Para un archivo de configuración da igual; para uno de dos gigas, decide si el programa funciona o se queda sin memoria.

También te puede interesar

El archivo entero, en una cadena

import java.nio.file.*;

void main() throws Exception {
    Path ruta = Path.of("salida", "notas.txt");
    String todo = Files.readString(ruta);
    IO.println(todo);
}
salidaa
b
c

Lo más corto que hay. Lee en UTF-8 y devuelve una cadena con los saltos de línea incluidos. Para cualquier archivo de tamaño razonable —configuración, una plantilla, un JSON pequeño— es lo que toca.

Una lista de líneas

List<String> lineas = Files.readAllLines(ruta);
IO.println(lineas + "  (" + lineas.size() + " líneas)");
salida[a, b, c]  (3 líneas)

Las líneas vienen ya sin el salto del final, y da igual si el archivo usa el de Unix o el de Windows. Es lo cómodo cuando vas a recorrerlas.

Archivos grandes: Files.lines

try (Stream<String> s = Files.lines(ruta)) {
    long n = s.filter(l -> !l.isBlank()).count();
    IO.println("líneas no vacías: " + n);
}
salidalíneas no vacías: 3
Las dos anteriores cargan el archivo entero en memoria. Con un registro de varios gigas, eso es un OutOfMemoryError. Files.lines devuelve un flujo perezoso: va leyendo según consumes. Y hay que cerrarlo, por eso va dentro de un try (…): es de los pocos streams de Java que tienen un archivo abierto detrás.

Cuando el archivo no está

try {
    Files.readString(Path.of("salida", "no-esta.txt"));
} catch (NoSuchFileException e) {
    IO.println("no existe: " + e.getFile());
}
salidano existe: salida/no-esta.txt

NoSuchFileException es una IOException concreta, y trae la ruta dentro. Eso es justo lo que la API vieja no hacía: new Scanner(new File(...)) lanzaba FileNotFoundException con un mensaje de texto del que había que adivinar el resto.

Y el Scanner del ejemplo de antes

Scanner input = new Scanner(new File("/ruta/archivo.txt"));
while (input.hasNextLine()) {
    System.out.println(input.nextLine());
}
input.close();

Funciona, y lo verás en muchos sitios. Pero Scanner está pensado para interpretar la entrada —leer un int, un double, saltarse espacios—, no para volcar un archivo; es más lento, se traga los errores de codificación y hay que cerrarlo a mano. Para leer texto, Files.

Si el archivo…Usa
Es pequeño y lo quieres enteroFiles.readString(ruta)
Es pequeño y lo quieres por líneasFiles.readAllLines(ruta)
Es grandeFiles.lines(ruta) en un try-with-resources
Es binarioFiles.readAllBytes(ruta)
Puede no existircaptura NoSuchFileException

Más información en inglés: Read a text file in Java.

Todo el código se compiló y se ejecutó con Java 25 LTS en un contenedor limpio antes de publicar esta página; las salidas están copiadas de esa ejecución.

2 comentarios en «Java – Leer un archivo de texto»

  1. public void ejecute(String aux){
    Statement sentencias=null;
    try{
    sentencias = conn1.createStatement();
    sentencias.executeUpdate(aux);
    sentencias.close();
    }catch(SQLException ex){
    ex.printStackTrace();
    }
    }

    public void leersql(String fichero){
    String aux;
    try{
    String cadena;
    aux=»»;
    FileReader f = new FileReader(fichero);
    BufferedReader b = new BufferedReader(f);
    while((cadena = b.readLine())!=null) {
    if(cadena.startsWith(«/*»)||cadena.startsWith(«–«)){
    }else{
    if(!cadena.endsWith(«;»)){
    aux+=cadena;
    }
    if(cadena.endsWith(«;»)){
    aux+=cadena;
    ejecute(aux);
    aux=»»;
    }
    }
    }
    System.out.println(«Treminado»);
    b.close();
    f.close();
    }
    catch (IOException e){
    System.out.println(e.getStackTrace());
    }
    }

    public void altaReparaciones(){
    String fechaE,fechaS;
    ArrayList matriculas=new ArrayList();
    System.out.print(«Fecha de entrada (dd/mm/aa): «);
    fechaE=sc.next();
    System.out.print(«Fecha de salida (dd/mm/aa): «);
    fechaS=sc.next();

    System.out.println(«Listado de coches:»);
    System.out.println(«————————–«);
    try{
    int contador=0,cocheSelec=0,precio,cantidad;
    String SQL = «SELECT * FROM coches»,nombre;
    Statement stmt = conn1.createStatement();
    ResultSet rs = stmt.executeQuery(SQL);
    while (rs.next()) {
    contador++;
    matriculas.add(rs.getString(«matricula»));
    System.out.println(contador+», «+rs.getString(«matricula») + «, » + rs.getString(«marca»)+», «+rs.getString(«modelo»));
    }

    System.out.println(«Elige uno de los coches:»);
    cocheSelec=sc.nextInt();

    PreparedStatement ps=null;
    ps=conn1.prepareStatement(«INSERT INTO `reparaciones` VALUES (NULL,?,?,?)»);
    ps.setString(1, fechaE);
    ps.setString(2, fechaS);
    ps.setString(3, matriculas.get(cocheSelec-1));
    ps.executeUpdate();
    ps.close();

    System.out.println(«Reparacion dada de alta, inserta los materiales usados»);
    System.out.println(«—————————————–«);
    System.out.print(«Nombre:»);
    nombre=sc.next();
    System.out.print(«Cantidad:»);
    cantidad=sc.nextInt();
    System.out.print(«Precio:»);
    precio=sc.nextInt();

    rs.close();
    stmt.close();

    }catch(Exception e){
    }
    }

    Responder

Deja un comentario