Comment créer une chaîne Java à partir du contenu d'un fichier?

j'utilise l'idiome ci-dessous depuis un certain temps maintenant. Et il semble être la plus répandue, au moins sur les sites que j'ai visité.

y a-t-il une meilleure/différente façon de lire un fichier dans une chaîne de caractères 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();
    }
}
1250
demandé sur nullpointer 2008-11-28 21:32:07
la source

30 ответов

lire tout le texte d'un fichier

voici un langage compact et robuste pour Java 7, 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 de commodité pour lire un fichier comme des lignes de texte, représenté comme un List<String> . Cette approche est "lossy" parce que les séparateurs de ligne sont dépouillés de l'extrémité de chaque ligne.

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

en Java 8, BufferedReader a ajouté une nouvelle méthode, lines() pour produire un Stream<String> . Si un IOException est rencontré lors de la lecture du fichier, il est enveloppé dans un UncheckedIOException , depuis Stream n'accepte pas lambdas qui jeter vérifié exceptions.

try (BufferedReader r = Files.newBufferedReader(path, encoding)) {
  r.lines().forEach(System.out::println);
}

il y a aussi une méthode Files.lines() qui fait quelque chose de très similaire, en retournant le Stream<String> directement. Mais je n'ai pas plaire. Le Stream nécessite un appel close() ; ceci est mal documenté sur L'API, et je soupçonne que beaucoup de gens ne remarquent même pas Stream a une méthode close() . Donc votre code ressemblerait beaucoup, comme ceci:

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

la différence est que vous avez un Stream assigné à une variable, et j'essaie d'éviter cela comme une pratique afin que je n'essaye pas accidentellement d'invoquer le flux deux fois.

utilisation de la mémoire

la première méthode, qui préserve les sauts de ligne, peut exiger Temporairement de la mémoire plusieurs fois la taille du fichier, parce que pendant un court moment le contenu du fichier brut (un tableau d'octets), et les caractères décodés (dont chacun est de 16 bits même si encodé en 8 bits dans le fichier) résident dans la mémoire à la fois. Il est plus sûr d'appliquer aux fichiers que vous savez être petit 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 byte d'entrée pour le décodage n'a pas besoin de contenir tout le fichier. Cependant, il n'est toujours pas adapté pour les fichiers qui sont très grands par rapport à la mémoire disponible.

pour lire de grands fichiers, vous avez besoin d'un design différent pour votre programme, celui qui lit un morceau de texte d'un flux, le traite, puis passe à l'autre, en réutilisant le même bloc de mémoire de taille fixe. Ici, "Grand" dépend des spécifications de l'ordinateur. Aujourd'hui, ce seuil peut-être plusieurs gigaoctets de RAM. La troisième méthode, en utilisant un Stream<String> est une façon de le faire, si votre entrée" enregistre " se trouve être des lignes individuelles. (L'utilisation de la méthode readLine() de BufferedReader est l'équivalent procédural de cette approche.)

codage de caractères

une chose qui manque à l'échantillon dans le post original 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 être en mesure de justifier vos choix.

Le StandardCharsets class définir des constantes pour les codages nécessaires de tous les temps d'exécution Java:

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

La plate-forme par défaut est disponible à partir de le Charset classe lui-même:

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

Note: Cette réponse remplace largement ma version Java 6. L'utilité de Java 7 simplifie en toute sécurité le code, et l'ancienne réponse, qui utilisait un tampon en octets cartographié, empêchait le fichier qui était lu d'être supprimé jusqu'à ce que le tampon cartographié soit collecté. Vous pouvez voir l'ancienne version via le lien "modifié" sur cette réponse.

1284
répondu erickson 2018-02-21 01:51:08
la source

Communes FileUtils.readFileToString :

public static String readFileToString(File file)
                       throws IOException

lit le contenu d'un fichier dans une chaîne en utilisant le codage par défaut pour la VM. Le dossier est toujours fermé.

paramètres:

  • file - le fichier à lire, ne doit pas être null

Returns: le contenu du fichier, jamais null

lancers: - IOException - en cas d'erreur d'E/S

depuis: Commons IO 1.3.1

le code utilisé (indirectement) par cette classe est:

IOUtils.java sous Licence Apache 2.0 .

public static long copyLarge(InputStream input, OutputStream output)
       throws IOException {
   byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
   long count = 0;
   int n = 0;
   while (-1 != (n = input.read(buffer))) {
       output.write(buffer, 0, n);
       count += n;
   }
   return count;
}

il est très similaire à celui utilisé par Ritche_W.

300
répondu Willi aus Rohr 2016-08-30 04:19:22
la source

à Partir de cette page un très maigre solution:

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

ou

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

si vous voulez régler le jeu de caractères

163
répondu Pablo Grisafi 2016-07-25 18:33:37
la source

si vous cherchez une alternative qui n'implique pas une bibliothèque tierce partie (par exemple Commons I / O ), vous pouvez utiliser le Scanner classe:

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();
    }
}
69
répondu Dónal 2016-04-29 00:39:07
la source

Goyave a une méthode similaire à celle de la Chambre des communes IOUtils que Willi aus Rohr a mentionné:

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

// ...

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

EDIT par Oscar Reyes

C'est le code (simplifié) sous-jacent sur 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 );

Modifier (par Jonik): Le ci-dessus ne correspond pas au code source de ces dernières Goyave versions. Pour la source courante, voir les classes Files , CharStreams , ByteSource et CharSource in com.google.commun.io paquet.

64
répondu OscarRyz 2016-11-21 22:02:06
la source
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 "";
    }
50
répondu user590444 2012-04-16 18:33:59
la source
String content = new String(Files.readAllBytes(Paths.get("readMe.txt")), "UTF-8");

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

47
répondu Jobin Joseph 2018-07-18 20:06:27
la source

ce code va normaliser les sauts de ligne, ce qui peut être ou non 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();
    }        
}
45
répondu Jon Skeet 2017-09-26 07:07:48
la source

si vous avez besoin d'un traitement de chaîne (traitement parallèle) Java 8 a l'API great 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 les exemples de JDK sample/lambda/BulkDataOperations qui peuvent être téléchargés à partir de Oracle Java SE 8 page de téléchargement

un autre exemple de doublure

String out = String.join("\n", Files.readAllLines(Paths.get("file.txt")));
44
répondu Andrei N 2016-09-02 14:31:21
la source

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 une liste, utilisez

public static List<String> readLines(File file) throws IOException
22
répondu Home in Time 2017-09-26 07:09:46
la source

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 a la nouvelle API java.nio.file , qui fournit de nombreux raccourcis, de sorte que les bibliothèques tierces ne sont pas toujours nécessaires pour les opérations simples de fichiers.

15
répondu Moritz Petersen 2016-05-06 12:03:21
la source

Java tente d'être extrêmement général et flexible dans tout ce qu'il fait. En conséquence, 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 façon plus courte de le faire, sauf en utilisant une bibliothèque externe (comme Willi aus Rohr mentionné). Vos options:

  • utilisez une bibliothèque externe.
  • Copy ce code dans tous vos projets.
  • créez votre propre mini-bibliothèque qui contient des fonctions que vous utilisez souvent.

votre meilleur pari est probablement le 2e, car il a les moins de dépendances.

14
répondu Claudiu 2017-05-23 14:47:32
la source

pour lire un fichier en binaire et 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();
    }
}
14
répondu Peter Lawrey 2010-04-18 11:34:29
la source

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
12
répondu leventov 2018-06-26 17:26:44
la source

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

  • Goyave: Google en utilisant 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 );
    }
    

  • BufferedReader en 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

8
répondu Yash 2018-08-17 09:23:38
la source

il y a 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 line. Si c'est "mieux" est une question de goût personnel.

for(String line = reader.readLine(); line != null; line = reader.readLine()) {
    stringBuilder.append(line);
    stringBuilder.append(ls);
}
7
répondu Dan Dyer 2013-08-02 00:14:19
la source
public static String slurp (final File file)
throws IOException {
    StringBuilder result = new StringBuilder();

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

        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();
}
5
répondu Scott S. McCoy 2010-02-08 22:51:12
la source

Si vous n'avez pas accès aux Fichiers, vous ne le suivant:

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);
}
4
répondu Ilya Gazman 2015-01-06 21:52:59
la source

une solution flexible utilisant IOUtils de 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 d'une URL.

4
répondu wau 2016-12-01 18:42:05
la source

utilisant JDK 8 ou plus:

pas de bibliothèques externes utilisées

vous pouvez créer un nouvel objet String à partir du contenu du fichier (en utilisant les classes du paquet java.nio.file ):

public String readStringFromFile(String filePath) throws IOException {
    String fileContent = new String(Files.readAllBytes(Paths.get(filePath)));
    return fileContent;
}
4
répondu Saikat 2018-07-18 20:03:11
la source

soyez conscient lorsque vous utilisez fileInputStream.available() l'entier retourné ne doit pas représenter la taille réelle du fichier, mais plutôt la quantité estimée d'octets que le système devrait être en mesure de lire à partir du flux sans bloquer IO. Un moyen sûr et simple pourrait ressembler à cela

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 faut considérer que cette approche est et non appropriée pour des encodages de caractères à plusieurs octets comme UTF-8.

3
répondu Henry 2013-03-15 13:09:56
la source

celui-ci utilise la méthode RandomAccessFile.readFully , il semble être disponible à partir de 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
        }
    }
}
3
répondu barjak 2014-02-07 16:11:56
la source

vous pouvez essayer le Scanner et la classe de dossier, une solution de 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!");
}
3
répondu jamesjara 2017-02-07 09:10:25
la source

après Ctrl+F'ing après Scanner, je pense que la solution de Scanner devrait être énumérée aussi. Dans la mode la plus facile à lire il va comme ceci:

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 plus récent (et vous devriez vraiment) envisagez d'utiliser des ressources d'essai pour rendre le code plus facile à lire. Plus de choses à point-fermé qui jonchent tout. Mais c'est surtout un style de choix il me semble.

je poste ceci principalement pour le complétionisme, puisque si vous avez besoin de faire ça fait beaucoup, il devrait y avoir des choses dans java.nio.fichier.Dossiers qui devrait faire le travail mieux.

ma suggestion serait d'utiliser dossiers#readAllBytes(chemin) pour saisir tous les octets, et le nourrir à la nouvelle chaîne de caractères(byte[] Charset) pour obtenir une corde hors de lui que vous pouvez faire confiance. Charsets sera méchant pour vous pendant votre vie, alors méfiez-vous de ce genre de choses maintenant.

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

2
répondu Haakon Løtveit 2015-11-29 17:09:52
la source

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

String data = IO.from(new File("data.txt")).toString();
2
répondu satnam 2016-12-10 18:55:40
la source

Aussi, si votre fichier se trouve être à l'intérieur d'un pot, 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 doit commencer par / par exemple, si votre pot est

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

alors vous voulez l'invoquer comme ceci:

String myTxt = fromFileInJar("/com/com/thing/a.txt");
2
répondu OscarRyz 2017-02-16 00:15:44
la source

en une ligne (Java 8), en supposant que vous avez un lecteur:

String sMessage = String.join("\n", reader.lines().collect(Collectors.toList()));
2
répondu Malcolm Boekhoff 2017-03-15 05:39:05
la source

basé sur 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()]));
}
2
répondu Muskovets 2018-05-10 13:39:23
la source

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

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 toujours un défaut. Il met toujours de nouveaux char ligne à la fin de la chaîne, ce qui peut causer des bugs weirds. 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();
    }
}
1
répondu Ajk 2017-05-23 15:34:53
la source

code D'utilisation:

File file = new File("input.txt");
BufferedInputStream bin = new BufferedInputStream(new FileInputStream(
                file));
byte[] buffer = new byte[(int) file.length()];
bin.read(buffer);
String fileStr = new String(buffer);

fileStr contient la sortie en chaîne.

0
répondu Devram Kandhare 2017-01-16 09:53:39
la source

Autres questions sur java string io file-io file