txt - ¿Cómo leer un archivo de texto grande línea por línea usando Java?

leer una linea especifica de un archivo en java

Question

Necesito leer un archivo de texto grande de alrededor de 5-6 GB línea por línea usando Java.

¿Cómo puedo hacer esto rápidamente?

Answer 1

Java-9:

try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
        stream.forEach(System.out::println);
}

Answer 2

Aquí hay una muestra con el manejo completo de errores y la especificación de conjunto de caracteres compatible para Java anterior a Java 7. Con Java 7 puede usar la sintaxis de prueba con recursos, lo que hace que el código sea más limpio.

Si solo desea el conjunto de caracteres predeterminado, puede omitir InputStream y usar FileReader.

InputStream ins = null; // raw byte-stream
Reader r = null; // cooked reader
BufferedReader br = null; // buffered for readLine()
try {
    String s;
    ins = new FileInputStream("textfile.txt");
    r = new InputStreamReader(ins, "UTF-8"); // leave charset out for default
    br = new BufferedReader(r);
    while ((s = br.readLine()) != null) {
        System.out.println(s);
    }
}
catch (Exception e)
{
    System.err.println(e.getMessage()); // handle exception
}
finally {
    if (br != null) { try { br.close(); } catch(Throwable t) { /* ensure close happens */ } }
    if (r != null) { try { r.close(); } catch(Throwable t) { /* ensure close happens */ } }
    if (ins != null) { try { ins.close(); } catch(Throwable t) { /* ensure close happens */ } }
}

Aquí está la versión Groovy, con el manejo completo de errores:

File f = new File("textfile.txt");
f.withReader("UTF-8") { br ->
    br.eachLine { line ->
        println line;
    }
}

Answer 3

Documenté y probé 10 formas diferentes de leer un archivo en Java y luego los encontré haciendo que se leyeran en archivos de prueba de 1KB a 1GB. Estos son los 3 métodos de lectura de archivos más rápidos para leer un archivo de prueba de 1GB.

Tenga en cuenta que cuando ejecutaba las pruebas de rendimiento no enviaba nada a la consola, ya que eso realmente ralentizaría la prueba. Solo quería probar la velocidad de lectura en bruto.

1) java.nio.file.Files.readAllBytes ()

Probado en Java 7, 8, 9. Este fue en general el método más rápido. La lectura de un archivo de 1GB fue consistentemente de menos de 1 segundo.

import java.io..File;
import java.io.IOException;
import java.nio.file.Files;

public class ReadFile_Files_ReadAllBytes {
  public static void main(String [] pArgs) throws IOException {
    String fileName = "c://temp//sample-1GB.txt";
    File file = new File(fileName);

    byte [] fileBytes = Files.readAllBytes(file.toPath());
    char singleChar;
    for(byte b : fileBytes) {
      singleChar = (char) b;
      System.out.print(singleChar);
    }
  }
}

2) java.nio.file.Files.lines ()

Esto se probó con éxito en Java 8 y 9, pero no funcionará en Java 7 debido a la falta de soporte para las expresiones lambda. Tomó alrededor de 3.5 segundos leer un archivo de 1GB que lo colocó en el segundo lugar en cuanto a leer archivos más grandes.

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.stream.Stream;

public class ReadFile_Files_Lines {
  public static void main(String[] pArgs) throws IOException {
    String fileName = "c://temp//sample-1GB.txt";
    File file = new File(fileName);

    try (Stream linesStream = Files.lines(file.toPath())) {
      linesStream.forEach(line -> {
        System.out.println(line);
      });
    }
  }
}

3) BufferedReader

Probado para funcionar en Java 7, 8, 9. Esto tomó aproximadamente 4,5 segundos para leer en un archivo de prueba de 1GB.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadFile_BufferedReader_ReadLine {
  public static void main(String [] args) throws IOException {
    String fileName = "c://temp//sample-1GB.txt";
    FileReader fileReader = new FileReader(fileName);

    try (BufferedReader bufferedReader = new BufferedReader(fileReader)) {
      String line;
      while((line = bufferedReader.readLine()) != null) {
        System.out.println(line);
      }
    }
  }

Puede encontrar la clasificación completa de los 10 métodos de lectura de archivos here .

Answer 4

En Java 7:

String folderPath = "C:/folderOfMyFile";
Path path = Paths.get(folderPath, "myFileName.csv"); //or any text file eg.: txt, bat, etc
Charset charset = Charset.forName("UTF-8");

try (BufferedReader reader = Files.newBufferedReader(path , charset)) {
  while ((line = reader.readLine()) != null ) {
    //separate all csv fields into string array
    String[] lineVariables = line.split(","); 
  }
} catch (IOException e) {
    System.err.println(e);
}

Answer 5

En Java 8, podrías hacer:

try (Stream<String> lines = Files.lines (file, StandardCharsets.UTF_8))
{
    for (String line : (Iterable<String>) lines::iterator)
    {
        ;
    }
}

Algunas notas: La transmisión devuelta por Files.lines (a diferencia de la mayoría de las transmisiones) debe cerrarse. Por las razones mencionadas aquí , evito usar forEach() . El extraño código (Iterable<String>) lines::iterator convierte un flujo a un iterable.

Answer 6

En Java 8, también hay una alternativa al uso de Files.lines() . Si su fuente de entrada no es un archivo sino algo más abstracto como un Reader o un InputStream , puede transmitir las líneas a través del método lines() BufferedReader s.

Por ejemplo:

try( BufferedReader reader = new BufferedReader( ... ) ) {
  reader.lines().foreach( line -> processLine( line ) );
}

llamará a processLine() para cada línea de entrada leída por BufferedReader .

Answer 7

FileReader no le permitirá especificar la codificación, use InputStreamReader en su lugar si necesita especificarla:

try {
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "Cp1252"));         

    String line;
    while ((line = br.readLine()) != null) {
        // process the line.
    }
    br.close();

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

Si importó este archivo desde Windows, es posible que tenga codificación ANSI (Cp1252), por lo que debe especificar la codificación.

Answer 8

La manera clara de lograr esto,

Por ejemplo:

Si tiene dataFile.txt en su directorio actual

import java.io.*;
import java.util.Scanner;
import java.io.FileNotFoundException;

public class readByLine
{
    public readByLine() throws FileNotFoundException
    {
        Scanner linReader = new Scanner(new File("dataFile.txt"));

        while (linReader.hasNext())
        {
            String line = linReader.nextLine();
            System.out.println(line);
        }
        linReader.close();

    }

    public static void main(String args[])  throws FileNotFoundException
    {
        new readByLine();
    }
}

La salida como la de abajo,

Answer 9

Lo que puede hacer es escanear todo el texto con Escáner y recorrer la línea de texto por línea. Por supuesto que deberías importar lo siguiente:

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public static void readText throws FileNotFoundException {
    Scanner scan = new Scanner(new File("samplefilename.txt"));
    while(scan.hasNextLine()){
        String line = scan.nextLine();
        //Here you can manipulate the string the way you want
    }
}

Escáner básicamente escanea todo el texto. El bucle while se utiliza para atravesar todo el texto.

La función .hasNextLine() es un valor booleano que devuelve verdadero si todavía hay más líneas en el texto. La función .nextLine() le ofrece una línea completa como una cadena que luego puede usar de la manera que desee. Intente System.out.println(line) para imprimir el texto.

Nota al margen: .txt es el texto de tipo de archivo.

Answer 10

Mira este blog:

• Java Read File Line by Line - Tutorial de Java

Se puede especificar el tamaño del búfer o se puede usar el tamaño predeterminado. El valor predeterminado es lo suficientemente grande para la mayoría de los propósitos.

// Open the file
FileInputStream fstream = new FileInputStream("textfile.txt");
BufferedReader br = new BufferedReader(new InputStreamReader(fstream));

String strLine;

//Read File Line By Line
while ((strLine = br.readLine()) != null)   {
  // Print the content on the console
  System.out.println (strLine);
}

//Close the input stream
br.close();

Answer 11

Normalmente hago la rutina de lectura directa:

void readResource(InputStream source) throws IOException {
    BufferedReader stream = null;
    try {
        stream = new BufferedReader(new InputStreamReader(source));
        while (true) {
            String line = stream.readLine();
            if(line == null) {
                break;
            }
            //process line
            System.out.println(line)
        }
    } finally {
        closeQuiet(stream);
    }
}

static void closeQuiet(Closeable closeable) {
    if (closeable != null) {
        try {
            closeable.close();
        } catch (IOException ignore) {
        }
    }
}

Answer 12

Para leer el archivo con java 8

  package com.java.java8;

    import java.nio.file.Files;
    import java.nio.file.Paths;
    import java.util.stream.Stream;

    /**
     * The Class ReadLargeFile.
     *
     * @author Ankit Sood Apr 20, 2017
     */
    public class ReadLargeFile {

        /**
         * The main method.
         *
         * @param args
         *            the arguments
         */
        public static void main(String[] args) {
        try {
            Stream<String> stream = Files.lines(Paths.get("C://Users//System//Desktop//demoData.txt"));
            stream.forEach(System.out::println);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }
    }

Answer 13

Puedes usar este código:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadTextFile {

    public static void main(String[] args) throws IOException {

        try {

            File f = new File("src/com/data.txt");

            BufferedReader b = new BufferedReader(new FileReader(f));

            String readLine = "";

            System.out.println("Reading file using Buffered Reader");

            while ((readLine = b.readLine()) != null) {
                System.out.println(readLine);
            }

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

    }

}

Answer 14

Puedes usar la clase Scanner

Scanner sc=new Scanner(file);
sc.nextLine();

Answer 15

Puedes usar streams para hacerlo de forma más precisa:

Files.lines(Paths.get("input.txt")).forEach(s -> stringBuffer.append(s);

Answer 16

También puedes usar apache commons io :

File file = new File("/home/user/file.txt");
try {
    List<String> lines = FileUtils.readLines(file);
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

Answer 17

Un patrón común es usar

try (BufferedReader br = new BufferedReader(new FileReader(file))) {
    String line;
    while ((line = br.readLine()) != null) {
       // process the line.
    }
}

Puede leer los datos más rápido si asume que no hay codificación de caracteres. Por ejemplo, ASCII-7 pero no hará mucha diferencia. Es muy probable que lo que haga con los datos tome mucho más tiempo.

EDITAR: Un patrón de uso menos común que evita el alcance de la fuga de line .

try(BufferedReader br = new BufferedReader(new FileReader(file))) {
    for(String line; (line = br.readLine()) != null; ) {
        // process the line.
    }
    // line is not visible here.
}

ACTUALIZACIÓN: En Java 8 puedes hacerlo.

try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
        stream.forEach(System.out::println);
}

NOTA: debe colocar la secuencia en un bloque de try-with-resource para asegurarse de que se llame al método #close; de ​​lo contrario, el identificador del archivo subyacente nunca se cerrará hasta que GC lo haga mucho más tarde.

Answer 18

Una vez que salga java-8 (marzo de 2014), podrás usar las transmisiones:

try (Stream<String> lines = Files.lines(Paths.get(filename), Charset.defaultCharset())) {
  lines.forEachOrdered(line -> process(line));
}

Imprimiendo todas las líneas en el archivo:

try (Stream<String> lines = Files.lines(file, Charset.defaultCharset())) {
  lines.forEachOrdered(System.out::println);
}

Answer 19

readLine() usar el método readLine() en la class BufferedReader . Cree un nuevo objeto de esa clase y opere este método en él y guárdelo en una cadena.

BufferReader Javadoc

Answer 20

BufferedReader br;
FileInputStream fin;
try {
    fin = new FileInputStream(fileName);
    br = new BufferedReader(new InputStreamReader(fin));

    /*Path pathToFile = Paths.get(fileName);
    br = Files.newBufferedReader(pathToFile,StandardCharsets.US_ASCII);*/

    String line = br.readLine();
    while (line != null) {
        String[] attributes = line.split(",");
        Movie movie = createMovie(attributes);
        movies.add(movie);
        line = br.readLine();
    }
    fin.close();
    br.close();
} catch (FileNotFoundException e) {
    System.out.println("Your Message");
} catch (IOException e) {
    System.out.println("Your Message");
}

Esto funciona para mi. Espero que te ayude también.