Estou usando o idioma abaixo há algum tempo. E parece ser o mais difundido, pelo menos nos sites que visitei.

Existe uma maneira melhor / diferente de ler um arquivo em uma string em Java?

private String readFile(String file) throws IOException {
    BufferedReader reader = new BufferedReader(new FileReader (file));
    String         line = null;
    StringBuilder  stringBuilder = new StringBuilder();
    String         ls = System.getProperty("line.separator");

    try {
        while((line = reader.readLine()) != null) {
            stringBuilder.append(line);
            stringBuilder.append(ls);
        }

        return stringBuilder.toString();
    } finally {
        reader.close();
    }
}

Leia todo o texto de um arquivo

O Java 11 adicionou o método readString () para ler arquivos pequenos como um String, preservando os terminadores de linha:

String content = Files.readString(path, StandardCharsets.US_ASCII);

Para versões entre Java 7 e 11, aqui está um idioma compacto e robusto, agrupado em um método utilitário:

static String readFile(String path, Charset encoding) 
  throws IOException 
{
  byte[] encoded = Files.readAllBytes(Paths.get(path));
  return new String(encoded, encoding);
}

Ler linhas de texto de um arquivo

O Java 7 adicionou um método de conveniência para ler um arquivo como linhas de texto, representadas como a List<String>. Essa abordagem é "com perda" porque os separadores de linha são removidos do final de cada linha.

List<String> lines = Files.readAllLines(Paths.get(path), encoding);

O Java 8 adicionou o Files.lines()método para produzir a Stream<String>. Novamente, esse método está com perdas porque os separadores de linha são removidos. Se um IOExceptionfor encontrado durante a leitura do arquivo, ele será agrupado em um UncheckedIOException, já Streamque não aceita lambdas que geram exceções verificadas.

try (Stream<String> lines = Files.lines(path, encoding)) {
  lines.forEach(System.out::println);
}

Isso Streamprecisa de uma close()ligação; isso está mal documentado na API e suspeito que muitas pessoas nem percebem que Streamtem umclose() método. Certifique-se de usar um bloco ARM, como mostrado.

Se você estiver trabalhando com uma fonte que não seja um arquivo, poderá usar o lines()método emBufferedReader vez disso.

Utilização de memória

O primeiro método, que preserva as quebras de linha, pode exigir temporariamente memória várias vezes o tamanho do arquivo, porque por um curto período de tempo o conteúdo do arquivo bruto (uma matriz de bytes) e os caracteres decodificados (cada um com 16 bits, mesmo que codificado) 8 bits no arquivo) residem na memória de uma só vez. É mais seguro aplicar a arquivos que você sabe serem pequenos em relação à memória disponível.

O segundo método, linhas de leitura, geralmente é mais eficiente em memória, porque o buffer de bytes de entrada para decodificação não precisa conter o arquivo inteiro. No entanto, ainda não é adequado para arquivos muito grandes em relação à memória disponível.

Para ler arquivos grandes, você precisa de um design diferente para o seu programa, que leia um pedaço de texto de um fluxo, o processe e depois passe para o próximo, reutilizando o mesmo bloco de memória de tamanho fixo. Aqui, "grande" depende das especificações do computador. Atualmente, esse limite pode ser de muitos gigabytes de RAM. O terceiro método, usando a, Stream<String>é uma maneira de fazer isso, se os "registros" de entrada forem linhas individuais. (Usar o readLine()método de BufferedReaderé o equivalente processual a essa abordagem.)

Codificação de caracteres

Uma coisa que está faltando na amostra na postagem original é a codificação de caracteres. Existem alguns casos especiais em que o padrão da plataforma é o que você deseja, mas eles são raros e você deve justificar sua escolha.

A StandardCharsetsclasse define algumas constantes para as codificações necessárias para todos os tempos de execução do Java:

String content = readFile("test.txt", StandardCharsets.UTF_8);

O padrão da plataforma está disponível naCharset própria classe :

String content = readFile("test.txt", Charset.defaultCharset());

Nota: Esta resposta substitui amplamente minha versão do Java 6. O utilitário do Java 7 simplifica com segurança o código, e a resposta antiga, que usava um buffer de bytes mapeados, impedia que o arquivo lido fosse excluído até que o buffer mapeado fosse coletado de lixo. Você pode visualizar a versão antiga através do link "editado" nesta resposta.

Se você deseja usar uma biblioteca externa, consulte o Apache Commons IO (200KB JAR). Ele contém um org.apache.commons.io.FileUtils.readFileToString()método que permite ler um inteiro Fileem um Stringcom uma linha de código.

Exemplo:

import java.io.*;
import java.nio.charset.*;
import org.apache.commons.io.*;

public String readFile() throws IOException {
    File file = new File("data.txt");
    return FileUtils.readFileToString(file, StandardCharsets.UTF_8);
}

Uma solução muito enxuta baseada em Scanner:

Scanner scanner = new Scanner( new File("poem.txt") );
String text = scanner.useDelimiter("\\A").next();
scanner.close(); // Put this call in a finally block

Ou, se você deseja definir o conjunto de caracteres:

Scanner scanner = new Scanner( new File("poem.txt"), "UTF-8" );
String text = scanner.useDelimiter("\\A").next();
scanner.close(); // Put this call in a finally block

Ou, com um bloco try-with-resources , que chamará scanner.close()você:

try (Scanner scanner = new Scanner( new File("poem.txt"), "UTF-8" )) {
    String text = scanner.useDelimiter("\\A").next();
}

Lembre-se de que o Scannerconstrutor pode lançar um IOException. E não se esqueça de importar java.ioe java.util.

Fonte: Blog de Pat Niemeyer

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;

String content = new String(Files.readAllBytes(Paths.get("readMe.txt")), StandardCharsets.UTF_8);

desde o java 7, você pode fazer dessa maneira.

Se você estiver procurando por uma alternativa que não envolva uma biblioteca de terceiros (por exemplo, Commons I / O ), use a classe Scanner :

private String readFile(String pathname) throws IOException {

    File file = new File(pathname);
    StringBuilder fileContents = new StringBuilder((int)file.length());        

    try (Scanner scanner = new Scanner(file)) {
        while(scanner.hasNextLine()) {
            fileContents.append(scanner.nextLine() + System.lineSeparator());
        }
        return fileContents.toString();
    }
}

A goiaba tem um método semelhante ao do Commons IOUtils que Willi aus Rohr mencionou:

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

// ...

String text = Files.toString(new File(path), Charsets.UTF_8);

EDIT by PiggyPiglet
Files#toString está obsoleto e com a remoção do Octobor 2019. Em vez disso, use Files.asCharSource(new File(path), StandardCharsets.UTF_8).read();

EDIT por Oscar Reyes

Este é o código subjacente (simplificado) da biblioteca citada:

InputStream in = new FileInputStream(file);
byte[] b  = new byte[file.length()];
int len = b.length;
int total = 0;

while (total < len) {
  int result = in.read(b, total, len - total);
  if (result == -1) {
    break;
  }
  total += result;
}

return new String( b , Charsets.UTF_8 );

Editar (por Jonik): O texto acima não corresponde ao código fonte das versões recentes do Guava. Para a fonte atual, consulte as classes Arquivos , CharStreams , ByteSource e CharSource no pacote com.google.common.io .

import java.nio.file.Files;

.......

 String readFile(String filename) {
            File f = new File(filename);
            try {
                byte[] bytes = Files.readAllBytes(f.toPath());
                return new String(bytes,"UTF-8");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return "";
    }

Se você precisar de um processamento de sequência (processamento paralelo), o Java 8 possui a excelente API de Stream.

String result = Files.lines(Paths.get("file.txt"))
                    .parallel() // for parallel processing 
                    .map(String::trim) // to change line   
                    .filter(line -> line.length() > 2) // to filter some lines by a predicate                        
                    .collect(Collectors.joining()); // to join lines

Mais exemplos estão disponíveis nas amostras JDK sample/lambda/BulkDataOperationsque podem ser baixadas da página de download do Oracle Java SE 8

Outro exemplo de um liner

String out = String.join("\n", Files.readAllLines(Paths.get("file.txt")));

Esse código normalizará as quebras de linha, que podem ou não ser o que você realmente deseja fazer.

Aqui está uma alternativa que não faz isso e que é (IMO) mais simples de entender do que o código NIO (embora ainda use java.nio.charset.Charset):

public static String readFile(String file, String csName)
            throws IOException {
    Charset cs = Charset.forName(csName);
    return readFile(file, cs);
}

public static String readFile(String file, Charset cs)
            throws IOException {
    // No real need to close the BufferedReader/InputStreamReader
    // as they're only wrapping the stream
    FileInputStream stream = new FileInputStream(file);
    try {
        Reader reader = new BufferedReader(new InputStreamReader(stream, cs));
        StringBuilder builder = new StringBuilder();
        char[] buffer = new char[8192];
        int read;
        while ((read = reader.read(buffer, 0, buffer.length)) > 0) {
            builder.append(buffer, 0, read);
        }
        return builder.toString();
    } finally {
        // Potential issue here: if this throws an IOException,
        // it will mask any others. Normally I'd use a utility
        // method which would log exceptions and swallow them
        stream.close();
    }        
}

Reuniu todas as maneiras possíveis para ler o arquivo como sequência do disco ou da rede.

• Goiaba: Google usando classes Resources,Files

  static Charset charset = com.google.common.base.Charsets.UTF_8;
  public static String guava_ServerFile( URL url ) throws IOException {
      return Resources.toString( url, charset );
  }
  public static String guava_DiskFile( File file ) throws IOException {
      return Files.toString( file, charset );
  }

• APACHE - COMMO IO usando as classes IOUtils, FileUtils

  static Charset encoding = org.apache.commons.io.Charsets.UTF_8;
  public static String commons_IOUtils( URL url ) throws IOException {
      java.io.InputStream in = url.openStream();
      try {
          return IOUtils.toString( in, encoding );
      } finally {
          IOUtils.closeQuietly(in);
      }
  }
  public static String commons_FileUtils( File file ) throws IOException {
      return FileUtils.readFileToString( file, encoding );
      /*List<String> lines = FileUtils.readLines( fileName, encoding );
      return lines.stream().collect( Collectors.joining("\n") );*/
  }

• Java 8 BufferReader usando API de Stream

  public static String streamURL_Buffer( URL url ) throws IOException {
      java.io.InputStream source = url.openStream();
      BufferedReader reader = new BufferedReader( new InputStreamReader( source ) );
      //List<String> lines = reader.lines().collect( Collectors.toList() );
      return reader.lines().collect( Collectors.joining( System.lineSeparator() ) );
  }
  public static String streamFile_Buffer( File file ) throws IOException {
      BufferedReader reader = new BufferedReader( new FileReader( file ) );
      return reader.lines().collect(Collectors.joining(System.lineSeparator()));
  }

• Classe de scanner com regex \A. que corresponde ao início da entrada.

  static String charsetName = java.nio.charset.StandardCharsets.UTF_8.toString();
  public static String streamURL_Scanner( URL url ) throws IOException {
      java.io.InputStream source = url.openStream();
      Scanner scanner = new Scanner(source, charsetName).useDelimiter("\\A");
      return scanner.hasNext() ? scanner.next() : "";
  }
  public static String streamFile_Scanner( File file ) throws IOException {
      Scanner scanner = new Scanner(file, charsetName).useDelimiter("\\A");
      return scanner.hasNext() ? scanner.next() : "";
  }

• Java 7 ( java.nio.file.Files.readAllBytes)

  public static String getDiskFile_Java7( File file ) throws IOException {
      byte[] readAllBytes = java.nio.file.Files.readAllBytes(Paths.get( file.getAbsolutePath() ));
      return new String( readAllBytes );
  }

• BufferedReaderusando InputStreamReader.

  public static String getDiskFile_Lines( File file ) throws IOException {
      StringBuffer text = new StringBuffer();
      FileInputStream fileStream = new FileInputStream( file );
      BufferedReader br = new BufferedReader( new InputStreamReader( fileStream ) );
      for ( String line; (line = br.readLine()) != null; )
          text.append( line + System.lineSeparator() );
      return text.toString();
  }

Exemplo com o método principal para acessar os métodos acima.

public static void main(String[] args) throws IOException {
    String fileName = "E:/parametarisation.csv";
    File file = new File( fileName );

    String fileStream = commons_FileUtils( file );
            // guava_DiskFile( file );
            // streamFile_Buffer( file );
            // getDiskFile_Java7( file );
            // getDiskFile_Lines( file );
    System.out.println( " File Over Disk : \n"+ fileStream );


    try {
        String src = "https://code.jquery.com/jquery-3.2.1.js";
        URL url = new URL( src );

        String urlStream = commons_IOUtils( url );
                // guava_ServerFile( url );
                // streamURL_Scanner( url );
                // streamURL_Buffer( url );
        System.out.println( " File Over Network : \n"+ urlStream );
    } catch (MalformedURLException e) {
        e.printStackTrace();
    }
}

@Vejo

• Maneiras de converter um InputStream em uma String

Se é um arquivo de texto, por que não usar o apache commons-io ?

Tem o seguinte método

public static String readFileToString(File file) throws IOException

Se você quiser as linhas como uma lista, use

public static List<String> readLines(File file) throws IOException

Desde o JDK 11:

String file = ...
Path path = Paths.get(file);
String content = Files.readString(path);
// Or readString(path, someCharset), if you need a Charset different from UTF-8

Para ler um arquivo como binário e converter no final

public static String readFileAsString(String filePath) throws IOException {
    DataInputStream dis = new DataInputStream(new FileInputStream(filePath));
    try {
        long len = new File(filePath).length();
        if (len > Integer.MAX_VALUE) throw new IOException("File "+filePath+" too large, was "+len+" bytes.");
        byte[] bytes = new byte[(int) len];
        dis.readFully(bytes);
        return new String(bytes, "UTF-8");
    } finally {
        dis.close();
    }
}

Com o Java 7, esta é minha opção preferida para ler um arquivo UTF-8:

String content = new String(Files.readAllBytes(Paths.get(filename)), "UTF-8");

Desde o Java 7, o JDK possui a nova java.nio.fileAPI, que fornece muitos atalhos, portanto nem sempre são necessárias bibliotecas de terceiros para operações simples de arquivo.

O Java tenta ser extremamente geral e flexível em tudo o que faz. Como resultado, algo que é relativamente simples em uma linguagem de script (seu código seria substituído por " open(file).read()" em python) é muito mais complicado. Parece não haver uma maneira mais curta de fazer isso, exceto usando uma biblioteca externa (como Willi aus Rohr mencionou). Suas opções:

• Use uma biblioteca externa.
• Copie esse código em todos os seus projetos.
• Crie sua própria mini-biblioteca, que contém funções que você usa com freqüência.

Sua melhor aposta é provavelmente a segunda, pois possui menos dependências.

Usando o JDK 8 ou superior:

nenhuma biblioteca externa usada

Você pode criar um novo objeto String a partir do conteúdo do arquivo (Usando classes do java.nio.filepacote):

public String readStringFromFile(String filePath) throws IOException {
    String fileContent = new String(Files.readAllBytes(Paths.get(filePath)));
    return fileContent;
}

Há uma variação no mesmo tema que usa um loop for, em vez de um while, para limitar o escopo da variável de linha. Se é "melhor" é uma questão de gosto pessoal.

for(String line = reader.readLine(); line != null; line = reader.readLine()) {
    stringBuilder.append(line);
    stringBuilder.append(ls);
}

Se você não tiver acesso à Filesclasse, poderá usar uma solução nativa.

static String readFile(File file, String charset)
        throws IOException
{
    FileInputStream fileInputStream = new FileInputStream(file);
    byte[] buffer = new byte[fileInputStream.available()];
    int length = fileInputStream.read(buffer);
    fileInputStream.close();
    return new String(buffer, 0, length, charset);
}

Uma solução flexível usando IOUtils do Apache commons-io em combinação com o StringWriter :

Reader input = new FileReader();
StringWriter output = new StringWriter();
try {
  IOUtils.copy(input, output);
} finally {
  input.close();
}
String fileContents = output.toString();

Funciona com qualquer leitor ou fluxo de entrada (não apenas com arquivos), por exemplo, ao ler de um URL.

Esteja ciente de que o uso fileInputStream.available()do número inteiro retornado não precisa representar o tamanho real do arquivo, mas a quantidade de bytes estimada que o sistema deve poder ler do fluxo sem bloquear as E / S. Uma maneira simples e segura pode ser assim

public String readStringFromInputStream(FileInputStream fileInputStream) {
    StringBuffer stringBuffer = new StringBuffer();
    try {
        byte[] buffer;
        while (fileInputStream.available() > 0) {
            buffer = new byte[fileInputStream.available()];
            fileInputStream.read(buffer);
            stringBuffer.append(new String(buffer, "ISO-8859-1"));
        }
    } catch (FileNotFoundException e) {
    } catch (IOException e) { }
    return stringBuffer.toString();
}

Deve-se considerar que essa abordagem não é adequada para codificações de caracteres de vários bytes, como UTF-8.

Este usa o método RandomAccessFile.readFully, parece estar disponível no JDK 1.0!

public static String readFileContent(String filename, Charset charset) throws IOException {
    RandomAccessFile raf = null;
    try {
        raf = new RandomAccessFile(filename, "r");
        byte[] buffer = new byte[(int)raf.length()];
        raf.readFully(buffer);
        return new String(buffer, charset);
    } finally {
        closeStream(raf);
    }
} 


private static void closeStream(Closeable c) {
    if (c != null) {
        try {
            c.close();
        } catch (IOException ex) {
            // do nothing
        }
    }
}

Você pode experimentar a classe Scanner e File, algumas soluções de linhas

 try
{
  String content = new Scanner(new File("file.txt")).useDelimiter("\\Z").next();
  System.out.println(content);
}
catch(FileNotFoundException e)
{
  System.out.println("not found!");
}

Usuário java.nio.Filespara ler todas as linhas de arquivo.

public String readFile() throws IOException {
        File fileToRead = new File("file path");
        List<String> fileLines = Files.readAllLines(fileToRead.toPath());
        return StringUtils.join(fileLines, StringUtils.EMPTY);
}

public static String slurp (final File file)
throws IOException {
    StringBuilder result = new StringBuilder();

    BufferedReader reader = new BufferedReader(new FileReader(file));

    try {
        char[] buf = new char[1024];

        int r = 0;

        while ((r = reader.read(buf)) != -1) {
            result.append(buf, 0, r);
        }
    }
    finally {
        reader.close();
    }

    return result.toString();
}

Ainda não posso comentar outras entradas, então deixarei aqui.

Uma das melhores respostas aqui ( https://stackoverflow.com/a/326448/1521167 ):

private String readFile(String pathname) throws IOException {

File file = new File(pathname);
StringBuilder fileContents = new StringBuilder((int)file.length());
Scanner scanner = new Scanner(file);
String lineSeparator = System.getProperty("line.separator");

try {
    while(scanner.hasNextLine()) {        
        fileContents.append(scanner.nextLine() + lineSeparator);
    }
    return fileContents.toString();
} finally {
    scanner.close();
}
}

ainda tem uma falha. Ele sempre coloca o novo caractere de linha no final da string, o que pode causar alguns erros estranhos. Minha sugestão é alterá-lo para:

    private String readFile(String pathname) throws IOException {
    File file = new File(pathname);
    StringBuilder fileContents = new StringBuilder((int) file.length());
    Scanner scanner = new Scanner(new BufferedReader(new FileReader(file)));
    String lineSeparator = System.getProperty("line.separator");

    try {
        if (scanner.hasNextLine()) {
            fileContents.append(scanner.nextLine());
        }
        while (scanner.hasNextLine()) {
            fileContents.append(lineSeparator + scanner.nextLine());
        }
        return fileContents.toString();
    } finally {
        scanner.close();
    }
}

Após Ctrl + F'ing após o Scanner, acho que a solução do Scanner também deve ser listada. Da maneira mais fácil de ler, fica assim:

public String fileToString(File file, Charset charset) {
  Scanner fileReader = new Scanner(file, charset);
  fileReader.useDelimiter("\\Z"); // \Z means EOF.
  String out = fileReader.next();
  fileReader.close();
  return out;
}

Se você usa o Java 7 ou mais recente (e realmente deveria) considere usar o try-with-resources para facilitar a leitura do código. Não há mais coisas pontilhadas espalhando tudo. Mas isso é principalmente uma escolha estilística.

Estou postando isso principalmente por completismo, pois se você precisar fazer muito isso, deve haver coisas em java.nio.file.Files que devem fazer o trabalho melhor.

Minha sugestão seria usar Files # readAllBytes (Path) para pegar todos os bytes e alimentá-lo com a nova String (byte [] Charset) para obter uma String em que você possa confiar. Charsets será mau para você durante a sua vida, então cuidado com isso agora.

Outros deram código e outras coisas, e eu não quero roubar sua glória. ;)

Usando esta biblioteca , é uma linha:

String data = IO.from(new File("data.txt")).toString();

Além disso, se o seu arquivo estiver dentro de um jar, você também poderá usar este:

public String fromFileInJar(String path) {
    try ( Scanner scanner 
            = new Scanner(getClass().getResourceAsStream(path))) {
        return scanner.useDelimiter("\\A").next();
    }
}

O caminho deve começar, / por exemplo, se o seu jar for

my.jar/com/some/thing/a.txt

Então você deseja invocá-lo assim:

String myTxt = fromFileInJar("/com/com/thing/a.txt");

Em uma linha (Java 8), supondo que você tenha um Reader:

String sMessage = String.join("\n", reader.lines().collect(Collectors.toList()));

Com base na resposta de @ erickson, você pode usar:

public String readAll(String fileName) throws IOException {
    List<String> lines = Files.readAllLines(new File(fileName).toPath());
    return String.join("\n", lines.toArray(new String[lines.size()]));
}