Quelle est la meilleure lecture de fichier (Java)

Il existe de nombreuses façons de lire les fichiers Java, mais j'ai mesuré lequel était le plus rapide. Cette fois, j'ai mesuré en lisant toutes les lignes.

Cible

1.Files.readAllLines Lisez toutes les lignes d'un fichier à l'aide de readAllLines de java.nio.file.Files introduits à partir de Java7. En interne, il crée simplement un BufferedReader, le lit ligne par ligne, le place dans une liste et le renvoie.

try {
    List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
} catch (IOException e) {
    e.printStackTrace();
}

2. Utilisez FileReader. C'est la méthode traditionnelle. Lisez le fichier avec FileReader et enveloppez-le avec BufferedReader. Pour le code de caractère, le code de caractère de l'environnement est utilisé tel quel. Si vous souhaitez spécifier le code de caractère, vous ne pouvez pas l'utiliser.

try (BufferedReader reader = new BufferedReader(new FileReader(file));){
    String str;
    List<String> lines = new ArrayList<>();
    while ((str = reader.readLine()) != null) {
        lines.add(str);
    }
} catch (IOException e) {
    e.printStackTrace();
}

3. Utilisez FileInputStream. C'est la méthode utilisée lorsque le code de caractère est utilisé de manière conventionnelle. Lisez le fichier avec FileInputStream et spécifiez le code de caractère avec InputStreamReader. Ensuite, enveloppez-le dans BufferedReader.

try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), StandardCharsets.UTF_8));){
    String str;
    List<String> lines = new ArrayList<>();
    while ((str = reader.readLine()) != null) {
        lines.add(str);
    }
} catch (IOException e) {
    e.printStackTrace();
}

4. Utilisez Files.readAllLines. Une fonction ajoutée à partir de Java8 qui renvoie toutes les lignes du fichier sous forme de flux. Les valeurs sont répertoriées dans le processus de résiliation.

try {
    List<String> lines = Files.lines(path, StandardCharsets.UTF_8).collect(Collectors.toList());
} catch (IOException e) {
    e.printStackTrace();
}

J'ai essayé de courir

J'ai essayé de l'exécuter avec la source suivante TestFile est un fichier texte de 200 000 lignes.

private static final String PATH = "src/test/java/com/test/common/TestFile";

public static void main(String[] args) {
    Path path = Paths.get(PATH);
    File file = path.toFile();
    // Files.Mesure ReadAllLines
    Runnable test1 = () -> {
        try {
            List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
        } catch (IOException e) {
            e.printStackTrace();
        }
    };

    //Mesure BufferedReader de FileReader
    Runnable test2 = () -> {
        try (BufferedReader reader = new BufferedReader(new FileReader(file));){
            String str;
            List<String> lines = new ArrayList<>();
            while ((str = reader.readLine()) != null) {
                lines.add(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    };

    //Mesure de BufferedReader InputStreamReader FileInputStream
    Runnable test3 = () -> {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), StandardCharsets.UTF_8));){
            String str;
            List<String> lines = new ArrayList<>();
            while ((str = reader.readLine()) != null) {
                lines.add(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    };

    // Files.Mesure ReadAllLines
    Runnable test4 = () -> {
        try {
            List<String> lines = Files.lines(path, StandardCharsets.UTF_8).collect(Collectors.toList());
        } catch (IOException e) {
            e.printStackTrace();
        }
    };


    calcFuncTime(test1);
    calcFuncTime(test2);
    calcFuncTime(test3);
    calcFuncTime(test4);
}

/**
 *Mesurer le temps
 * @param runnable
 */
private static void calcFuncTime(Runnable runnable) {
    long start = System.nanoTime();
    runnable.run();
    long end = System.nanoTime();
    System.out.println(end - start);
}

Résultat d'exécution

101206619
178792154
53933069
102386121

Quel est le meilleur

Lors de la vérification des résultats de l'exécution, le cas le plus lent était le deuxième cas et le premier était le troisième. Cependant, la différence est d'environ 0,1 seconde, donc s'il y a une différence d'environ 200 000 lignes, je pense que vous n'avez pas à vous en préoccuper. Personnellement, je ne recommande pas d'utiliser FileReader car il ne vous permet pas d'utiliser des codes de caractères et est lent. La méthode utilisant FileInputStream est la plus rapide, mais comme la quantité de description est importante, la méthode utilisant Files est probablement la meilleure. S'il vous plaît excusez-moi.