Afin d'améliorer les performances de mon appli au moment de l'écriture dans un fichier, j'ai choisi d'utiliser le package java.nio.

J'ai donc développé 4 méthodes de lectures et d'écritures utilisant plusieurs moyens différents afin d'observer les performances des unes et des autres.

J'ai été très surpris d'observer les résultats suivants
On y observe que :
- la lecture avec les channels est performante, mais moins qu'avec les BufferedReaders
- l'écriture avec les channels est le moyen le plus long des 4 (FileWriter, BufferedWriter, OutputStream et Channel)

Voici mon code:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
package com.tests.channels;
 
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.WritableByteChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
 
public class Test
{
    public static final String TEXT = "La bataille d'Héraclée est une bataille de l'Antiquité (280 av. J.-C.) qui vit s'affronter d'une part les troupes de la République romaine, commandées par le consul Publius Valerius Laevinus et d'autre part celles de la coalition grecque d'Épire, de Tarente, de Thurii, de Métaponte et d'Héraclée, sous le commandement du roi d'Épire, Pyrrhus Ier. Les Grecs, conduits par un de leurs généraux les plus talentueux, remportèrent la victoire.\nLa bataille d'Héraclée est une bataille de l'Antiquité (280 av. J.-C.) qui vit s'affronter d'une part les troupes de la République romaine, commandées par le consul Publius Valerius Laevinus et d'autre part celles de la coalition grecque d'Épire, de Tarente, de Thurii, de Métaponte et d'Héraclée, sous le commandement du roi d'Épire, Pyrrhus Ier. Les Grecs, conduits par un de leurs généraux les plus talentueux, remportèrent la victoire.\nLa bataille d'Héraclée est une bataille de l'Antiquité (280 av. J.-C.) qui vit s'affronter d'une part les troupes de la République romaine, commandées par le consul Publius Valerius Laevinus et d'autre part celles de la coalition grecque d'Épire, de Tarente, de Thurii, de Métaponte et d'Héraclée, sous le commandement du roi d'Épire, Pyrrhus Ier. Les Grecs, conduits par un de leurs généraux les plus talentueux, remportèrent la victoire.\nLa bataille d'Héraclée est une bataille de l'Antiquité (280 av. J.-C.) qui vit s'affronter d'une part les troupes de la République romaine, commandées par le consul Publius Valerius Laevinus et d'autre part celles de la coalition grecque d'Épire, de Tarente, de Thurii, de Métaponte et d'Héraclée, sous le commandement du roi d'Épire, Pyrrhus Ier. Les Grecs, conduits par un de leurs généraux les plus talentueux, remportèrent la victoire.\nLa bataille d'Héraclée est une bataille de l'Antiquité (280 av. J.-C.) qui vit s'affronter d'une part les troupes de la République romaine, commandées par le consul Publius Valerius Laevinus et d'autre part celles de la coalition grecque d'Épire, de Tarente, de Thurii, de Métaponte et d'Héraclée, sous le commandement du roi d'Épire, Pyrrhus Ier. Les Grecs, conduits par un de leurs généraux les plus talentueux, remportèrent la victoire.\nLa bataille d'Héraclée est une bataille de l'Antiquité (280 av. J.-C.) qui vit s'affronter d'une part les troupes de la République romaine, commandées par le consul Publius Valerius Laevinus et d'autre part celles de la coalition grecque d'Épire, de Tarente, de Thurii, de Métaponte et d'Héraclée, sous le commandement du roi d'Épire, Pyrrhus Ier. Les Grecs, conduits par un de leurs généraux les plus talentueux, remportèrent la victoire.\nLa bataille d'Héraclée est une bataille de l'Antiquité (280 av. J.-C.) qui vit s'affronter d'une part les troupes de la République romaine, commandées par le consul Publius Valerius Laevinus et d'autre part celles de la coalition grecque d'Épire, de Tarente, de Thurii, de Métaponte et d'Héraclée, sous le commandement du roi d'Épire, Pyrrhus Ier. Les Grecs, conduits par un de leurs généraux les plus talentueux, remportèrent la victoire.\nLa bataille d'Héraclée est une bataille de l'Antiquité (280 av. J.-C.) qui vit s'affronter d'une part les troupes de la République romaine, commandées par le consul Publius Valerius Laevinus et d'autre part celles de la coalition grecque d'Épire, de Tarente, de Thurii, de Métaponte et d'Héraclée, sous le commandement du roi d'Épire, Pyrrhus Ier. Les Grecs, conduits par un de leurs généraux les plus talentueux, remportèrent la victoire.\n";
 
    public static void main(String[] args) throws IOException
    {
        Charset charset = Charset.forName("ISO-8859-1");
        // Charset charset = Charset.forName("UTF-8");
        // Charset charset = Charset.forName("US-ASCII");
 
        File fileChannels = new File("C:/temp/testChannels.txt");
        File fileIO = new File("C:/temp/testFileRW.txt");
        File fileOS = new File("C:/temp/testOutputStream.txt");
        File fileBW = new File("C:/temp/testBufferedRW.txt");
        /*
         * Writing tests
         */
        Test.writeWithFileWriter(fileIO, Test.TEXT);
        Test.writeWithBufferedWriter(fileBW, Test.TEXT);
        Test.writeWithOutputStream(fileOS, Test.TEXT);
        Test.writeWithChannel(charset, fileChannels, Test.TEXT);
        /*
         * Reading tests
         */
        Test.readWithFileReader(fileIO);
        Test.readWithBufferedReader(fileIO);
        Test.readWithInputStream(fileIO);
        Test.readWithChannel(charset, fileIO);
    }
 
    /**
     * @param args
     * @throws IOException
     */
    public static void writeWithChannel(Charset charset, File file, String text) throws IOException
    {
        CharsetEncoder encoder = charset.newEncoder();
        file.createNewFile();
        OutputStream fos = new FileOutputStream(file);
        WritableByteChannel channel = Channels.newChannel(fos);
        ByteBuffer bb = encoder.encode(CharBuffer.wrap(text));
        channel.write(bb);
        channel.close();
        fos.close();
    }
 
    public static void readWithChannel(Charset charset, File aFile) throws IOException
    {
        System.out.println("Test.readWithChannel()");
        FileInputStream inFile = new FileInputStream(aFile);
        FileChannel inChannel = inFile.getChannel();
        ByteBuffer buf = ByteBuffer.allocate((int) aFile.length());
        CharBuffer outBuff = CharBuffer.allocate((int) aFile.length());
        inChannel.read(buf);
        buf.flip();
        outBuff = charset.decode((ByteBuffer) buf);
        System.out.println(outBuff);
        inFile.close();
    }
 
    /***************************************************************************
     * 
     **************************************************************************/
    public static void writeWithFileWriter(File file, String text) throws IOException
    {
        file.createNewFile();
        FileWriter writer = new FileWriter(file);
        writer.write(text);
        writer.close();
    }
 
    public static void readWithFileReader(File file) throws IOException
    {
        System.out.println("Test.readWithFileReader()");
        FileReader reader = new FileReader(file);
        int i = 0;
        while ((i = reader.read()) != -1)
        {
            System.out.print((char) i);
        }
        reader.close();
 
    }
 
    /***************************************************************************
     * 
     **************************************************************************/
    public static void readWithBufferedReader(File file) throws IOException
    {
        System.out.println("Test.readWithBufferedReader()");
        BufferedReader reader = new BufferedReader(new FileReader(file));
        String st;
        while ((st = reader.readLine()) != null)
        {
            System.out.println(st);
        }
        reader.close();
    }
 
    public static void writeWithBufferedWriter(File file, String text) throws IOException
    {
      BufferedWriter writer = new BufferedWriter(new FileWriter(file));
      writer.write(text);
      writer.close();
    }
 
    /***************************************************************************
     * 
     **************************************************************************/
    public static void readWithInputStream(File file) throws IOException
    {
        System.out.println("Test.readWithInputStream()");
        FileInputStream reader = new FileInputStream(file);
        int i = 0;
        while ((i = reader.read()) != -1)
        {
            System.out.print((char) i);
        }
        reader.close();
    }
 
    private static void writeWithOutputStream(File file, String text) throws IOException
    {
        file.createNewFile();
        BufferedOutputStream writer = new BufferedOutputStream(new FileOutputStream(file));
        writer.write(text.getBytes());
        writer.close();
    }
}
Je serais très intéressé par votre avis sur l'utilisation que je fais des différents moyen d'écriture, et sur la raison pour laquelle Les FileReader et FileWriter semblent plus rapides (ce qui me ferait poser de sérieux doutes sur l'intérêt de java.nio alors).