Java: la lecture des chaînes à partir d'un fichier à accès aléatoire avec tampon d'entrée

Je n'ai jamais eu de fermer les expériences avec Java IO API avant et je suis vraiment frustré maintenant. J'ai du mal à croire à quel étrange et complexe qu'il est et à quel point il pourrait être de faire une tâche simple.

Ma tâche: j'ai 2 positions (à partir de l'octet, la fin de l'octet), pos1 et pos2. J'ai besoin de lire entre les lignes de ces deux octets (y compris le départ, pour ne pas dire la fin d'un) et de les utiliser comme Chaîne UTF8 objets.

Par exemple, dans la plupart des langages de script, il serait très simple 1-2-3-liner comme ça (en Ruby, mais il sera essentiellement le même, Python, Perl, etc):

f = File.open("file.txt").seek(pos1)
while f.pos < pos2 {
  s = f.readline
  # do something with "s" here
}

Il en vient vite l'enfer avec Java IO Api 😉 En fait, je vois deux façons de lire les lignes (se terminant par \n) à partir régulière des fichiers locaux:

  • RandomAccessFile a getFilePointer() et seek(long pos), mais c'est readLine() lit non-UTF8 cordes (et même pas de tableaux d'octets), mais très étrange chaînes brisées de codage, et il n'a pas de mise en mémoire tampon (ce qui veut probablement dire que chaque read*() appel doit être traduit en un seul sous-tendent OS read() => assez lent).
  • BufferedReader a une grande readLine() méthode, et il peut même faire quelques recherche avec skip(long n), mais il n'a aucun moyen de déterminer le nombre d'octets qui a été déjà lu, de ne pas mentionner la position courante dans un fichier.

J'ai essayé d'utiliser quelque chose comme:

    FileInputStream fis = new FileInputStream(fileName);
    FileChannel fc = fis.getChannel();
    BufferedReader br = new BufferedReader(
            new InputStreamReader(
                    fis,
                    CHARSET_UTF8
            )
    );

... et puis, à l'aide de fc.position() pour obtenir fichier en cours de lecture de la position et de fc.position(newPosition) à définir, mais il ne semble pas fonctionner dans mon cas: ressemble, il retourne la position d'une mémoire tampon de pré-remplissage effectué par BufferedReader, ou quelque chose comme ça - ces compteurs semblent être arrondi à 16K incréments.

Dois-je vraiment mettre en œuvre tout cela par moi-même, c'est à dire un fichier readering interface:

  • me permettent d'obtenir/définir la position dans un fichier
  • tampon de lecture du fichier d'opérations
  • permettre la lecture de chaînes de caractères UTF8 (ou au moins permettre à des opérations comme "tout lire jusqu'à la prochaine \n")

Est-il un moyen plus rapide que la mise en œuvre de tout moi-même? Suis-je la supervision de quelque chose?

RandomAccessFile est conçu pour des données binaires. Bien qu'il permet de stocker et de récupérer des chaînes UTF-8 avec writeUTF/readUTF, comme vous l'avez trouvé, son readLine (et le DataInput de l'interface readLine en général) ne fonctionne pas sur UTF-8.
Êtes-vous autorisé à utiliser openJDK 7 (bêta) ou d'un 3ème parti lib comme Apache Commons IO?
merci de poster votre OpenJDK 7 et Apache Commons IO solutions de toute façon. Je suis curieux, et probablement d'autres personnes le sont aussi.
Verburg: je ne peux pas utiliser le JDK 7, mais un 3ème partie les bibliothèques sont les bienvenus. Merci de répondre, c'est intéressant 🙂
Bloom - j'ai donné la version de Java 7 un aller et c'est encore sacrément bavard et il a échoué lors de l'exécution avec les dernières openJDK construire :(. Le seul avantage est que vous pouvez utiliser plusieurs threads de lecture/écriture à partir du même fichier en parallèle. J'ai posté n'importe quoi. J'avoue ne pas avoir regardé les communes de fichier I/O choses encore, je suppose qu'ils avaient une API simple de JDK 1.5/1.6, je vais prendre un coup d'oeil à la prochaine

OriginalL'auteur GreyCat | 2010-11-29

  1. 6
    import org.apache.commons.io.input.BoundedInputStream

FileInputStream file = new FileInputStream(filename);
file.skip(pos1);
BufferedReader br = new BufferedReader(
   new InputStreamReader(new BoundedInputStream(file,pos2-pos1))
);

    Si vous n'avez pas de soins sur pos2, alors vous woundn pas besoin d'Apache Commons IO.

    Merci! Il est dommage que l'origine des Api Java de ne pas inclure une telle fonctionnalité, mais au moins nous avons une solution de contournement comme BoundedStream. J'ai aussi découvert que Google Goyave comprend absolument semblable, LimitedInputStream de classe.

    OriginalL'auteur Ken Bloom

  2. 6

    J'ai écrit ce code pour lire l'utf-8 à l'aide randomaccessfiles

    //File: CyclicBuffer.java
public class CyclicBuffer {
private static final int size = 3;
private FileChannel channel;
private ByteBuffer buffer = ByteBuffer.allocate(size);
public CyclicBuffer(FileChannel channel) {
this.channel = channel;
}
private int read() throws IOException {
return channel.read(buffer);
}
/**
* Returns the byte read
*
* @return byte read -1 - end of file reached
* @throws IOException
*/
public byte get() throws IOException {
if (buffer.hasRemaining()) {
return buffer.get();
} else {
buffer.clear();
int eof = read();
if (eof == -1) {
return (byte) eof;
}
buffer.flip();
return buffer.get();
}
}
}
//File: UTFRandomFileLineReader.java
public class UTFRandomFileLineReader {
private final Charset charset = Charset.forName("utf-8");
private CyclicBuffer buffer;
private ByteBuffer temp = ByteBuffer.allocate(4096);
private boolean eof = false;
public UTFRandomFileLineReader(FileChannel channel) {
this.buffer = new CyclicBuffer(channel);
}
public String readLine() throws IOException {
if (eof) {
return null;
}
byte x = 0;
temp.clear();
while ((byte) -1 != (x = (buffer.get())) &amp;&amp; x != '\n') {
if (temp.position() == temp.capacity()) {
temp = addCapacity(temp);
}
temp.put(x);
}
if (x == -1) {
eof = true;
}
temp.flip();
if (temp.hasRemaining()) {
return charset.decode(temp).toString();
} else {
return null;
}
}
private ByteBuffer addCapacity(ByteBuffer temp) {
ByteBuffer t = ByteBuffer.allocate(temp.capacity() + 1024);
temp.flip();
t.put(temp);
return t;
}
public static void main(String[] args) throws IOException {
RandomAccessFile file = new RandomAccessFile("/Users/sachins/utf8.txt",
"r");
UTFRandomFileLineReader reader = new UTFRandomFileLineReader(file
.getChannel());
int i = 1;
while (true) {
String s = reader.readLine();
if (s == null)
break;
System.out.println("\n line  " + i++);
s = s + "\n";
for (byte b : s.getBytes(Charset.forName("utf-8"))) {
System.out.printf("%x", b);
}
System.out.printf("\n");
}
}
}

    OriginalL'auteur scube

  3. 1

    Pour @Ken Floraison très rapide aller à une version de Java 7. Remarque: je ne pense pas que ce est la façon la plus efficace, je suis toujours obtenir ma tête autour de NIO.2, Oracle a commencé à leur tutoriel ici

    Notez également que ce n'est pas à l'aide de Java 7, le nouveau BRAS de syntaxe (qui s'occupe de la gestion d'Exception pour les fichiers basés sur des ressources), il ne fonctionnait pas dans la dernière openJDK build que j'ai. Mais si les gens veulent voir la syntaxe, laissez-moi savoir.

    /* 
* Paths uses the default file system, note no exception thrown at this stage if 
* file is missing
*/
Path file = Paths.get("C:/Projects/timesheet.txt");
ByteBuffer readBuffer = ByteBuffer.allocate(readBufferSize);
FileChannel fc = null;
try
{
/*
* newByteChannel is a SeekableByteChannel - this is the fun new construct that 
* supports asynch file based I/O, e.g. If you declared an AsynchronousFileChannel 
* you could read and write to that channel simultaneously with multiple threads.
*/
fc = (FileChannel)file.newByteChannel(StandardOpenOption.READ);
fc.position(startPosition);
while (fc.read(readBuffer) != -1)
{
readBuffer.rewind();
System.out.println(Charset.forName(encoding).decode(readBuffer));
readBuffer.flip();
}
}
    Comment lire un fichier ligne par ligne à l'aide de NIO? Est une chose possible?
    J'ai fixé l'exemple de code donc la lecture des œuvres - va déterminer la meilleure façon de lire une ligne (c'est un exercice utile que je suis de retour d'API " à la nio-dev mailing list)
    Je vois la réponse ici javakb.com/Uwe/Forum.aspx/java-programmer/7117/... -- utiliser un java.util.Scanner pour fonctionner sur le canal
    Que serait le travail oui, je viens de réaliser que j'ai utilisé la régulière FileChannel exemple, par opposition à la AsynchronousFileChannel exemple, donc j'ai ajusté mes commentaires ci-dessus. Il est tout puissant, mais il lui reste encore à un niveau supérieur de l'API abstractions à prendre je pense.
    AFAICT, GreyCat encore n'a pas de limite au lecteur de ne pas aller plus loin que pos2

    OriginalL'auteur Martijn Verburg

  4. 0

    Commencer avec un RandomAccessFile et l'utilisation read ou readFully pour obtenir un tableau d'octets entre pos1 et pos2. Disons que nous avons stocké les données lues dans une variable nommée rawBytes.

    Puis de créer votre BufferedReader à l'aide de

    new BufferedReader(new InputStreamReader(new ByteArrayInputStream(rawBytes)))

    Ensuite, vous pouvez appeler readLine sur le BufferedReader.

    Mise en garde: c'est probablement ce qui utilise le plus de mémoire que si on pouvait faire de la BufferedReader chercher au bon endroit lui-même, parce qu'il met tout en mémoire.

    Ce n'est pas une option pour moi: je travaille avec plusieurs gigaoctets de fichiers sur les ordinateurs disposant de peu de mémoire.

    OriginalL'auteur Ken Bloom

  5. 0

    Je pense que la confusion est causée par le codage UTF-8 et la possibilité de caractères à deux octets.

    UTF8 ne précise pas le nombre d'octets dans un seul et unique personnage. Je suis en supposant à partir de votre post que vous êtes en utilisant un seul octet. Par exemple, 412 octets signifierait 411 caractères. Mais si la chaîne ont été en utilisant des caractères à deux octets), vous obtenez le 206 caractère.

    L'origine de java.io paquet n'a pas bien avec ce multi-octets confusion. Donc, ils ont ajouté plus de classes pour traiter spécifiquement avec des chaînes. Le package mélange les deux différents types de gestionnaires de fichiers (et ils peuvent être source de confusion jusqu'à ce que la nomenclature est trié). Le flux classes directement des données I/O, sans aucune conversion. Le lecteur classes de convertir les fichiers vers des chaînes de caractères multi-octets. Qui pourrait aider à clarifier une partie du problème.

    Puisque vous dites que vous êtes à l'aide de caractères UTF-8, vous voulez que le lecteur classes. Dans ce cas, je suggère FileReader. Le skip() la méthode en FileReader vous permet de passer de X caractères, puis démarrez la lecture du texte. Sinon, je préfère la surcharge méthode read() car il vous permet de saisir tout le texte en une seule fois.

    Si vous supposez votre "octets" sont des caractères individuels, essayez quelque chose comme ceci:

    FileReader fr = new FileReader( new File("x.txt") );
char[] buffer = new char[ pos2 - pos ];
fr.read( buffer, pos, buffer.length );
...
    Notez que les lecteurs ignorer les caractères, pas d'octets. Cela empêche l'ambiguïté lorsque l'on travaille avec des inconnus jeux de caractères - est-il de l'octet unique ou à double octet? Dans votre cas, je suppose que c'est tout un octet, donc, "pos" = caractères.
    Je travaille avec unicode complet set - avec plusieurs octets par caractère dans le codage UTF8 - il n'y a pas de problème avec ça. FileReader a essentiellement la même interface que BufferedReader, mais vous proposons de lire l'intégralité de la gamme des octets en mémoire à la fois - mais je ne peux pas le faire, je suis en train de travailler avec plusieurs giga-octets, des plages sur les machines avec d'assez peu de RAM.
    Vous n'avez pas à le faire de cette façon, c'est juste de la pratique. Le plus long est d'utiliser skip() pour obtenir le point, puis utilisez read() pour avoir des personnages hors du flux. Depuis il n'y a pas de mise en mémoire tampon dans cette méthode, vous aurez beaucoup de contrôle sur l'empreinte mémoire. (Vous pouvez toujours obtenir les avantages de la mise en mémoire tampon par emballage de la FileReader avec un BufferedReader. BufferedReader peut être initialisée à une taille très spécifique si vous avez besoin de limiter l'empreinte mémoire.)

    OriginalL'auteur Jonathan B

  6. 0

    Je suis en retard pour la fête ici, mais j'ai couru à travers ce problème dans mon propre projet.

    Après beaucoup de la traversée de la documentation Javadoc et de Dépassement de Pile, je crois que j'ai trouvé une solution simple.

    Après avoir demandé à l'endroit approprié dans votre RandomAccessFile, dont je suis ici l'appel de raFile, procédez de la manière suivante:

    FileDescriptor fd = raFile.getFD();
FileReader     fr = new FileReader(fd);
BufferedReader br = new BufferedReader(fr);

    Alors vous devriez être en mesure d'appeler br.readLine() au contenu de votre coeur, qui sera beaucoup plus rapide que d'appeler raFile.readLine().

    La seule chose que je ne suis pas sûr à ce sujet est de savoir si UTF8 chaînes sont correctement gérés.

    Problème, c'est qu'il n'est toujours pas résolu de garder la trace d'octets lus. J'ai une contrainte que j'ai besoin de retourner des blocs de n octets (par exemple, 64 k octets). UTF8 chaînes seront traitées correctement afaict à partir du JDK source. La lecture de la source de RandomAccessFile est vraiment instructif; Oracle devrait avoir honte à la mise en œuvre de readLine, surtout depuis qu'ils ont un travail correct à l'BufferedReader... pire encore, dans leur sagesse, ils l'ont rendu final donc, nous ne pouvons même pas le réparer
    Bon point: ce n'est pas en charge de l'arrêt se lit à une certaine position. Me semble qu'il serait simple d'encadrer ce code pour le suivi des octets lire, bien que. Aussi, je compatis à votre frustration à l'RandomAccessFile mise en œuvre!

    OriginalL'auteur Jeff Terrell Ph.D.

  7. -1

    La java IO API est très flexible. Malheureusement, parfois, la flexibilité rend bavard. L'idée principale ici est qu'il y a de nombreux cours d'eau, des écrivains et des lecteurs qui mettent en œuvre wrapper patter. Par exemple BufferedInputStream encapsule toute autre InputStream. Le même est sur le flux de sortie.

    La différence entre les flux et les lecteurs/écrivains est que les flux de travail avec des octets tandis que les lecteurs/écrivains travailler avec les personnages.

    Heureusement, certains cours d'eau, les écrivains et les lecteurs ont pratique des constructeurs de simplifier le codage. Si vous voulez lire le fichier, vous avez juste à dire

        InputStream in = new FileInputStream("/usr/home/me/myfile.txt");
if (in.markSupported()) {
in.skip(1024);
in.read();
}

    Il n'est pas si compliqué que ce que vous avez peur.

    Canaux est quelque chose de différent. C'est une partie de soi-disant "nouvelle IO" ou nio. Nouvelle IO n'est pas bloqué - c'est là son principal avantage. Vous pouvez effectuer une recherche dans internet pour tous "nio java tutorial" et lire à ce sujet. Mais c'est plus compliqué que les IO et il n'est pas nécessaire pour la plupart des applications.

    Eh bien, j'ai lu la plupart de ces "différences idéologiques" des explications dans la documentation Javadoc, mais, pour en revenir à ma question initiale: je crois qu'il n'y a pas de moyen simple (comme dans 5-6-10 lignes) pour faire exactement ce que je l'ai démontré dans le langage de script?

    OriginalL'auteur AlexR