Lecture d'un fichier texte brut en Java

933

Il semble qu'il existe différentes façons de lire et d'écrire des données de fichiers en Java.

Je veux lire les données ASCII d'un fichier. Quelles sont les voies possibles et leurs différences?

Tim l'Enchanteur
la source
24
Je suis également en désaccord avec la conclusion comme "non constructive". Heureusement, cela pourrait bien être fermé en double . Bonnes réponses, par exemple dans Comment créer une chaîne à partir du contenu d'un fichier? , Quel est le moyen le plus simple de lire un fichier dans String? , Quelles sont les classes les plus simples pour lire des fichiers?
Jonik
Sans boucles: {{{Scanner sc = nouveau scanner (fichier, "UTF-8"); sc.useDelimiter ("$ ^"); // regex ne correspondant à rien String text = sc.next (); sc.close (); }}}
Aivar
3
c'est tellement intéressant qu'il n'y a rien de tel que "read ()" en python, pour lire le fichier entier dans une chaîne
kommradHomer
2
C'est le moyen le plus simple de le faire: mkyong.com/java/…
dellasavia

Réponses:

567

ASCII est un fichier TEXT que vous utiliseriez Readerspour la lecture. Java prend également en charge la lecture à partir d'un fichier binaire à l'aide de InputStreams. Si les fichiers en cours de lecture sont volumineux, vous souhaiterez utiliser un BufferedReadersur le dessus FileReaderpour améliorer les performances de lecture.

Parcourez cet article pour savoir comment utiliser unReader

Je vous recommande également de télécharger et de lire ce merveilleux livre (pourtant gratuit) intitulé Thinking In Java

En Java 7 :

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

(docs) ou

Files.readAllLines(...)

(documents)

En Java 8 :

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

(documents)

Aravind Yarram
la source
14
Choisir un lecteur dépend vraiment de la raison pour laquelle vous avez besoin du contenu du fichier. Si le fichier est petit (ish) et que vous en avez besoin, il est plus rapide (évalué par nos soins: 1.8-2x) d'utiliser simplement un FileReader et de tout lire (ou au moins des morceaux assez gros). Si vous le traitez ligne par ligne, optez pour le BufferedReader.
Vlad
3
L'ordre des lignes sera-t-il conservé lors de l'utilisation de "Files.lines (..). ForEach (...)". Je crois comprendre que la commande sera arbitraire après cette opération.
Daniil Shevelev,
39
Files.lines(…).forEach(…)ne conserve pas l'ordre des lignes mais s'exécute en parallèle, @Dash. Si la commande est importante, vous pouvez l'utiliser Files.lines(…).forEachOrdered(…), ce qui devrait préserver la commande (ne l'a pas vérifié cependant).
Palec
2
@Palec c'est intéressant, mais pouvez-vous citer des documents où il est dit que cela Files.lines(...).forEach(...)est exécuté en parallèle? Je pensais que ce n'était le cas que lorsque vous faites explicitement le flux parallèle en utilisant Files.lines(...).parallel().forEach(...).
Klitos Kyriacou
3
Ma formulation d'origine n'est pas à l'épreuve des balles, @KlitosKyriacou. Le fait est que forEachcela ne garantit aucun ordre et la raison est une parallélisation facile. Si l'ordre doit être préservé, utilisez forEachOrdered.
Palec
687

Ma façon préférée de lire un petit fichier est d'utiliser un BufferedReader et un StringBuilder. C'est très simple et au point (bien que pas particulièrement efficace, mais assez bon pour la plupart des cas):

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

Certains ont souligné qu'après Java 7, vous devriez utiliser les fonctionnalités d' essai avec les ressources (c'est -à- dire la fermeture automatique):

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

Lorsque je lis des chaînes comme celle-ci, je veux généralement faire un peu de gestion de chaînes par ligne, alors je choisis cette implémentation.

Bien que si je veux simplement lire un fichier dans une chaîne, j'utilise toujours Apache Commons IO avec la méthode de classe IOUtils.toString (). Vous pouvez consulter la source ici:

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

Et encore plus simple avec Java 7:

try(FileInputStream inputStream = new FileInputStream("foo.txt")) {     
    String everything = IOUtils.toString(inputStream);
    // do something with everything string
}
Knubo
la source
6
J'ai fait un petit ajustement pour arrêter d'ajouter une nouvelle ligne (\ n) si la dernière ligne est atteinte. code while (ligne! = null) {sb.append (ligne); line = br.readLine (); // Ajouter une nouvelle ligne uniquement lorsque la courbe n'est PAS la dernière ligne .. if (ligne! = Null) {sb.append ("\ n"); }}code
Ramon Fincken
2
Semblable à Apache Common IO IOUtils # toString () est sun.misc.IOUtils # readFully (), qui est inclus dans les JRE Sun / Oracle.
gb96
3
Pour des performances, appelez toujours sb.append ('\ n') de préférence à sb.append ("\ n") car un caractère est ajouté au StringBuilder plus rapidement qu'une String
gb96
2
FileReader peut lever FileNotFoundException et BufferedRead peut lever IOException, vous devez donc les attraper.
kamaci
4
il n'est pas nécessaire d'utiliser directement les lecteurs et également pas besoin d'ioutils. java7 a intégré des méthodes pour lire un fichier entier / toutes les lignes: voir docs.oracle.com/javase/7/docs/api/java/nio/file/… et docs.oracle.com/javase/7/docs/api / java / nio / file /…
kritzikratzi
142

La manière la plus simple consiste à utiliser la Scannerclasse en Java et l'objet FileReader. Exemple simple:

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

Scanner a plusieurs méthodes pour lire des chaînes, des nombres, etc ... Vous pouvez chercher plus d'informations à ce sujet sur la page de documentation Java.

Par exemple, lire tout le contenu dans un String:

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

De plus, si vous avez besoin d'un encodage spécifique, vous pouvez l'utiliser au lieu de FileReader:

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)
Jesus Ramos
la source
28
while (in.hasNext ()) {System.out.println (in.next ()); }
Gene Bo
16
@Hissain Mais beaucoup plus facile à utiliser queBufferedReader
Jesus Ramos
3
Doit l'entourer d'essayer Catch
Rahal Kanishka
@JesusRamos Pas vraiment, pourquoi le pensez-vous? Quoi de plus facile à ce sujet que while ((line = br.readLine()) != null) { sb.append(line); }?
Marquis de Lorne
83

Voici une solution simple:

String content;

content = new String(Files.readAllBytes(Paths.get("sample.txt")));
Nery Jr
la source
2
@Nery Jr, élégant et simple
Mahmoud Saleh
1
Le meilleur et le plus simple.
Dary
57

Voici une autre façon de le faire sans utiliser de bibliothèques externes:

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;
}
Crasseux
la source
10
ou utilisez la fonction "essayer avec des ressources" (lecteur FileReader = nouveau FileReader (fichier))
Hernán Eche
3
J'ai remarqué le fichier.length (), comment cela fonctionne-t-il avec les fichiers utf-16?
Wayne
5
Cette technique suppose que read () remplit le tampon; que le nombre de caractères est égal au nombre d'octets; que le nombre d'octets s'inscrit dans la mémoire; et que le nombre d'octets s'inscrit dans un entier. -1
Marquis de Lorne
1
@HermesTrismegistus J'ai donné quatre raisons pour lesquelles c'est faux. StefanReich a parfaitement raison d'être d'accord avec moi.
Marquis de Lorne
35

J'ai dû comparer les différentes manières. Je commenterai mes conclusions mais, en bref, le moyen le plus rapide est d'utiliser un ancien BufferedInputStream simple sur un FileInputStream. Si de nombreux fichiers doivent être lus, trois threads réduiront le temps total d'exécution à environ la moitié, mais l'ajout de plus de threads dégradera progressivement les performances jusqu'à ce que cela prenne trois fois plus de temps pour terminer avec vingt threads qu'avec un seul thread.

L'hypothèse est que vous devez lire un fichier et faire quelque chose de significatif avec son contenu. Dans les exemples, voici la lecture des lignes d'un journal et compter celles qui contiennent des valeurs qui dépassent un certain seuil. Je suppose donc que le monoligne Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))n'est pas une option.

J'ai testé sur Java 1.8, Windows 7 et les disques SSD et HDD.

J'ai écrit six implémentations différentes:

rawParse : utilisez BufferedInputStream sur un FileInputStream, puis coupez les lignes en lisant octet par octet. Cela a surpassé toute autre approche à un seul thread, mais cela peut être très gênant pour les fichiers non ASCII.

lineReaderParse : utilisez un BufferedReader sur un FileReader, lisez ligne par ligne, divisez les lignes en appelant String.split (). C'est environ 20% plus lent que rawParse.

lineReaderParseParallel : c'est la même chose que lineReaderParse, mais il utilise plusieurs threads. C'est l'option la plus rapide dans tous les cas.

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

nioAsyncParse : utilisez un AsynchronousFileChannel avec un gestionnaire d'achèvement et un pool de threads.

nioMemoryMappedParse : utilisez un fichier mappé en mémoire. C'est vraiment une mauvaise idée qui donne des temps d'exécution au moins trois fois plus longs que toute autre implémentation.

Ce sont les délais moyens de lecture de 204 fichiers de 4 Mo chacun sur un lecteur quadricœur i7 et SSD. Les fichiers sont générés à la volée pour éviter la mise en cache du disque.

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

J'ai trouvé une différence plus petite que ce à quoi je m'attendais entre l'exécution sur un SSD ou un disque dur, le SSD étant environ 15% plus rapide. Cela peut être dû au fait que les fichiers sont générés sur un disque dur non fragmenté et qu'ils sont lus séquentiellement, par conséquent, le lecteur tournant peut fonctionner presque comme un SSD.

J'ai été surpris par les faibles performances de l'implémentation nioAsyncParse. Soit j'ai implémenté quelque chose de la mauvaise façon, soit l'implémentation multi-thread utilisant NIO et un gestionnaire de complétion effectue la même chose (ou pire encore) qu'une implémentation single-thread avec l'API java.io. De plus, l'analyse asynchrone avec CompletionHandler est beaucoup plus longue dans les lignes de code et difficile à implémenter correctement qu'une implémentation directe sur les anciens flux.

Maintenant, les six implémentations suivies d'une classe les contenant toutes, plus une méthode main () paramétrable qui permet de jouer avec le nombre de fichiers, la taille des fichiers et le degré de concurrence. Notez que la taille des fichiers varie de plus moins 20%. C'est pour éviter tout effet car tous les fichiers sont exactement de la même taille.

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

MISE EN ŒUVRE PLEINE ET EXÉCUTOIRE DE TOUS LES CAS

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

Serg M Ten
la source
24

Voici les trois méthodes de travail et testées:

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

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

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

Lire le fichier entier sans boucle en utilisant la 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
la source
1
Comment donner le chemin si les dossiers sont présents dans le projet?
Kavipriya
2
Et alors java.nio.file.Files? Nous pouvons maintenant utiliser juste readAllLines, readAllByteset lines.
Claude Martin
21

Les méthodes à l'intérieur org.apache.commons.io.FileUtilspeuvent également être très pratiques, par exemple:

/**
 * 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
la source
Ou si vous préférez Guava (une bibliothèque plus moderne et activement entretenue), il a des utilitaires similaires dans sa classe Files . Exemples simples dans cette réponse .
Jonik
1
ou vous utilisez simplement la méthode intégrée pour obtenir toutes les lignes: docs.oracle.com/javase/7/docs/api/java/nio/file/…
kritzikratzi
Le lien sur apache commons semble mort.
kebs
17

Que voulez-vous faire avec le texte? Le fichier est-il suffisamment petit pour tenir en mémoire? J'essaierais de trouver le moyen le plus simple de gérer le fichier selon vos besoins. La bibliothèque FileUtils est très pratique pour cela.

for(String line: FileUtils.readLines("my-text-file"))
    System.out.println(line);
Peter Lawrey
la source
2
il est également intégré à java7: docs.oracle.com/javase/7/docs/api/java/nio/file/…
kritzikratzi
@PeterLawrey signifie probablement org.apache.commons.io.FileUtils. Le lien Google peut changer le contenu au fil du temps, car la signification la plus répandue change, mais cela correspond à sa requête et semble correct.
Palec
2
Malheureusement, de nos jours il n'y a pas readLines(String)et readLines(File)est déprécié en faveur de readLines(File, Charset). L'encodage peut également être fourni sous forme de chaîne.
Palec
12

J'ai documenté 15 façons de lire un fichier en Java , puis je les ai testées pour la vitesse avec différentes tailles de fichiers - de 1 Ko à 1 Go et voici les trois principales façons de le faire:

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

    Testé pour fonctionner en Java 7, 8 et 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()

    Testé pour fonctionner en 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()

    Cela a été testé pour fonctionner en Java 8 et 9 mais ne fonctionnera pas en Java 7 en raison de l'exigence d'expression 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
la source
9

Vous trouverez ci-dessous une ligne de conduite à la manière de Java 8. En supposant que le text.txtfichier se trouve à la racine du répertoire de projet d'Eclipse.

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

Utilisation de 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();
}
Néo
la source
7

C'est fondamentalement la même chose que la réponse de Jesus Ramos, sauf avec File au lieu de FileReader plus l'itération pour parcourir le contenu du fichier.

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

... jette FileNotFoundException

ThisClark
la source
3
File vs FileReader: Avec un FileReader, le fichier doit exister et les autorisations du système d'exploitation doivent permettre l'accès. Avec un fichier, il est possible de tester ces autorisations ou de vérifier si le fichier est un répertoire. Le fichier a des fonctions utiles: isFile (), isDirectory (), listFiles (), canExecute (), canRead (), canWrite (), exist (), mkdir (), delete (). File.createTempFile () écrit dans le répertoire temporaire par défaut du système. Cette méthode retournera un objet fichier qui peut être utilisé pour ouvrir des objets FileOutputStream, etc. source
ThisClark
7

Les classes de flux tamponnées sont beaucoup plus performantes dans la pratique, à tel point que l'API NIO.2 inclut des méthodes qui renvoient spécifiquement ces classes de flux, en partie pour vous encourager à toujours utiliser des flux tamponnés dans votre application.

Voici un exemple:

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

Vous pouvez remplacer ce code

BufferedReader reader = Files.newBufferedReader(path);

avec

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

Je recommande cet article pour découvrir les principales utilisations de Java NIO et IO.

Imar
la source
6

Probablement pas aussi rapide qu'avec des E / S tamponnées, mais assez concis:

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

Le \Zmotif indique Scannerque le délimiteur est EOF.

David Soroko
la source
1
Une réponse très apparentée et déjà existante est celle de Jésus Ramos.
Palec
1
Vrai, devrait être: if(scanner.hasNext()) content = scanner.next();
David Soroko
1
Cela échoue pour moi sur Android 4.4. Seuls 1024 octets sont lus. YMMV.
Roger Keays
3

Je ne le vois pas encore mentionné dans les autres réponses jusqu'à présent. Mais si "Best" signifie vitesse, alors la nouvelle Java I / O (NIO) pourrait fournir la performance la plus rapide, mais pas toujours la plus facile à comprendre pour quelqu'un qui apprend.

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

jzd
la source
Vous auriez dû indiquer comment cela s'est fait et ne pas donner de lien à suivre
Orar
3

La façon la plus simple de lire des données à partir d'un fichier en Java consiste à utiliser la classe File pour lire le fichier et la classe Scanner pour lire le contenu du fichier.

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'oubliez pas d'importer java.util. *; pour que le scanner fonctionne.

anadir47
la source
2

La goyave fournit une doublure pour cela:

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

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

Ce n'est peut-être pas la réponse exacte à la question. C'est juste une autre façon de lire un fichier où vous ne spécifiez pas explicitement le chemin d'accès à votre fichier dans votre code Java et à la place, vous le lisez comme un argument de ligne de commande.

Avec le code suivant,

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

allez-y et lancez-le avec:

java InputReader < input.txt

Ce serait lire le contenu de la input.txt et l'imprimerait sur votre console.

Vous pouvez également créer votre System.out.println()pour écrire dans un fichier spécifique via la ligne de commande comme suit:

java InputReader < input.txt > output.txt

Ce serait lire input.txtet écrire à output.txt.

Adit A. Pillai
la source
2

Vous pouvez utiliser readAllLines et la joinméthode pour obtenir le contenu de fichier entier sur une seule ligne:

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

Il utilise le codage UTF-8 par défaut, qui lit correctement les données ASCII.

Vous pouvez également utiliser readAllBytes:

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

Je pense que readAllBytes est plus rapide et plus précis, car il ne remplace pas la nouvelle ligne par \net aussi la nouvelle ligne peut l'être \r\n. C'est en fonction de vos besoins que l'on convient.

Mostafa Vatanpour
la source
1

Pour les applications Web Maven basées sur JSF, utilisez simplement ClassLoader et le Resourcesdossier pour lire le fichier de votre choix :

  1. Mettez tout fichier que vous souhaitez lire dans le dossier Ressources.
  2. Mettez la dépendance IO Apache Commons dans votre POM:

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-io</artifactId>
        <version>1.3.2</version>
    </dependency>
  3. Utilisez le code ci-dessous pour le lire (par exemple ci-dessous est la lecture dans un fichier .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;

Vous pouvez faire de même pour les fichiers texte, les fichiers .properties, les schémas XSD , etc.

Analyse floue
la source
Vous ne pouvez pas l'utiliser sur 'n'importe quel fichier que vous voulez'. Vous ne pouvez l'utiliser que pour les ressources qui ont été regroupées dans le fichier JAR ou WAR.
Marquis de Lorne
1

Cactoos vous offre une ligne déclarative:

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

Utilisez Java Kiss s'il s'agit de simplicité de structure:

import static kiss.API.*;

class App {
  void run() {
    String line;
    try (Close in = inOpen("file.dat")) {
      while ((line = readLine()) != null) {
        println(line);
      }
    }
  }
}
Warren MacEvoy
la source
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();
    }

 }

 }

Utilisez simplement java 8 Stream.

Archit Bhadauria
la source
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
la source
0

La méthode la plus intuitive est introduite dans 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 a ce luxe d'il y a des décennies! ☺

PHPst
la source
-3

Ce code que j'ai programmé est beaucoup plus rapide pour les très gros fichiers:

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
la source
10
Beaucoup plus rapide, j'en doute, si vous utilisez une simple concaténation de chaînes au lieu d'un StringBuilder ...
PhiLho
6
Je pense que le gain de vitesse principal provient de la lecture dans des blocs de 1 Mo (1024 * 1024). Cependant, vous pouvez faire de même en passant simplement 1024 * 1024 comme deuxième argument au constructeur BufferedReader.
gb96
3
je ne crois pas que cela soit testé du tout. l'utilisation +=de cette manière vous donne une complexité quadratique (!) pour une tâche qui devrait être une complexité linéaire. cela va commencer à explorer les fichiers de plus de quelques Mo. pour contourner ce problème, vous devez soit conserver les blocs de texte dans une liste <chaîne>, soit utiliser le constructeur de chaînes susmentionné.
kritzikratzi
5
Beaucoup plus rapide que quoi? Ce n'est certainement pas plus rapide que l'ajout à un StringBuffer. -1
Marquis de Lorne
1
@ gb96 J'ai pensé la même chose à propos des tailles de tampons, mais l'expérience détaillée de cette question a donné des résultats surprenants dans un contexte similaire: un tampon de 16 Ko était constamment et sensiblement plus rapide.
chiastic-security
-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.

L'ensemble de lignes ci-dessus peut être écrit en 1 seule ligne comme:

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

Ajout au générateur de chaînes (si votre fichier est énorme, il est conseillé d'utiliser le générateur de chaînes, sinon utilisez un objet 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
la source