TOC

Java - Lecture à partir d’un fichier

Java - Lecture à partir d'un fichier

1. Vue d'ensemble

Dans ce didacticiel, nous allons explorer différentes manières deread from a File in Java; nous utiliseronsBufferedReader,Scanner,StreamTokenizer,DataInputStream,SequenceInputStream etFileChannel.

Ensuite, nous verrons comment lire un fichier codé UTF-8 et comment créer une chaîne à partir du contenu d’un fichier.

Enfin, nous explorerons les nouvelles techniques de lecture de fichier dans Java 7.

Cet article fait partie dethe “Java – Back to Basic” series ici par exemple.

2. Lire avecBufferedReader

Commençons par un moyen simple de lire un fichier en utilisantBufferedReader; le fichier lui-même contient: 

Hello world

Le code suivant lit le fichier à l'aide deBufferedReader: 

@Test
public void whenReadWithBufferedReader_thenCorrect()
  throws IOException {
     String expected_value = "Hello world";
     String file ="src/test/resources/test_read.txt";

     BufferedReader reader = new BufferedReader(new FileReader(file));
     String currentLine = reader.readLine();
     reader.close();

    assertEquals(expected_value, currentLine);
}

Notez quereadLine() renverranull lorsque la fin du fichier est atteinte.

3. Lire avecScanner

Ensuite, utilisons unScanner pour lire à partir du fichier - le fichier contient: 

Hello world 1

Nous utiliserons un simple espace blanc comme délimiteur: 

@Test
public void whenReadWithScanner_thenCorrect()
  throws IOException {
    String file = "src/test/resources/test_read.txt";
    Scanner scanner = new Scanner(new File(file));
    scanner.useDelimiter(" ");

    assertTrue(scanner.hasNext());
    assertEquals("Hello", scanner.next());
    assertEquals("world", scanner.next());
    assertEquals(1, scanner.nextInt());

    scanner.close();
}

Notez que le délimiteur par défaut est l'espace blanc, mais plusieurs délimiteurs peuvent être utilisés avec unScanner.

4. Lire avecStreamTokenizer

Ensuite, lisons un fichier texte en jetons en utilisant unStreamTokenizer.

La façon dont fonctionne le tokenizer est - tout d'abord, nous devons déterminer quel est le prochain jeton - Chaîne ou nombre; nous faisons cela en regardant le champtokenizer.ttype.

Ensuite, nous lirons le jeton réel basé sur ce type:

  • tokenizer.nval - si le type était un nombre

  • tokenizer.sval - si le type était une chaîne

Le fichier contient simplement: 

Hello 1

Le code suivant lit à partir du fichier String et le numéro: 

@Test
public void whenReadWithStreamTokenizer_thenCorrectTokens()
  throws IOException {
    String file = "src/test/resources/test_read.txt";
   FileReader reader = new FileReader(file);
    StreamTokenizer tokenizer = new StreamTokenizer(reader);

    // token 1
    tokenizer.nextToken();
    assertEquals(StreamTokenizer.TT_WORD, tokenizer.ttype);
    assertEquals("Hello", tokenizer.sval);

    // token 2
    tokenizer.nextToken();
    assertEquals(StreamTokenizer.TT_NUMBER, tokenizer.ttype);
    assertEquals(1, tokenizer.nval, 0.0000001);

    // token 3
    tokenizer.nextToken();
    assertEquals(StreamTokenizer.TT_EOF, tokenizer.ttype);
    reader.close();
}

Notez comment le jeton de fin de fichier est utilisé à la fin.

5. Lire avecDataInputStream

Nous pouvons utiliserDataInputStream pour lire le type de données binaire ou primitif à partir d'un fichier.

Commençons par le fichier lui-même: 

Hello

Le test suivant lit le fichier en utilisant unDataInputStream: 

@Test
public void whenReadWithDataInputStream_thenCorrect()
  throws IOException {
    String expectedValue = "Hello";
    String file ="src/test/resources/test_read.txt";
    DataInputStream reader = new DataInputStream(new FileInputStream(file));
    String result = reader.readUTF();
    reader.close();

    assertEquals(expectedValue, result);
}

6. Lire avecFileChannel

Si nous lisons un fichier volumineux,FileChannel peut être plus rapide que les E / S standard.

Le contenu du fichier: 

 Hello world

Le code suivant lit les octets de données du fichier à l'aide deFileChannel etRandomAccessFile: 

@Test
public void whenReadWithFileChannel_thenCorrect()
  throws IOException {
    String expected_value = "Hello world";
    String file = "src/test/resources/test_read.txt";
    RandomAccessFile reader = new RandomAccessFile(file, "r");
    FileChannel channel = reader.getChannel();

    int bufferSize = 1024;
    if (bufferSize > channel.size()) {
        bufferSize = (int) channel.size();
    }
    ByteBuffer buff = ByteBuffer.allocate(bufferSize);
    channel.read(buff);
    buff.flip();

    assertEquals(expected_value, new String(buff.array()));
    channel.close();
    reader.close();
}

7. Lire le fichier encodé UTF-8

Voyons maintenant comment lire un fichier encodé en UTF-8 à l'aide deBufferedReader: 

@Test
public void whenReadUTFEncodedFile_thenCorrect()
  throws IOException {
    String expected_value = "青空";
    String file = "src/test/resources/test_read.txt";
    BufferedReader reader = new BufferedReader
      (new InputStreamReader(new FileInputStream(file), "UTF-8"));
    String currentLine = reader.readLine();
    reader.close();

    assertEquals(expected_value, currentLine);
}

8. Lire un fichier dans une chaîne

Nous pouvons faire bon usage deStringBuilder àread the entire contents of a file into a String. Commençons par le fichier: 

Hello world

Test line

Le code suivant ajoute les données lues à partir du fichier dans unStringBuilder ligne par ligne: 

@Test
public void whenReadFileContentsIntoString_thenCorrect()
  throws IOException {
    String expected_value = "Hello world n Test line n";
    String file = "src/test/resources/test_read.txt";
    BufferedReader reader = new BufferedReader(new FileReader(file));
    StringBuilder builder = new StringBuilder();
    String currentLine = reader.readLine();
    while (currentLine != null) {
        builder.append(currentLine);
        builder.append("n");
        currentLine = reader.readLine();
    }

    reader.close();
    assertEquals(expected_value, builder.toString());
}

9. Lire à partir d'un fichier à l'aide de Java 7

Java 7 introduit une nouvelle façon de travailler avec les fichiers et le système de fichiers - utilisons-en pour lire les fichiers.

9.1. Lire un petit fichier avec Java 7

Le contenu du fichier: 

 Hello world

Le code suivant montre comment lire un petit fichier à l'aide de la nouvelle classeFiles: 

@Test
public void whenReadSmallFileJava7_thenCorrect()
  throws IOException {
    String expected_value = "Hello world";

    Path path = Paths.get("src/test/resources/test_read.txt");

    String read = Files.readAllLines(path).get(0);
    assertEquals(expected_value, read);
}

Notez que vous pouvez également utiliser la méthodereadAllBytes() si vous avez besoin de données binaires.

9.2. Lire un fichier volumineux avec Java 7

Si nous voulons lire un gros fichier avec la classeFiles, nous pouvons utiliser lesBufferedReader.

Le contenu du fichier: 

 Hello world

Le code suivant lit le fichier à l'aide de la nouvelle classeFiles etBufferedReader: 

@Test
public void whenReadLargeFileJava7_thenCorrect()
  throws IOException {
    String expected_value = "Hello world";

    Path path = Paths.get("src/test/resources/test_read.txt");

    BufferedReader reader = Files.newBufferedReader(path);
    String line = reader.readLine();
    assertEquals(expected_value, line);
}

10. Conclusion

Comme vous pouvez le constater, il existe de nombreuses possibilités pour lire des données à partir d’un fichier en langage Java pur. Vous pouvez aller pourBufferedReader pour lire ligne par ligne,Scanner pour lire en utilisant différents délimiteurs,StreamTokenizer pour lire un fichier en jetons,DataInputStream pour lire des données binaires et des données primitives types,SequenceInput Stream pour lier plusieurs fichiers en un seul flux,FileChannel pour lire plus rapidement à partir de fichiers volumineux, etc.

Related