Lendo um arquivo de texto sem formatação em Java

933

Parece que existem diferentes maneiras de ler e gravar dados de arquivos em Java.

Eu quero ler dados ASCII de um arquivo. Quais são os caminhos possíveis e suas diferenças?

Tim, o Encantador
fonte
24
Também não concordo com o fechamento como "não construtivo". Felizmente, isso pode muito bem ser fechado como duplicado . Boas respostas, por exemplo, em Como criar uma String a partir do conteúdo de um arquivo? , Qual é a maneira mais simples de ler um arquivo no String? , Quais são as classes mais simples para ler arquivos?
Jonik
Sem loops: {{{Scanner sc = novo Scanner (arquivo, "UTF-8"); sc.useDelimiter ("$ ^"); // regex que não corresponde a nada String text = sc.next (); sc.close (); }}}
Aivar 28/04
3
é tão interessante que não há nada como "read ()" em python, para ler todo o arquivo para uma string
kommradHomer
2
Esta é a maneira mais simples de fazer isso: mkyong.com/java/…
dellasavia 17/03/15

Respostas:

567

ASCII é um arquivo de texto que você usaria Readerspara ler. Java também suporta a leitura de um arquivo binário usando InputStreams. Se os arquivos que estão sendo lidos forem grandes, você poderá usar umBufferedReader em cima de um FileReaderpara melhorar o desempenho da leitura.

Leia este artigo sobre como usar umReader

Também recomendo que você baixe e leia este livro maravilhoso (ainda gratuito) chamado Thinking In Java

No Java 7 :

new String(Files.readAllBytes(...))

(docs) ou

Files.readAllLines(...)

(docs)

No Java 8 :

Files.lines(..).forEach(...)

(docs)

Aravind Yarram
fonte
14
Escolher um leitor realmente depende do conteúdo para o qual você precisa. Se o arquivo é pequeno (ish) e você precisa de tudo, é mais rápido (comparado a nós: 1.8-2x) usar apenas um FileReader e ler tudo (ou pelo menos pedaços grandes o suficiente). Se você estiver processando linha por linha, vá para o BufferedReader.
Vlad
3
A ordem das linhas será preservada ao usar "Files.lines (..). ForEach (...)". Meu entendimento é que a ordem será arbitrária após esta operação.
Daniil Shevelev 14/09/14
39
Files.lines(…).forEach(…)não preserva a ordem das linhas, mas é executado em paralelo, @Dash. Se o pedido for importante, você pode usá-lo Files.lines(…).forEachOrdered(…), o que deve preservar o pedido (embora não tenha sido verificado).
Palec 15/02
2
@Palec isso é interessante, mas você pode citar os documentos onde diz que Files.lines(...).forEach(...)é executado em paralelo? Eu pensei que este era apenas o caso quando você explicitamente faz o fluxo paralelo usando Files.lines(...).parallel().forEach(...).
Klitos Kyriacou 9/11
3
Minha formulação original não é à prova de balas, @KlitosKyriacou. O ponto é que forEachnão garante nenhuma ordem e o motivo é a fácil paralelização. Se a ordem deve ser preservada, use forEachOrdered.
Palec
687

Minha maneira favorita de ler um arquivo pequeno é usar um BufferedReader e um StringBuilder. É muito simples e direto ao ponto (embora não seja particularmente eficaz, mas bom o suficiente para a maioria dos casos):

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();

    while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
    }
    String everything = sb.toString();
} finally {
    br.close();
}

Alguns salientaram que após o Java 7 você deve usar os recursos try-with-resources (isto é, fechamento automático):

try(BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();

    while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
    }
    String everything = sb.toString();
}

Quando leio seqüências de caracteres como essa, geralmente quero manipular algumas linhas por linha de qualquer maneira, então vou para essa implementação.

Embora, se eu realmente queira apenas ler um arquivo em uma String, sempre usei o Apache Commons IO com o método da classe IOUtils.toString (). Você pode dar uma olhada na fonte aqui:

http://www.docjar.com/html/api/org/apache/commons/io/IOUtils.java.html

FileInputStream inputStream = new FileInputStream("foo.txt");
try {
    String everything = IOUtils.toString(inputStream);
} finally {
    inputStream.close();
}

E ainda mais simples com o Java 7:

try(FileInputStream inputStream = new FileInputStream("foo.txt")) {     
    String everything = IOUtils.toString(inputStream);
    // do something with everything string
}
Knubo
fonte
6
Fiz um pequeno ajuste para parar de adicionar uma nova linha (\ n) se a última linha for alcançada. code while (linha! = nula) {sb.append (linha); line = br.readLine (); // Adicione apenas uma nova linha quando a linha de curvatura NÃO for a última linha. If (line! = Null) {sb.append ("\ n"); }}code
Ramon Fincken 16/04
2
Semelhante ao Apache IO IOUtils comuns # toString () é sun.misc.IOUtils # readFully (), incluído nos JREs do Sun / Oracle.
Gb96
3
Para um desempenho sempre chamar sb.append ( '\ n') em detrimento de sb.append ( "\ n") como um char é anexado ao StringBuilder mais rápido do que uma String
GB96
2
FileReader pode lançar FileNotFoundException e BufferedRead pode lançar IOException para que você precise capturá-los.
Kamaci #
4
não há necessidade de usar os leitores diretamente e também não há necessidade de ferramentas. O java7 desenvolveu métodos para ler um arquivo inteiro / todas as linhas: consulte docs.oracle.com/javase/7/docs/api/java/nio/file/… e docs.oracle.com/javase/7/docs/api / java / nio / file /…
kritzikratzi
142

A maneira mais fácil é usar a Scannerclasse em Java e o objeto FileReader. Exemplo simples:

Scanner in = new Scanner(new FileReader("filename.txt"));

Scanner possui vários métodos para leitura de strings, números, etc ... Você pode procurar mais informações sobre isso na página de documentação do Java.

Por exemplo, lendo todo o conteúdo em String:

StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
    sb.append(in.next());
}
in.close();
outString = sb.toString();

Além disso, se você precisar de uma codificação específica, poderá usar isso em vez de FileReader:

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)
Jesus Ramos
fonte
28
while (in.hasNext ()) {System.out.println (in.next ()); }
Gene Bo
16
@ Hissain Mas muito mais fácil de usar do queBufferedReader
Jesus Ramos
3
Deve cercá-lo com a tentativa Catch
Rahal Kanishka
@ JesusRamos Na verdade não, por que você acha isso? O que há de mais fácil nisso while ((line = br.readLine()) != null) { sb.append(line); }?
Marquês de Lorne
83

Aqui está uma solução simples:

String content;

content = new String(Files.readAllBytes(Paths.get("sample.txt")));
Nery Jr
fonte
2
@Nery Jr, elegante e simples #
Mahmoud Saleh
1
O melhor e mais simples.
Dary
57

Aqui está outra maneira de fazer isso sem usar bibliotecas externas:

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

public String readFile(String filename)
{
    String content = null;
    File file = new File(filename); // For example, foo.txt
    FileReader reader = null;
    try {
        reader = new FileReader(file);
        char[] chars = new char[(int) file.length()];
        reader.read(chars);
        content = new String(chars);
        reader.close();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(reader != null){
            reader.close();
        }
    }
    return content;
}
Sujo
fonte
10
ou use a tentativa "try-with-resources" (FileReader reader = new FileReader (file))
Hernán Eche
3
Notei o file.length (), como isso funciona com arquivos utf-16?
Wayne
5
Essa técnica assume que read () preenche o buffer; que o número de caracteres é igual ao número de bytes; que o número de bytes cabe na memória; e que o número de bytes se encaixa em um número inteiro. -1
Marquês de Lorne
1
@HermesTrismegistus Forneci quatro razões pelas quais está errado. StefanReich está perfeitamente correto em concordar comigo.
Marquês de Lorne
35

Eu tive que avaliar as diferentes maneiras. Vou comentar minhas descobertas, mas, em resumo, a maneira mais rápida é usar um BufferedInputStream antigo simples sobre um FileInputStream. Se muitos arquivos precisarem ser lidos, três threads reduzirão o tempo total de execução para aproximadamente a metade, mas a adição de mais threads diminuirá progressivamente o desempenho até que demore três vezes mais para concluir com vinte threads do que com apenas um thread.

A suposição é que você deve ler um arquivo e fazer algo significativo com seu conteúdo. Nos exemplos a seguir, está lendo linhas de um log e conte as que contêm valores que excedem um determinado limite. Portanto, estou assumindo que o Java 8 de Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))uma linha não é uma opção.

Testei em Java 1.8, Windows 7 e unidades SSD e HDD.

Eu escrevi seis implementações diferentes:

rawParse : use BufferedInputStream sobre um FileInputStream e, em seguida, corte linhas lendo byte a byte. Isso superou qualquer outra abordagem de thread único, mas pode ser muito inconveniente para arquivos não ASCII.

lineReaderParse : use um BufferedReader sobre um FileReader, leia linha por linha, divida as linhas chamando String.split (). Isso é aproximadamente 20% mais lento que rawParse.

lineReaderParseParallel : É o mesmo que lineReaderParse, mas usa vários threads. Essa é a opção mais rápida em todos os casos.

nioFilesParse : use java.nio.files.Files.lines ()

nioAsyncParse : use um AsynchronousFileChannel com um manipulador de conclusão e um conjunto de encadeamentos.

nioMemoryMappedParse : use um arquivo mapeado na memória. Essa é realmente uma péssima idéia, gerando tempos de execução pelo menos três vezes maiores do que qualquer outra implementação.

Estes são os tempos médios para a leitura de 204 arquivos de 4 MB cada, em uma unidade i7 e SSD de quatro núcleos. Os arquivos são gerados em tempo real para evitar o cache do disco.

rawParse                11.10 sec
lineReaderParse         13.86 sec
lineReaderParseParallel  6.00 sec
nioFilesParse           13.52 sec
nioAsyncParse           16.06 sec
nioMemoryMappedParse    37.68 sec

Encontrei uma diferença menor do que eu esperava entre a execução em um SSD ou uma unidade de disco rígido, sendo o SSD aproximadamente 15% mais rápido. Isso pode ocorrer porque os arquivos são gerados em um disco rígido não fragmentado e são lidos sequencialmente; portanto, a unidade rotativa pode funcionar quase como um SSD.

Fiquei surpreso com o baixo desempenho da implementação nioAsyncParse. Eu implementei algo da maneira errada ou a implementação de vários threads usando o NIO e um manipulador de conclusão executa o mesmo (ou pior ainda) do que uma implementação de thread único com a API java.io. Além disso, a análise assíncrona com um CompletionHandler é muito mais longa em linhas de código e difícil de implementar corretamente do que uma implementação direta em fluxos antigos.

Agora, as seis implementações seguidas por uma classe contendo todas, mais um método parametrizável main () que permite brincar com o número de arquivos, tamanho e grau de simultaneidade. Observe que o tamanho dos arquivos varia mais menos 20%. Isso evita qualquer efeito, pois todos os arquivos têm exatamente o mesmo tamanho.

rawParse

public void rawParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    overrunCount = 0;
    final int dl = (int) ';';
    StringBuffer lineBuffer = new StringBuffer(1024);
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileInputStream fin = new FileInputStream(fl);
        BufferedInputStream bin = new BufferedInputStream(fin);
        int character;
        while((character=bin.read())!=-1) {
            if (character==dl) {

                // Here is where something is done with each line
                doSomethingWithRawLine(lineBuffer.toString());
                lineBuffer.setLength(0);
            }
            else {
                lineBuffer.append((char) character);
            }
        }
        bin.close();
        fin.close();
    }
}

public final void doSomethingWithRawLine(String line) throws ParseException {
    // What to do for each line
    int fieldNumber = 0;
    final int len = line.length();
    StringBuffer fieldBuffer = new StringBuffer(256);
    for (int charPos=0; charPos<len; charPos++) {
        char c = line.charAt(charPos);
        if (c==DL0) {
            String fieldValue = fieldBuffer.toString();
            if (fieldValue.length()>0) {
                switch (fieldNumber) {
                    case 0:
                        Date dt = fmt.parse(fieldValue);
                        fieldNumber++;
                        break;
                    case 1:
                        double d = Double.parseDouble(fieldValue);
                        fieldNumber++;
                        break;
                    case 2:
                        int t = Integer.parseInt(fieldValue);
                        fieldNumber++;
                        break;
                    case 3:
                        if (fieldValue.equals("overrun"))
                            overrunCount++;
                        break;
                }
            }
            fieldBuffer.setLength(0);
        }
        else {
            fieldBuffer.append(c);
        }
    }
}

lineReaderParse

public void lineReaderParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    String line;
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileReader frd = new FileReader(fl);
        BufferedReader brd = new BufferedReader(frd);

        while ((line=brd.readLine())!=null)
            doSomethingWithLine(line);
        brd.close();
        frd.close();
    }
}

public final void doSomethingWithLine(String line) throws ParseException {
    // Example of what to do for each line
    String[] fields = line.split(";");
    Date dt = fmt.parse(fields[0]);
    double d = Double.parseDouble(fields[1]);
    int t = Integer.parseInt(fields[2]);
    if (fields[3].equals("overrun"))
        overrunCount++;
}

lineReaderParseParallel

public void lineReaderParseParallel(final String targetDir, final int numberOfFiles, final int degreeOfParalelism) throws IOException, ParseException, InterruptedException {
    Thread[] pool = new Thread[degreeOfParalelism];
    int batchSize = numberOfFiles / degreeOfParalelism;
    for (int b=0; b<degreeOfParalelism; b++) {
        pool[b] = new LineReaderParseThread(targetDir, b*batchSize, b*batchSize+b*batchSize);
        pool[b].start();
    }
    for (int b=0; b<degreeOfParalelism; b++)
        pool[b].join();
}

class LineReaderParseThread extends Thread {

    private String targetDir;
    private int fileFrom;
    private int fileTo;
    private DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private int overrunCounter = 0;

    public LineReaderParseThread(String targetDir, int fileFrom, int fileTo) {
        this.targetDir = targetDir;
        this.fileFrom = fileFrom;
        this.fileTo = fileTo;
    }

    private void doSomethingWithTheLine(String line) throws ParseException {
        String[] fields = line.split(DL);
        Date dt = fmt.parse(fields[0]);
        double d = Double.parseDouble(fields[1]);
        int t = Integer.parseInt(fields[2]);
        if (fields[3].equals("overrun"))
            overrunCounter++;
    }

    @Override
    public void run() {
        String line;
        for (int f=fileFrom; f<fileTo; f++) {
            File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
            try {
            FileReader frd = new FileReader(fl);
            BufferedReader brd = new BufferedReader(frd);
            while ((line=brd.readLine())!=null) {
                doSomethingWithTheLine(line);
            }
            brd.close();
            frd.close();
            } catch (IOException | ParseException ioe) { }
        }
    }
}

nioFilesParse

public void nioFilesParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    for (int f=0; f<numberOfFiles; f++) {
        Path ph = Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        Consumer<String> action = new LineConsumer();
        Stream<String> lines = Files.lines(ph);
        lines.forEach(action);
        lines.close();
    }
}


class LineConsumer implements Consumer<String> {

    @Override
    public void accept(String line) {

        // What to do for each line
        String[] fields = line.split(DL);
        if (fields.length>1) {
            try {
                Date dt = fmt.parse(fields[0]);
            }
            catch (ParseException e) {
            }
            double d = Double.parseDouble(fields[1]);
            int t = Integer.parseInt(fields[2]);
            if (fields[3].equals("overrun"))
                overrunCount++;
        }
    }
}

nioAsyncParse

public void nioAsyncParse(final String targetDir, final int numberOfFiles, final int numberOfThreads, final int bufferSize) throws IOException, ParseException, InterruptedException {
    ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(numberOfThreads);
    ConcurrentLinkedQueue<ByteBuffer> byteBuffers = new ConcurrentLinkedQueue<ByteBuffer>();

    for (int b=0; b<numberOfThreads; b++)
        byteBuffers.add(ByteBuffer.allocate(bufferSize));

    for (int f=0; f<numberOfFiles; f++) {
        consumerThreads.acquire();
        String fileName = targetDir+filenamePreffix+String.valueOf(f)+".txt";
        AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(fileName), EnumSet.of(StandardOpenOption.READ), pool);
        BufferConsumer consumer = new BufferConsumer(byteBuffers, fileName, bufferSize);
        channel.read(consumer.buffer(), 0l, channel, consumer);
    }
    consumerThreads.acquire(numberOfThreads);
}


class BufferConsumer implements CompletionHandler<Integer, AsynchronousFileChannel> {

        private ConcurrentLinkedQueue<ByteBuffer> buffers;
        private ByteBuffer bytes;
        private String file;
        private StringBuffer chars;
        private int limit;
        private long position;
        private DateFormat frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        public BufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers, String fileName, int bufferSize) {
            buffers = byteBuffers;
            bytes = buffers.poll();
            if (bytes==null)
                bytes = ByteBuffer.allocate(bufferSize);

            file = fileName;
            chars = new StringBuffer(bufferSize);
            frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            limit = bufferSize;
            position = 0l;
        }

        public ByteBuffer buffer() {
            return bytes;
        }

        @Override
        public synchronized void completed(Integer result, AsynchronousFileChannel channel) {

            if (result!=-1) {
                bytes.flip();
                final int len = bytes.limit();
                int i = 0;
                try {
                    for (i = 0; i < len; i++) {
                        byte by = bytes.get();
                        if (by=='\n') {
                            // ***
                            // The code used to process the line goes here
                            chars.setLength(0);
                        }
                        else {
                                chars.append((char) by);
                        }
                    }
                }
                catch (Exception x) {
                    System.out.println(
                        "Caught exception " + x.getClass().getName() + " " + x.getMessage() +
                        " i=" + String.valueOf(i) + ", limit=" + String.valueOf(len) +
                        ", position="+String.valueOf(position));
                }

                if (len==limit) {
                    bytes.clear();
                    position += len;
                    channel.read(bytes, position, channel, this);
                }
                else {
                    try {
                        channel.close();
                    }
                    catch (IOException e) {
                    }
                    consumerThreads.release();
                    bytes.clear();
                    buffers.add(bytes);
                }
            }
            else {
                try {
                    channel.close();
                }
                catch (IOException e) {
                }
                consumerThreads.release();
                bytes.clear();
                buffers.add(bytes);
            }
        }

        @Override
        public void failed(Throwable e, AsynchronousFileChannel channel) {
        }
};

IMPLEMENTAÇÃO RUNNABLE COMPLETA DE TODOS OS CASOS

https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java

Serg M Ten
fonte
24

Aqui estão os três métodos de trabalho e testados:

Usando BufferedReader

package io;
import java.io.*;
public class ReadFromFile2 {
    public static void main(String[] args)throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        BufferedReader br = new BufferedReader(new FileReader(file));
        String st;
        while((st=br.readLine()) != null){
            System.out.println(st);
        }
    }
}

Usando Scanner

package io;

import java.io.File;
import java.util.Scanner;

public class ReadFromFileUsingScanner {
    public static void main(String[] args) throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        Scanner sc = new Scanner(file);
        while(sc.hasNextLine()){
            System.out.println(sc.nextLine());
        }
    }
}

Usando FileReader

package io;
import java.io.*;
public class ReadingFromFile {

    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("C:\\Users\\pankaj\\Desktop\\test.java");
        int i;
        while ((i=fr.read()) != -1){
            System.out.print((char) i);
        }
    }
}

Leia o arquivo inteiro sem um loop usando a Scannerclasse

package io;

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

public class ReadingEntireFileWithoutLoop {

    public static void main(String[] args) throws FileNotFoundException {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        Scanner sc = new Scanner(file);
        sc.useDelimiter("\\Z");
        System.out.println(sc.next());
    }
}
pankaj
fonte
1
Como dar um caminho se as pastas estiverem presentes dentro do projeto?
Kavipriya
2
Que tal java.nio.file.Files? Podemos agora usar apenas readAllLines, readAllBytese lines.
Claude Martin
21

Os métodos org.apache.commons.io.FileUtilstambém podem ser muito úteis, por exemplo:

/**
 * Reads the contents of a file line by line to a List
 * of Strings using the default encoding for the VM.
 */
static List readLines(File file)
Claude
fonte
Ou, se você preferir o Guava (uma biblioteca mais moderna e com manutenção ativa), ele possui utilitários semelhantes na classe Arquivos . Exemplos simples nesta resposta .
Jonik
1
ou você simplesmente usa o método embutido para obter todas as linhas: docs.oracle.com/javase/7/docs/api/java/nio/file/…
kritzikratzi
O link no apache commons parece morto.
Kebs # 6/17
17

O que você quer fazer com o texto? O arquivo é pequeno o suficiente para caber na memória? Eu tentaria encontrar a maneira mais simples de lidar com o arquivo para suas necessidades. A biblioteca FileUtils é muito adequada para isso.

for(String line: FileUtils.readLines("my-text-file"))
    System.out.println(line);
Peter Lawrey
fonte
2
ele também está embutido no Java7: docs.oracle.com/javase/7/docs/api/java/nio/file/...
kritzikratzi
@ PeterLawrey provavelmente significa org.apache.commons.io.FileUtils. O link do Google pode alterar o conteúdo ao longo do tempo, à medida que o significado mais difundido muda, mas isso corresponde à sua consulta e parece correto.
Palec 15/02/2015
2
Infelizmente, hoje em dia não existe readLines(String)e readLines(File)é preterido em favor de readLines(File, Charset). A codificação pode ser fornecida também como uma sequência.
Palec 15/02/2015
12

Documentei 15 maneiras de ler um arquivo em Java e testei sua velocidade com vários tamanhos de arquivo - de 1 KB a 1 GB e aqui estão as três principais maneiras de fazer isso:

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

    Testado para funcionar em Java 7, 8 e 9.

    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-10KB.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.io.BufferedReader.readLine()

    Testado para funcionar em Java 7, 8, 9.

    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-10KB.txt";
        FileReader fileReader = new FileReader(fileName);
    
        try (BufferedReader bufferedReader = new BufferedReader(fileReader)) {
          String line;
          while((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
          }
        }
      }
    }
  3. java.nio.file.Files.lines()

    Isso foi testado para funcionar no Java 8 e 9, mas não funcionará no Java 7 devido ao requisito de expressão lambda.

    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-10KB.txt";
        File file = new File(fileName);
    
        try (Stream linesStream = Files.lines(file.toPath())) {
          linesStream.forEach(line -> {
            System.out.println(line);
          });
        }
      }
    }
gomisha
fonte
9

Abaixo está um exemplo de como fazê-lo da maneira Java 8. Supondo que o text.txtarquivo esteja na raiz do diretório do projeto do Eclipse.

Files.lines(Paths.get("text.txt")).collect(Collectors.toList());
Zeus
fonte
7

Usando BufferedReader:

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

BufferedReader br;
try {
    br = new BufferedReader(new FileReader("/fileToRead.txt"));
    try {
        String x;
        while ( (x = br.readLine()) != null ) {
            // Printing out each line in the file
            System.out.println(x);
        }
    }
    catch (IOException e) {
        e.printStackTrace();
    }
}
catch (FileNotFoundException e) {
    System.out.println(e);
    e.printStackTrace();
}
Neo
fonte
7

Isso é basicamente o mesmo que a resposta de Jesus Ramos, exceto com File em vez de FileReader mais iteração para percorrer o conteúdo do arquivo.

Scanner in = new Scanner(new File("filename.txt"));

while (in.hasNext()) { // Iterates each line in the file
    String line = in.nextLine();
    // Do something with line
}

in.close(); // Don't forget to close resource leaks

... joga FileNotFoundException

ThisClark
fonte
3
Arquivo x FileReader: com um FileReader, o arquivo deve existir e as permissões do sistema operacional devem permitir o acesso. Com um arquivo, é possível testar essas permissões ou verificar se o arquivo é um diretório. O arquivo possui funções úteis: isFile (), isDirectory (), listFiles (), canExecute (), canRead (), canWrite (), existe (), mkdir (), delete (). File.createTempFile () grava no diretório temporário padrão do sistema. Este método retornará um objeto de arquivo que pode ser usado para abrir objetos FileOutputStream, etc. source
ThisClark
7

As classes de fluxo em buffer têm muito mais desempenho na prática, tanto que a API NIO.2 inclui métodos que retornam especificamente essas classes de fluxo, em parte para encorajá-lo a sempre usar fluxos em buffer em seu aplicativo.

Aqui está um exemplo:

Path path = Paths.get("/myfolder/myfile.ext");
try (BufferedReader reader = Files.newBufferedReader(path)) {
    // Read from the stream
    String currentLine = null;
    while ((currentLine = reader.readLine()) != null)
        //do your code here
} catch (IOException e) {
    // Handle file I/O exception...
}

Você pode substituir este código

BufferedReader reader = Files.newBufferedReader(path);

com

BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));

Eu recomendo este artigo para aprender os principais usos do Java NIO e IO.

Imar
fonte
6

Provavelmente não tão rápido quanto na E / S em buffer, mas bastante conciso:

    String content;
    try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
        content = scanner.next();
    }

O \Zpadrão informa Scannerque o delimitador é EOF.

David Soroko
fonte
1
Uma resposta muito relacionada e já existente é de Jesus Ramos.
Palec
1
É verdade que: if(scanner.hasNext()) content = scanner.next();
David Soroko 13/08/2015
1
Isso falha para mim no Android 4.4. Apenas 1024 bytes são lidos. YMMV.
Roger Keays
3

Ainda não o vejo mencionado nas outras respostas até agora. Mas se "Melhor" significa velocidade, o novo Java I / O (NIO) pode fornecer o desempenho mais rápido, mas nem sempre o mais fácil de descobrir para quem está aprendendo.

http://download.oracle.com/javase/tutorial/essential/io/file.html

jzd
fonte
Você deveria ter declarado como o seu feito e não para dar um link a seguir
Orar
3

A maneira mais simples de ler dados de um arquivo em Java é usar a classe File para ler o arquivo e a classe Scanner para ler o conteúdo do arquivo.

public static void main(String args[])throws Exception
{
   File f = new File("input.txt");
   takeInputIn2DArray(f);
}

public static void takeInputIn2DArray(File f) throws Exception
{
    Scanner s = new Scanner(f);
    int a[][] = new int[20][20];
    for(int i=0; i<20; i++)
    {
        for(int j=0; j<20; j++)
        {
            a[i][j] = s.nextInt();
        }
    }
}

PS: Não esqueça de importar java.util. *; para o Scanner funcionar.

anadir47
fonte
2

O Goiaba fornece uma linha para isso:

import com.google.common.base.Charsets;
import com.google.common.io.Files;

String contents = Files.toString(filePath, Charsets.UTF_8);
rahul mehra
fonte
2

Esta pode não ser a resposta exata para a pergunta. É apenas outra maneira de ler um arquivo em que você não especifica explicitamente o caminho para o seu arquivo no código Java e, em vez disso, lê-o como um argumento da linha de comandos.

Com o seguinte código,

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class InputReader{

    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s="";
        while((s=br.readLine())!=null){
            System.out.println(s);
        }
    }
}

vá em frente e execute-o com:

java InputReader < input.txt

Isso leria o conteúdo input.txte o imprimiria no seu console.

Você também pode System.out.println()gravar em um arquivo específico através da linha de comando da seguinte maneira:

java InputReader < input.txt > output.txt

Isso iria ler input.txte escrever para output.txt.

Adit A. Pillai
fonte
2

Você pode usar readAllLines e o joinmétodo para obter todo o conteúdo do arquivo em uma linha:

String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));

Ele usa a codificação UTF-8 por padrão, que lê os dados ASCII corretamente.

Além disso, você pode usar o readAllBytes:

String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);

Eu acho que o readAllBytes é mais rápido e mais preciso, porque não substitui a nova linha \ne também pode ser a nova linha \r\n. Depende das suas necessidades, qual delas é adequada.

Mostafa Vatanpour
fonte
1

Para aplicativos da Web Maven baseados em JSF, basta usar o ClassLoader e a Resourcespasta para ler qualquer arquivo que você desejar:

  1. Coloque qualquer arquivo que você deseja ler na pasta Recursos.
  2. Coloque a dependência do Apache Commons IO em seu POM:

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-io</artifactId>
        <version>1.3.2</version>
    </dependency>
  3. Use o código abaixo para lê-lo (por exemplo, abaixo está lendo em um arquivo .json):

    String metadata = null;
    FileInputStream inputStream;
    try {
    
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        inputStream = (FileInputStream) loader
                .getResourceAsStream("/metadata.json");
        metadata = IOUtils.toString(inputStream);
        inputStream.close();
    }
    catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return metadata;

Você pode fazer o mesmo com arquivos de texto, arquivos .properties, esquemas XSD , etc.

Análise Fuzzy
fonte
Você não pode usar isso em 'qualquer arquivo que desejar'. Você pode usá-lo apenas para recursos que foram empacotados no arquivo JAR ou WAR.
Marquês de Lorne
1

Os Cactoos oferecem uma única linha declarativa:

new TextOf(new File("a.txt")).asString();
yegor256
fonte
0

Use Java kiss se isso for sobre simplicidade de estrutura:

import static kiss.API.*;

class App {
  void run() {
    String line;
    try (Close in = inOpen("file.dat")) {
      while ((line = readLine()) != null) {
        println(line);
      }
    }
  }
}
Warren MacEvoy
fonte
0
import java.util.stream.Stream;
import java.nio.file.*;
import java.io.*;

class ReadFile {

 public static void main(String[] args) {

    String filename = "Test.txt";

    try(Stream<String> stream = Files.lines(Paths.get(filename))) {

          stream.forEach(System.out:: println);

    } catch (IOException e) {

        e.printStackTrace();
    }

 }

 }

Basta usar o java 8 Stream.

Archit Bhadauria
fonte
0
try {
  File f = new File("filename.txt");
  Scanner r = new Scanner(f);  
  while (r.hasNextLine()) {
    String data = r.nextLine();
    JOptionPane.showMessageDialog(data);
  }
  r.close();
} catch (FileNotFoundException ex) {
  JOptionPane.showMessageDialog("Error occurred");
  ex.printStackTrace();
}
Fridjato Part Fridjat
fonte
0

O método mais intuitivo é introduzido no Java 11 Files.readString

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String args[]) throws IOException {
        String content = Files.readString(Paths.get("D:\\sandbox\\mvn\\my-app\\my-app.iml"));
        System.out.print(content);
    }
}

PHP tem esse luxo de décadas atrás! ☺

PHPst
fonte
-3

Este código que eu programei é muito mais rápido para arquivos muito grandes:

public String readDoc(File f) {
    String text = "";
    int read, N = 1024 * 1024;
    char[] buffer = new char[N];

    try {
        FileReader fr = new FileReader(f);
        BufferedReader br = new BufferedReader(fr);

        while(true) {
            read = br.read(buffer, 0, N);
            text += new String(buffer, 0, read);

            if(read < N) {
                break;
            }
        }
    } catch(Exception ex) {
        ex.printStackTrace();
    }

    return text;
}
Juan Carlos Kuri Pinto
fonte
10
Muito mais rápido, duvido, se você usar uma concatenação simples de seqüências de caracteres em vez de um StringBuilder ...
#
6
Penso que o principal ganho de velocidade é a leitura em blocos de 1 MB (1024 * 1024). No entanto, você pode fazer o mesmo simplesmente passando 1024 * 1024 como segundo argumento para o construtor BufferedReader.
Gb96
3
Eu não acredito que isso seja testado. o uso +=dessa maneira fornece complexidade quadrática (!) para uma tarefa que deve ser complexidade linear. isso começará a rastrear arquivos com mais de alguns mb. Para contornar isso, você deve manter os blocos de texto em uma lista <string> ou usar o construtor de string mencionado acima.
kritzikratzi
5
Muito mais rápido que o que? Certamente não é mais rápido do que anexar a um StringBuffer. -1
Marquês de Lorne
1
@ gb96 Pensei o mesmo sobre tamanhos de buffer, mas o experimento detalhado nesta pergunta deu resultados surpreendentes em um contexto semelhante: um buffer de 16 KB era consistentemente e visivelmente mais rápido.
chiastic-security 12/09/14
-3
String fileName = 'yourFileFullNameWithPath';
File file = new File(fileName); // Creates a new file object for your file
FileReader fr = new FileReader(file);// Creates a Reader that you can use to read the contents of a file read your file
BufferedReader br = new BufferedReader(fr); //Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.

O conjunto de linhas acima pode ser escrito em uma única linha como:

BufferedReader br = new BufferedReader(new FileReader("file.txt")); // Optional

Adicionando ao construtor de strings (se o seu arquivo for enorme, é recomendável usar o construtor de strings, caso contrário, use o objeto String normal)

try {
        StringBuilder sb = new StringBuilder();
        String line = br.readLine();

        while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
        }
        String everything = sb.toString();
        } finally {
        br.close();
    }
Vaibhav Rai
fonte