Comment utiliser AsynchronousFileChannel pour lire à un StringBuffer efficace

Question

Vous savez que vous pouvez utiliser AsynchronousFileChannel pour lire un fichier entier à une chaîne:

AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(filePath, StandardOpenOption.READ); 
      long len = fileChannel.size(); 

      ReadAttachment readAttachment = new ReadAttachment(); 
      readAttachment.byteBuffer = ByteBuffer.allocate((int) len); 
      readAttachment.asynchronousChannel = fileChannel; 

      CompletionHandler<Integer, ReadAttachment> completionHandler = new CompletionHandler<Integer, ReadAttachment>() { 

       @Override 
       public void completed(Integer result, ReadAttachment attachment) { 

        String content = new String(attachment.byteBuffer.array()); 
        try { 
         attachment.asynchronousChannel.close(); 
        } catch (IOException e) { 
         e.printStackTrace(); 
        } 
        completeCallback.accept(content); 
       } 

       @Override 
       public void failed(Throwable exc, ReadAttachment attachment) { 
        exc.printStackTrace(); 
        exceptionError(errorCallback, completeCallback, String.format("error while reading file [%s]: %s", path, exc.getMessage())); 
       } 
      }; 

      fileChannel.read(
        readAttachment.byteBuffer, 
        0, 
        readAttachment, 
        completionHandler); 

Supposons que maintenant, je ne veux pas affecter un ensemble ByteBuffer , mais lisez ligne par ligne. Je pourrais utiliser un ByteBuffer de largeur fixe et continuer à rappeler read plusieurs fois, en copiant et en ajoutant toujours à un StringBuffer jusqu'à ce que je n'obtienne pas à une nouvelle ligne ... Ma seule préoccupation est: parce que l'encodage du dossier que je lis peut être multi octet par caractère (quelque chose UTF), il peut arriver que les octets lus se terminent par un caractère incomplet. Comment puis-je m'assurer que je convertis les bons octets en chaînes et que je ne gâche pas l'encodage?

MISE À JOUR: réponse est dans le commentaire de la réponse sélectionnée, mais il pointe essentiellement à CharsetDecoder.

Answer 1

Si vous avez un séparateur ASCII clair dans votre cas (\ n), vous ne devez pas vous soucier de la chaîne incomplète car ce caractère est mappé sur singlebyte (et vice versa).

Il suffit donc de rechercher '\ n' octet dans votre entrée et de lire et convertir n'importe quoi avant en String. Boucle jusqu'à ce que plus aucune nouvelle ligne ne soit trouvée. Ensuite, compactez le tampon et réutilisez-le pour la lecture suivante. Si vous ne trouvez pas de nouvelle ligne, vous devrez allouer un tampon plus grand, copier le contenu de l'ancien et seulement ensuite appeler à nouveau la lecture.

EDIT: Comme mentionné dans le commentaire, vous pouvez passer le ByteBuffer à CharsetDecoder à la volée et le traduire en CharBuffer (puis ajouter à StringBuilder ou à tout ce qui est la solution préférée).

Answer 2

Essayez Scanner:

Scanner sc = new Scanner(FileChannel.open(filePath, StandardOpenOption.READ)); 
    String line = sc.readLine(); 

FileChannel est InterruptibleChannel