Archivo randomaccess
RandomAccessFile se usa para acceder a archivos que guardan registros de datos. Puede usar el método Seek () para acceder a los registros y leer y escribir. El tamaño de estos registros no tiene que ser el mismo; Sin embargo, se debe conocer su tamaño y posición. Sin embargo, esta clase se limita a los archivos operativos.
RandomAccessFile no pertenece a las clases InputStream y OutputStream. De hecho, además de implementar las interfaces DataAnput y DataOutput (DataInputStream y DataOutputStream también implementan estas dos interfaces), no tiene nada que ver con estas dos clases, y ni siquiera usa ninguna función que ya existan en las clases InputStream y OutputStream; Es una clase completamente independiente, y todos los métodos (en su mayoría solo pertenecen a sí mismo) se escriben desde cero. Esto puede deberse a que RandomAccessFile puede moverse de un lado a otro en el archivo, por lo que su comportamiento es algo fundamentalmente diferente de otras clases de E/S. En resumen, es una clase separada que hereda directamente el objeto.
Básicamente, el método de trabajo de RandomAccessFile es combinar DataRenPutStream y DataOutputStream, y agregar algunos de sus propios métodos, como GetFilePointer () para posicionarse, buscar () para moverse en el archivo y determinar la longitud () para el tamaño del archivo, y Skipbytes () para Skip por cuántos bytes salta. Además, su constructor también tiene un parámetro que indica si abrir el archivo en modo de solo lectura ("R") o el modo de lectura-escritura ("RW") (exactamente lo mismo que el Fopen () de C). No admite escribir solo archivos.
Solo RandomAccessFile tiene un método de búsqueda de búsqueda, y este método solo es aplicable a los archivos. BufferedInputStream tiene un método Mark (), que puede usar para establecer la marca (guarde el resultado en una variable interna), y luego llame a RESET () para volver a esta posición, pero su función es demasiado débil y no muy práctica.
La mayoría de las funciones de RandomAccessFile, pero no todas, han sido reemplazadas por los "archivos mapeados de memoria" de JDK 1.4. Debe considerar si usar "archivos mapeados de memoria" en lugar de RandomAccessFile.
import java.io.ioException; import java.io.randomaccessfile; public class testRandomAccessFile {public static void main (string [] args) lanza ioexception {randomAccessFile rf = new RandomAccessFile ("rtest.dat", "rw"); for (int i = 0; i <10; i ++) {// Escribir datos básicos de doble data rf.WriteDouble (i * 1.414); } rf.close (); rf = new RandomAccessFile ("rtest.dat", "rw"); // gire directamente mueva el puntero del archivo al quinto doble datos rf.seek (5 * 8); // sobrescribe los sextos datos dobles rf.WriteDouble (47.0001); rf.close (); rf = new RandomAccessFile ("rtest.dat", "r"); for (int i = 0; i <10; i ++) {system.out.println ("valor" + i + ":" + rf.readdouble ()); } rf.close (); }}Archivo mapeado de memoria
Los archivos mapeados de memoria le permiten crear y modificar archivos que son demasiado grandes para poner en la memoria. Con el archivo mapeado de memoria, puede pensar que el archivo ha sido leído en la memoria y acceder a él como una matriz muy grande. Esta solución puede simplificar enormemente el código de modificación de archivos.
filechannel.map (filechannel.mapmode, modo, posición larga, tamaño largo) mapea el área de archivo de este canal directamente en la memoria. Tenga en cuenta que debe indicar de dónde se mapea y cuán grande es el rango del mapa; Es decir, también puede mapear un pequeño fragmento de un archivo grande.
MappedByteBuffer es una subclase de Bytebuffer, por lo que tiene todos los métodos de ByteBuffer, pero se agrega una nueva fuerza () para forzar el contenido del contenido del búfer al dispositivo de almacenamiento, cargue () cargue los datos en el dispositivo de almacenamiento en la memoria y isloaded () en la ubicación de memoria si los datos en la memoria están sincronizados con la configuración de almacenamiento. Aquí solo demostramos brevemente los métodos put () y get (). Además, también puede usar métodos como Ascharbuffer () para obtener la vista almacenada de los datos de tipo básico correspondientes, que pueden leer y escribir fácilmente datos de tipo básico.
import java.io.randomaccessfile; import java.nio.MappedByteBuffer; import java.nio.channels.filechannel; clase pública LargemappedFiles {static int longitud = 0x8000000; // 128 MB Public static void main (String [] args) arroja una excepción {// Para abrir el archivo de manera legible y redonda, RandomAccessFile se usa aquí para crear el archivo. FileChannel fc = new RandomAccessFile ("test.dat", "rw"). GetChannel (); // Tenga en cuenta que el canal de archivos legible y de escritura debe estar basado en la transmisión de archivos legible y redactable en sí. MappedByteBuffer out = fc.map (filechannel.mapmode.read_write, 0, longitud); // Escribir contenido de 128m para (int i = 0; i <longitud; i ++) {out.put ((byte) 'x'); } System.out.println ("terminado de escribir"); // leer 6 bytes del centro del archivo para (int i = longitud / 2; i <longitud / 2+6; i ++) {System.out.print ((char) out.get (i)); } fc.close (); }}Aunque parece que FileOutputStream se usa para la asignación de escritura, todas las salidas en el archivo de asignación deben usar RandomAccessFile, pero si solo necesita leer FileInputStream, debe usar un archivo de acceso aleatorio al escribir archivos de asignación. Quizás la razón para leer al escribir.
El programa crea un archivo de 128 MB. Si lee la memoria al mismo tiempo, puede causar desbordamiento de memoria, pero el acceso aquí parece ser solo un momento, porque solo una pequeña parte de ella en realidad se transfiere a la memoria, y el resto se coloca en el archivo de intercambio. De esta manera, puede modificar fácilmente archivos súper grandes (hasta 2 GB). Tenga en cuenta que Java llama al "mecanismo de mapeo de archivos" del sistema operativo para mejorar el rendimiento.
Aplicación de la clase RandomAccessFile:
/ * * Función del programa: demuestre el funcionamiento de la clase RandomAccessFile e implementa una operación de copia de archivo. */ paquete com.lwj.demo; import java.io.*; Public Class RandomAtAssFileDeMo {public static void main (string [] args) lanza la excepción {randomAccessFile file = new RandomAccessFile ("archivo", "rw"); // El siguiente escribe datos en el archivo File.WriteInt (20); // Ocupa 4 bytes file.writeDouble (8.236598); // ocupa 8 bytes file.writeutf ("Esta es una cadena UTF"); // Esta longitud se escribe en los dos primeros bytes del Puntero de archivo actual. File.WriteBoolean (true); // ocupa 1 byte file.WriteShort (395); // ocupa 2 bytes file.writeLong (2325451l); // ocupa 8 bytes file.writeutf ("otra cadena utf"); file.writeFloat (35.5f); // ocupa 4 bytes file.writeChar ('a'); // ocupa 2 bytes file.seek (0); // Establezca la posición del puntero del archivo en el inicio del archivo // El siguiente es para leer los datos del archivo. Preste atención a la ubicación del puntero de archivo System.out.println ("" ... ... ... Bytes, y en este caso se omiten un valor booleano y un valor corto. System.out.println (file.readfloat ()); // lo siguiente demuestra la operación de copia de archivo System.out.println ("" ... ... número) byte [] b = nuevo byte [Len]; RandomAccessFile Inserción Ejemplo de escritura:
/ **** @param omita cuántos bytes omitir para insertar datos* @param str string para insertar* @param ruta del archivo de nombre de archivo*/ public static void beiju (long skip, string str, string filename) {try {randomAtAccessFile raf = new RandomAccessFile (nombre de archivo, "rw"); if (skip <0 || skip> raf.length ()) {System.out.println ("Skip Number of Skipped Bytes no es válido"); devolver; } byte [] b = str.getBytes (); raf.setLength (raf.length () + b.length); para (long i = raf.length () - 1; i> b.length + skip - 1; i -) {raf.seek (i - b.length); byte temp = raf.readbyte (); raf.seek (i); raf.writyte (temp); } raf.seek (saltar); raf.write (b); raf.close (); } catch (Exception e) {E.PrintStackTrace (); }}Use RandomAccessFile para realizar una descarga de archivos múltiples, es decir, cuando múltiples hilos descargan un archivo, el archivo se divide en varias piezas y cada pieza se descarga con un hilo diferente. Aquí hay un ejemplo del uso de múltiples lecturas al escribir archivos, donde el espacio requerido para el archivo se al asignar, luego se ajusta en el espacio asignado y luego se escribe:
import java.io.filenotfoundException; import java.io.ioException; import java.io.randomaccessfile; /*** Prueba utilizando Multithreading para operaciones de escritura de archivos*/Public Class Test {public static void main (String [] args) lanza la excepción {// espacio de disco pre-alsocado, un archivo de un tamaño especificado se creará en el disco randomaccessfile raf = new randomaccessfile ("d: //abc.txt", "rw"); raf.setLength (1024*1024); // space de archivo 1M pre-asignado raf.close (); // El contenido de archivo para ser escrito String S1 = "Primera cadena"; Cadena s2 = "segunda cadena"; Cadena s3 = "tercera cadena"; Cadena S4 = "Cuarta cadena"; Cadena s5 = "quinta cadena"; // Escribe un archivo al mismo tiempo usando múltiples hilos nuevos FileWriteThread (1024*1, S1.getBytes ()). Start (); // Escribir datos de 1024 bytes del archivo nuevo FileWriteThread (1024*2, S2.getBytes ()). Start (); // Escribir datos de 2048 bytes del archivo nuevo FileWriteThread (1024*3, S3.getBytes ()). Start (); // Escribir datos de 3072 bytes del archivo nuevo FileWriteThread (1024*4, S4.GetBytes ()). Start (); // Escribir datos de 4096 bytes del archivo nuevo FileWriteThread (1024*5, S5.getBytes ()). Start (); // Escribir datos de 5120 bytes del archivo} // Use un subproceso para escribir datos especificados en la ubicación especificada del archivo de clase estática FileWriteThread extiende el hilo {private int skip; Contenido de byte privado []; Public FileWriteThread (int Skip, byte [] content) {this.skip = skip; this.content = content; } public void run () {randomAccessFile raf = null; intente {raf = new RandomAccessFile ("d: //abc.txt", "rw"); raf.seek (omitir); raf.write (contenido); } catch (FileNotFoundException e) {E.PrintStackTrace (); } Catch (ioException e) {// tODO Auto Generated BLOCK E.PrintStackTRace (); } finalmente {try {raf.close (); } catch (excepción e) {}}}}}}}La explicación detallada del uso de Java RandomAccessfile anterior es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.