J'utilise l'idiome ci-dessous depuis un certain temps maintenant. Et il semble que ce soit le plus répandu, du moins sur les sites que j'ai visités.

Existe-t-il une manière meilleure / différente de lire un fichier dans une chaîne en 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();
    }
}

Lire tout le texte d'un fichier

Java 11 a ajouté la méthode readString () pour lire les petits fichiers en tant que String, en préservant les terminateurs de ligne:

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

Pour les versions entre Java 7 et 11, voici un idiome compact et robuste, enveloppé dans une méthode utilitaire:

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

Lire des lignes de texte à partir d'un fichier

Java 7 a ajouté une méthode pratique pour lire un fichier sous forme de lignes de texte, représentées par un List<String>. Cette approche est "avec perte" car les séparateurs de ligne sont retirés de la fin de chaque ligne.

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

Java 8 a ajouté la Files.lines()méthode pour produire un Stream<String>. Encore une fois, cette méthode est avec perte car les séparateurs de ligne sont supprimés. Si un IOExceptionest rencontré lors de la lecture du fichier, il est enveloppé dans un UncheckedIOException, car Streamn'accepte pas les lambdas qui lèvent des exceptions vérifiées.

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

Cela Streamnécessite un close()appel; cela est mal documenté sur l'API, et je soupçonne que beaucoup de gens ne remarquent même pas Streama une close()méthode. Assurez-vous d'utiliser un bloc ARM comme indiqué.

Si vous travaillez avec une source autre qu'un fichier, vous pouvez utiliser la lines()méthode dans à la BufferedReaderplace.

Utilisation de la mémoire

La première méthode, qui préserve les sauts de ligne, peut temporairement nécessiter de la mémoire plusieurs fois la taille du fichier, car pendant une courte période le contenu brut du fichier (un tableau d'octets) et les caractères décodés (chacun de 16 bits même s'il est codé comme 8 bits dans le fichier) résident en mémoire à la fois. Il est plus sûr d'appliquer aux fichiers que vous savez être petits par rapport à la mémoire disponible.

La deuxième méthode, la lecture des lignes, est généralement plus efficace en mémoire, car le tampon d'octets d'entrée pour le décodage n'a pas besoin de contenir le fichier entier. Cependant, il n'est toujours pas adapté aux fichiers très volumineux par rapport à la mémoire disponible.

Pour lire des fichiers volumineux, vous avez besoin d'une conception différente pour votre programme, une qui lit un morceau de texte à partir d'un flux, le traite, puis passe au suivant, en réutilisant le même bloc de mémoire de taille fixe. Ici, "grand" dépend des spécifications de l'ordinateur. De nos jours, ce seuil peut être de plusieurs gigaoctets de RAM. La troisième méthode, en utilisant un, Stream<String>est une façon de le faire, si vos «enregistrements» d'entrée se trouvent être des lignes individuelles. (En utilisant la readLine()méthode deBufferedReader est l'équivalent procédural de cette approche.)

Encodage de caractère

Une chose qui manque dans l'exemple de l'article d'origine est l'encodage des caractères. Il y a des cas spéciaux où la plate-forme par défaut est ce que vous voulez, mais ils sont rares, et vous devriez pouvoir justifier votre choix.

La StandardCharsetsclasse définit quelques constantes pour les encodages requis pour tous les runtimes Java:

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

La plate-forme par défaut est disponible dans la Charsetclasse elle - même:

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

Remarque: Cette réponse remplace largement ma version Java 6. L'utilitaire de Java 7 simplifie le code en toute sécurité et l'ancienne réponse, qui utilisait un tampon d'octets mappés, empêchait la suppression du fichier lu jusqu'à ce que le tampon mappé soit récupéré. Vous pouvez voir l'ancienne version via le lien "édité" sur cette réponse.

Si vous souhaitez utiliser une bibliothèque externe, consultez Apache Commons IO (200KB JAR). Il contient une org.apache.commons.io.FileUtils.readFileToString()méthode qui vous permet de lire un entier Filedans unString avec une seule ligne de code.

Exemple:

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);
}

Une solution très allégée basée sur 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, si vous souhaitez définir le jeu de caractères:

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, avec un bloc try-with-resources , qui scanner.close()vous demandera :

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

N'oubliez pas que le Scannerconstructeur peut lancer un IOException. Et n'oubliez pas d'importer java.ioet java.util.

Source: 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);

depuis java 7, vous pouvez le faire de cette façon.

Si vous recherchez une alternative qui n'implique pas de bibliothèque tierce (par exemple, Commons I / O ), vous pouvez utiliser la 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();
    }
}

La goyave a une méthode similaire à celle de Commons IOUtils que Willi aus Rohr a mentionnée:

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 obsolète et doit être supprimé en octobre 2019. Utilisez plutôt Files.asCharSource(new File(path), StandardCharsets.UTF_8).read();

EDIT par Oscar Reyes

Voici le code sous-jacent (simplifié) de la bibliothèque citée:

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 );

Edit (par Jonik): Ce qui précède ne correspond pas au code source des versions récentes de Guava. Pour la source actuelle, consultez les classes Files , CharStreams , ByteSource et CharSource dans le package 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 "";
    }

Si vous avez besoin d'un traitement de chaîne (traitement parallèle), Java 8 possède la grande API 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

D'autres exemples sont disponibles dans des exemples JDK sample/lambda/BulkDataOperationsqui peuvent être téléchargés à partir de la page de téléchargement d' Oracle Java SE 8

Un autre exemple de liner

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

Ce code normalisera les sauts de ligne, ce qui peut ou non être ce que vous voulez vraiment faire.

Voici une alternative qui ne fait pas cela, et qui est (IMO) plus simple à comprendre que le code NIO (bien qu'il utilise toujours 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();
    }        
}

Rassemblé toutes les façons possibles de lire le fichier sous forme de chaîne à partir du disque ou du réseau.

• Goyave: Google utilise des 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 - COMMONS IO utilisant les 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 utilisant Stream API

  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 avec regex \A. qui correspond au début de l'entrée.

  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 );
  }

• BufferedReaderen utilisant 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();
  }

Exemple avec la méthode principale pour accéder aux méthodes ci-dessus.

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();
    }
}

@voir

• Façons de convertir un InputStream en une chaîne

Si c'est un fichier texte, pourquoi ne pas utiliser apache commons-io ?

Il a la méthode suivante

public static String readFileToString(File file) throws IOException

Si vous voulez les lignes comme liste, utilisez

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

Depuis 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

Pour lire un fichier au format binaire et le convertir à la fin

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();
    }
}

Avec Java 7, c'est mon option préférée pour lire un fichier UTF-8:

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

Depuis Java 7, le JDK dispose de la nouvelle java.nio.fileAPI, qui fournit de nombreux raccourcis, de sorte que les bibliothèques tierces ne sont pas toujours nécessaires pour les opérations de fichiers simples.

Java tente d'être extrêmement général et flexible dans tout ce qu'il fait. Par conséquent, quelque chose qui est relativement simple dans un langage de script (votre code serait remplacé par " open(file).read()" en python) est beaucoup plus compliqué. Il ne semble pas y avoir de moyen plus court de le faire, sauf en utilisant une bibliothèque externe (comme Willi aus Rohr l'a mentionné). Vos options:

• Utilisez une bibliothèque externe.
• Copiez ce code dans tous vos projets.
• Créez votre propre mini-bibliothèque contenant les fonctions que vous utilisez souvent.

Votre meilleur pari est probablement le 2ème, car il a le moins de dépendances.

En utilisant JDK 8 ou supérieur:

aucune bibliothèque externe utilisée

Vous pouvez créer un nouvel objet String à partir du contenu du fichier (à l'aide des classes du java.nio.filepackage):

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

Il existe une variation sur le même thème qui utilise une boucle for, au lieu d'une boucle while, pour limiter la portée de la variable de ligne. Que ce soit "mieux" est une question de goût personnel.

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

Si vous n'avez pas accès à la Filesclasse, vous pouvez utiliser une solution native.

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);
}

Une solution flexible utilisant IOUtils d'Apache commons-io en combinaison avec StringWriter :

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

Il fonctionne avec n'importe quel lecteur ou flux d'entrée (pas seulement avec des fichiers), par exemple lors de la lecture à partir d'une URL.

Soyez conscient lorsque l'utilisation de fileInputStream.available()l'entier renvoyé ne doit pas représenter la taille réelle du fichier, mais plutôt la quantité supposée d'octets que le système devrait pouvoir lire à partir du flux sans bloquer les E / S. Un moyen simple et sûr pourrait ressembler à ceci

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();
}

Il convient de considérer que cette approche ne convient pas aux codages de caractères multi-octets comme UTF-8.

Celui-ci utilise la méthode RandomAccessFile.readFully, il semble être disponible depuis 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
        }
    }
}

Vous pouvez essayer Scanner and File class, une solution en quelques lignes

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

L'utilisateur java.nio.Filesdoit lire toutes les lignes du fichier.

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();
}

Je ne peux pas encore commenter d'autres entrées, je vais donc le laisser ici.

L'une des meilleures réponses ici ( 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();
}
}

a encore un défaut. Il met toujours un nouveau caractère de ligne à la fin de la chaîne, ce qui peut provoquer des bugs étranges. Ma suggestion est de le changer en:

    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();
    }
}

Après Ctrl + F après Scanner, je pense que la solution Scanner devrait aussi être listée. De la manière la plus facile à lire, cela se passe comme suit:

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;
}

Si vous utilisez Java 7 ou une version plus récente (et vous devriez vraiment le faire), envisagez d'utiliser try-with-resources pour faciliter la lecture du code. Plus de trucs étroits qui jonchent tout. Mais c'est surtout un choix stylistique.

Je poste cela principalement pour l'achèvement, car si vous avez besoin de faire beaucoup de choses, il devrait y avoir des choses dans java.nio.file.Files qui devraient faire le travail mieux.

Ma suggestion serait d'utiliser Files # readAllBytes (Path) pour récupérer tous les octets et de le nourrir dans une nouvelle chaîne (byte [] Charset) pour en extraire une chaîne en laquelle vous pouvez avoir confiance. Les jeux de caractères seront méchants pour vous au cours de votre vie, alors méfiez-vous de ce genre de choses maintenant.

D'autres ont donné du code et des trucs, et je ne veux pas voler leur gloire. ;)

En utilisant cette bibliothèque , c'est une ligne:

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

De plus, si votre fichier se trouve dans un bocal, vous pouvez également utiliser ceci:

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

Le chemin devrait commencer par / exemple si votre pot est

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

Ensuite, vous voulez l'invoquer comme ceci:

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

En une seule ligne (Java 8), en supposant que vous avez un Reader:

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

Sur la base de la réponse de @ erickson, vous pouvez utiliser:

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()]));
}