Java: fichier texte Restitution à la console

Question

Je tente de produire un fichier texte à la console avec Java. Je me demandais ce qui est la façon la plus efficace de le faire?

Je l'ai étudié plusieurs méthodes cependant, il est difficile de discerner ce qui est la moindre solution la performance impactée.

un fichier Restitution texte à la console impliquerait la lecture dans chaque ligne dans le fichier, il écrit alors à la console.

Est-il préférable d'utiliser:

1. Buffered Reader avec un FileReader, la lecture en lignes et faire un tas d'appels System.out.println?

   BufferedReader in = new BufferedReader(new FileReader("C:\\logs\\")); 
   while (in.readLine() != null) {
         System.out.println(blah blah blah);          
   }         
   in.close();
   

2. lecture du scanner chaque ligne dans le fichier et de faire des appels system.print?

   while (scanner.hasNextLine()) { 
       System.out.println(blah blah blah);   
   }
   

Merci.

Answer 1

Si vous n'êtes pas intéressé par les données à base de caractères du fichier texte est contenant, flux juste « brut » sous forme d'octets.

InputStream input = new BufferedInputStream(new FileInputStream("C:/logs.txt"));
byte[] buffer = new byte[8192];

try {
    for (int length = 0; (length = input.read(buffer)) != -1;) {
        System.out.write(buffer, 0, length);
    }
} finally {
    input.close();
}

Cela permet d'économiser le coût de massant inutilement entre les octets et les caractères et également la numérisation et le fractionnement sur les nouvelles lignes et les annexant à nouveau.

En ce qui concerne les performances, vous pouvez trouver intéressant cet article. Selon l'article, un FileChannel avec un réseau de 256K octets qui est lu par un enveloppé ByteBuffer et écrit directement à partir du tableau d'octets est le moyen le plus rapide.

FileInputStream input = new FileInputStream("C:/logs.txt");
FileChannel channel = input.getChannel();
byte[] buffer = new byte[256 * 1024];
ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);

try {
    for (int length = 0; (length = channel.read(byteBuffer)) != -1;) {
        System.out.write(buffer, 0, length);
        byteBuffer.clear();
    }
} finally {
    input.close();
}

Answer 2

Si tout ce que vous voulez faire est d'imprimer le contenu d'un fichier (et ne veulent pas imprimer le prochain int / double / etc.) À la console alors BufferedReader est très bien.

Votre code tel qu'il est ne produira pas le résultat que vous êtes après, cependant. Essayez ceci:

BufferedReader in = new BufferedReader(new FileReader("C:\\logs\\log001.txt"));
String line = in.readLine();
while(line != null)
{
  System.out.println(line);
  line = in.readLine();
}
in.close();

Je ne trop accroché à ce sujet, mais parce qu'il est plus probable que le principal goulot d'étranglement sera la capacité de votre console d'imprimer les informations que Java est de l'envoyer.

Answer 3

Si vous voulez tout est plus efficace de vidage le contenu du fichier à la console sans traitement entre les deux, la conversion des données en caractères et trouver des sauts de ligne est une surcharge inutile. Au lieu de cela, vous pouvez simplement lire des blocs d'octets à partir du fichier et écrire ensuite directement à System.out:

package toconsole;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

public class Main {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        byte[] buffer = new byte[8192];
        int bytesRead = 0;
        try {
            bis = new BufferedInputStream(new FileInputStream(args[0]));
            while ((bytesRead = bis.read(buffer)) != -1) {
                System.out.write(buffer, /* start */ 0, /* length */ bytesRead);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try { bis.close(); } catch (Exception e) { /* meh */ }
        }
    }
}

Dans le cas où vous n'avez pas rencontré ce genre de langage avant, la déclaration en tant que condition deux affecte le résultat de bis.read à bytesRead, puis le compare à -1. Donc, nous continuons la lecture d'octets dans la mémoire tampon jusqu'à ce que nous dit que nous sommes à la fin du fichier. Et nous utilisons bytesRead dans System.out.write pour nous assurer que nous écrivons uniquement les octets que nous venons de lire, que nous ne pouvons pas supposer tous les fichiers sont un multiple de 8 ko long!

Answer 4

Si c'est un fichier relativement faible, un Java d'une ligne de la façon de le faire est:

System.out.println(new String(Files.readAllBytes(Paths.get("logs.txt"))));

Voir https: // docs .oracle.com / JavaSE / 7 / docs / api / java / nio / fichier / package-summary.html pour plus de détails.

Vive!