Pourquoi BufferedReader read () est-il beaucoup plus lent que readLine ()?

Merci @Voo pour la correction. Ce que j'ai mentionné ci-dessous est correct de FileReader#read() v/s BufferedReader#readLine() point de vue MAIS pas correct de BufferedReader#read() v/s BufferedReader#readLine() point de vue, donc, j'ai barré la réponse.

utiliser read() méthode sur BufferedReader n'est pas une bonne idée, il ne serait pas vous causer de tort, mais il est certain que cela gaspille l'objet de la classe.

but dans la vie de BufferedReader est de réduire l'e/s en tamponnant le contenu. Vous pouvez lire ici dans les tutoriels Java. Vous pouvez également noter que read() méthode dans BufferedReader est en fait hérité de Reader tandis que readLine() est BufferedReader propre méthode.

si vous voulez utiliser la méthode read() alors je dirais que vous devriez utiliser FileReader , qui est destiné à cet effet. Vous pouvez lire ici dans les tutoriels Java.

, je pense que la réponse à votre question est très simple (sans entrer dans le bench-marking et tous que les explications) -

• chaque read() est géré par le système d'exploitation sous-jacent et déclenche l'accès disque, l'activité réseau ou toute autre opération relativement coûteuse.
• quand vous utilisez readLine() alors vous Enregistrez tous ces frais généraux, donc readLine() sera toujours plus rapide que read() , peut ne pas être substantiellement pour les petites données, mais plus rapide.

donc c'est la pratique réponse à ma propre question: N'utilisez pas BufferedReader.read() utilisez FileChannel à la place. (Évidemment, je ne réponds pas à la raison pour laquelle j'ai mis dans le titre). Voici le benchmark rapide et sale, espérons que d'autres le trouveront utile:

@Test
public void testFileChannel() throws IOException{

    FileChannel fileChannel = FileChannel.open(Paths.get("chr1.fa"));
    long n= 0;
    int noOfBytesRead = 0;

    long t0= System.nanoTime();

    while(noOfBytesRead != -1){
        ByteBuffer buffer = ByteBuffer.allocate(10000);
        noOfBytesRead = fileChannel.read(buffer);
        buffer.flip();
        while ( buffer.hasRemaining() ) {
            char x= (char)buffer.get();
            n++;
        }
    }
    long t1= System.nanoTime();
    System.err.println((float)(t1-t0) / 1e6); // ~ 250 ms
    System.err.println("nchars: " + n); // 254235640 chars read
}

avec ~250 ms pour lire l'ensemble du fichier char par char, cette stratégie est considérablement plus rapide que BufferedReader.readLine() (~700 ms), et encore moins read() . Ajouter des instructions if dans la boucle à vérifier x == '\n' et x == '>' fait peu de différence. Mettre aussi un StringBuilder pour reconstruire les lignes n'affecte pas trop le timing. C'est donc très bien pour moi (du moins pour l'instant).

merci à @Marco13 d'avoir mentionné FileChannel.

il n'est pas surprenant de voir cette différence si on y pense. Un test itère les lignes dans un fichier texte, tandis que l'autre itère les caractères.

sauf si chaque ligne contient un caractère, on s'attend à ce que readLine() soit beaucoup plus rapide que la méthode read() .(bien que comme souligné par les commentaires ci-dessus, il est discutable car un BufferedReader tamponne l'entrée, tandis que la lecture du fichier physique pourrait ne pas être la seule performance prise fonctionnement)

si vous voulez vraiment tester la différence entre les 2 je suggère une configuration où vous itérez sur chaque caractère dans les deux tests. Par exemple: quelque chose comme:

void readTest(BufferedReader r)
{
    int c;
    StringBuilder b = new StringBuilder();
    while((c = r.read()) != -1)
        b.append((char)c);
}

void readLineTest(BufferedReader r)
{
    String line;
    StringBuilder b = new StringBuilder();
    while((line = b.readLine())!= null)
        for(int i = 0; i< line.length; i++)
            b.append(line.charAt(i));
}

en plus de ce qui précède, s'il vous plaît utiliser un" outil de diagnostic de performance de Java " pour évaluer votre code. Aussi, readup sur comment microbenchmark code java .

selon la documentation:

Tous "les 151900920" appel de la méthode fait un coûteux système d'appel.

chaque appel de méthode readLine() fait encore un appel système coûteux, cependant, pour plus d'octets à la fois, il y a donc moins d'appels.

une situation similaire se produit lorsque nous faisons la commande update de la base de données pour chaque enregistrement que nous voulons mettre à jour, par rapport à une mise à jour par lots, où nous faisons un appel pour tous les enregistrements.

Java JIT optimise les corps de boucle vides, de sorte que vos boucles ressemblent réellement à ceci:

while((c = fa.read()) != -1);

et

while((line = fa.readLine()) != null);

je vous suggère de lire sur le benchmarking ici et l'optimisation des boucles ici .

quant à savoir pourquoi le temps pris diffère:

• raison un (ceci ne s'applique que si les corps des boucles contiennent du code): dans le premier exemple, vous faites une opération par ligne, dans le second, vous en faites une par caractère. Ceci additionne le plus de lignes / caractères que vous avez.

  while((c = fa.read()) != -1){
      //One operation per character.
  }
  
  while((line = fa.readLine()) != null){
      //One operation per line.
  }
  

• deuxième raison: dans la classe BufferedReader , la méthode readLine() n'utilise pas read() dans les coulisses - elle utilise son propre code. La méthode readLine() fait moins d'opérations par caractère pour lire une ligne, qu'il faudrait pour lire une ligne avec la méthode read() - c'est pourquoi readLine() est plus rapide à lire un fichier entier.

• troisième raison: il faut plus d'itérations pour lire chaque caractère, que pour lire chaque ligne (sauf si chaque caractère est sur une nouvelle ligne); read() est appelé plus de fois que readLine() .