Bueno primeramente aviso que es un poco tocho lo que voy a escribir, así que ojo.
Me estoy leyendo un libro sobre Java (
Beggining Java 2 JDK ) y voy por el tema de lectura de ficheros.
Bien, pues explicando una forma eficiente para leer un fichero que contenga datos de diferentes tipos y longitudes variables me habla del metodo FileChannel.compact(), el cual desplaza los datos correspondientes a position<limit del buffer al inicio de éste.
El libro explica que despues de este desplazamiento, position apunta a position+1 y limit = capacidad_del_buffer.
Bien hasta aquí lo entiendo, lo que no entiendo es en el ejemplo que pone de uso hace una cosa que me pierde:
El fichero a leer contiene lineas que tienen el siguiente formato:
(double)Longitud_de_la_cadena : Cadena de longitud variable : long.
(Me salto las comprobaciones que hace para asegurarse de la existencia del fichero.)
Código:
File aFile = new File( "C:/texto.txt" );
FileInputStream inFile = new FileInputStream( aFile );
FileChannel inChannel = inFile.getChannel();
try
{
ByteBuffer buf = ByteBuffer.allocateDirect( 1024 );
buf.position( buf.limit() ); //Ponemos la posición para el bucle.
int strLength = 0; //Longitud del string
byte[] strChars = null; //Array para el string
while( true )
{
if( buf.remaining() < 8 ) //Si no hay suficiente para almacenar un double
{ //... compactamos y leemos
if( inChannel.read( buf.compact() ) == -1 )
break; //Si ya no queda nada que leer, nos vamos
buf.flip(); //limit=position Position=0;
}
strLength = (int)buf.getDouble();
//Mas codigo similar al bloque condicional anterior pero aplicado a Cadena_de_longitud_variable y a long.
}
}
El codigo, según el libro lo que hace es ir comprobando que aún existan bytes suficientes para albergar el dato que esperamos encontrar y si no lo hay lee mas del fichero.
En la primera iteración, el position del buffer lo hace apuntar a limit para que en if( buf.remaining < 8 ), buf.remaining devuelva 0 y entre en el IF.
Una vez dentro, se ejecuta inChannel.read(), y aquí viene mi duda:
-ejecuta antes buf.compact() o inChannel.read()?
Si como supongo ejecuta antes inChannel.read, entonces la lectura que efectua la inserta en el buffer que devuelve buf.compact() machacándolo, cosa que no tiene mucho sentido porque para eso podría poner buf a secas y te ahorras operaciones inútiles. Para que compactar lo que vas a sobreescribir?
Si ejecuta antes buf.compact() mi duda es la siguiente:
Que es lo que está compactando si position=limit?? Para que compacta si luego se machaca con lo que va a meter inChannel.read() ?
Espero haberme explicado bien, se que es un tocho. Si hace falta pongo el resto del codigo, pero ya digo que es parecido al primer bloque IF.