Bonjour a tous.

J'ai écris un petit programme qui permet de suivre les résultats d'un solver. ce solver écrit ses résultats dans un fichier relativement fréquemment.

Le programme permet de mettre a jour les données affichées en relisant le fichier. La mise ajour peut être faite soit en lisant le fichier depuis le début (chargement de toute les données), soit en sautant les lignes déjà lu et lire les données présentes après.

J'utilise actuellement un BufferedReader pour accéder aux données mais je souhaiterai maintenant implémenter une méthode plus intelligente lorsqu'il s'agit de la deuxième méthode de lecture: je cherche une méthode pour continuer a lire mes données une fois fois la fin du buffer atteinte (lorsque readline() retourne null).

quelqu'un aurait une suggestion ?

Merci!

Bonjour.

Pour information la commande Unix "tail" permet de surveiller un fichier, et afficher les nouvelles lignes qui sont ajoutées.
Pratique pour un fichier de logs par exemple.

En recherchant sur Google "Java tail" j'ai trouvé la classe org.apache.commons.io.input.Tailer
Après test rapide cela devrait être ce que tu cherches !

Bonjour,

L’idée du tailer est intéressante pour faire une mise a jour automatique des données, ce qui n'est pas mon cas actuellement. Pour l'instant je souhaite déclencher la mise a jour via une action de l'utilisateur.

le genre de procédure que j'aimerai obtenir serait quelque chose du genre:

• Initialisation du bufferedReader
• Lecture du fichier jusqu’à ce le buffer soit vide
• mettre a jour l'affichage
• L'utilisateur demande le rafraîchissement
• Reprise de la lecture du buffer qui s'est mis a jour pendant ce temps (avec de nouvelles données)
• Lecture jusqu’à la fin de nouvelles données
• fermeture du bufferedreader et filereader une fois le programme terminé

Est-ce que quelque chose de ce genre est realisable ?

Merci!

Il faut savoir réutiliser les choses qui existent !

2 solutions :

• Tu réutilises org.apache.commons.io.input.Tailer, :
  Lors du lancement il va lire l'intégralité du fichier : très bien c'est ce que tu veux.
  Ensuite pour chaque modification il va exécuter ton listener : tu stockes les informations dans une Collection.
  Lorsque l'utilisateur veut rafraichir les données, tu ajoutes les données stockées aux données initiales.
• Utiliser java.io.BufferedReader et garder l'état du Stream la fin de la lecture (lorsque readLine() retourne null) : c'est à dire garder une référence sur ton Reader.
  Lorsque l'utilisateur veut rafraichir les données alors tu reprends la lecture là où il en était.
  Exemple : si tu veux tester
  

  BufferedReader reader = new BufferedReader(new FileReader("toto.txt"));
  String line;
  
  // 1ère lecture
  while ((line = reader.readLine()) != null) {
      // ...
  }
  
  Thread.sleep(5_000); // tu as 5sec pour modifier ton fichier
  
  // 2ème lecture
  while ((line = reader.readLine()) != null) {
      // ...
  }
  
  Thread.sleep(5_000); // tu as 5sec pour modifier ton fichier
  
  // 3ème lecture
  while ((line = reader.readLine()) != null) {
      // ...
  }

Ce que je me demandais c'est en effet s'il était possible de faire ce que tu fait dans ton exemple avec le bufferedreader: continuer la lecture du fichier.

J'avais un test identique pour vérifier et j'en était arriver la conclusion que ce n’était plus possible d’accéder aux données du fichier une fois que le buffer avait retourner null.

Je vais re-essayer pour voir!

Je marquerai le sujet comme résolu si cela fonctionne!

J'ai testé un bout de code quasiment identique (j'ai factorisé le while dans une classe avec comme attribut le Reader) et cela a fonctionné parfaitement.

Mais il est possible que certains flux ait un état qui change à la fin de la lecture, ou se ferme.
Cela ne me choquerait pas. 

Notes :

• cela ne prend pas en compte les modifications
• attention à la fermeture du flux

-
Edité par Pinguet62 28 août 2015 à 14:19:36