java récupérer données - Lecture d'un fichier texte en Java




12 Answers

ASCII est un fichier TEXT donc vous utiliseriez des Readers pour 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 énormes, vous voudrez utiliser un BufferedReader sur un FileReader pour améliorer les performances de lecture.

Parcourez cet article sur l'utilisation d'un lecteur

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

En Java 7 :

new String (Files.readAllBytes (...)) ou Files.readAllLines(...)

En Java 8 :

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

ligne caractere

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 manières possibles et leurs différences?




Le plus simple est d'utiliser la classe Scanner dans Java et l'objet FileReader. Exemple simple:

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

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

Par exemple lire le contenu entier dans une String :

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

Aussi, si vous avez besoin d'un encodage spécifique, vous pouvez l'utiliser à la place de FileReader :

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)



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



Je devais comparer les différentes manières. Je commenterai mes conclusions mais, en bref, le moyen le plus rapide consiste à utiliser un ancien tampon BufferedInputStream sur un FileInputStream. Si de nombreux fichiers doivent être lus, trois threads réduiront le temps d'exécution total à environ la moitié, mais l'ajout de threads dégradera progressivement les performances jusqu'à ce que cela prenne trois fois plus de temps 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, il s'agit de lire les lignes d'un journal et de compter celles qui contiennent des valeurs dépassant un certain seuil. Donc, je suppose que le Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) 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 lecteurs 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 monothread, 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 (). Ceci est approximativement 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 : Utilise 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 d'avoir des temps d'exécution au moins trois fois plus longs que n'importe quelle autre implémentation.

Ce sont les temps moyens pour lire 204 fichiers de 4 Mo chacun sur un disque i7 et SSD quad-core. 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 courir sur un SSD ou un disque dur étant le SSD 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 disque rotatif peut fonctionner presque comme un disque SSD.

J'ai été surpris par les faibles performances de l'implémentation de nioAsyncParse. Soit j'ai implémenté quelque chose dans le mauvais sens, soit l'implémentation multi-thread utilisant NIO et un gestionnaire de complétion fait la même chose (ou même pire) qu'une implémentation à un seul 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 parametrizable main () qui permet de jouer avec le nombre de fichiers, la taille du fichier et le degré de simultanéité. Notez que la taille des fichiers varie plus moins 20%. Ceci afin d'éviter tout effet dû au fait que tous les fichiers ont exactement 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 PLEINEMENT RUNNABLE DE TOUS LES CAS

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




Que voulez-vous faire avec le texte? Le fichier est-il assez petit pour tenir dans la mémoire? Je voudrais essayer de trouver le moyen le plus simple de gérer le fichier pour vos besoins. La bibliothèque FileUtils est très maniable pour cela.

for(String line: FileUtils.readLines("my-text-file"))
    System.out.println(line);



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



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

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

Le motif \Z indique au Scanner que le délimiteur est EOF.




La façon la plus simple de lire des données à partir d'un fichier en Java est d'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 Scanner fonctionne.




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

  1. Mettez tout fichier que vous voulez lire dans le dossier Ressources.
  2. Mettez la dépendance Apache Commons IO 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, lisez ci-dessous 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 la même chose pour les fichiers texte, les fichiers .properties, les schémas XSD , etc.




Cactoos vous donne un one-liner déclaratif:

new TextOf(new File("a.txt")).asString();



Utilisez Java kiss si cela concerne la simplicité de la structure:

import static kiss.API.*;

class App {
  void run() {
    String line;
    try (Close in = inOpen("file.dat")) {
      while ((line = readLine()) != null) {
        println(line);
      }
    }
  }
}



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



Related