Cuando Java lee un archivo de texto enorme, ¿cómo garantizar tanto el desbordamiento de la memoria como el rendimiento?
Importar Java .io . file;
Importar Java. nio. byte buffer;
Importar Java.mappedbytebuffer;
Importar canal de archivos Java. p>
Importar Java. nio.mappedbytebuffer;
Importar canales de archivos Java;
p>
Clase pública ReadBig. p>Cadena estática pública fff = " C:\ \ MQ \ \ read \ \ from . XML "
La estática pública void main1( String[] args) arroja una excepción {
final int BUFFER _ TAMAÑO = 0x300000//El tamaño del búfer es 3M.
Archivo f = nuevo archivo(fff);
/**
*
*Map(archivo canal.Modo MapMode, posición larga, tamaño largo)
* Modo: asigna archivos según si son de solo lectura, lectura/escritura o privados (copia en escritura), según se define en el canal de archivos. Clase MapMode.
*Uno de solo lectura, lectura-escritura o privado.
*
* posición: la posición al comienzo del área de mapeo en el archivo debe ser un número no negativo
*
;* tamaño a asignar El tamaño de la región no debe ser negativo y no debe ser mayor que un número entero. MAX_VALUE.
*
*Entonces, si desea leer la segunda mitad del archivo, tal como está escrito en el ejemplo, si desea leer el último 1/8 del archivo; texto, necesita escribir el mapa (Canal de archivo. mapmode.read_only
*Longitud completa()*7/8, Longitud completa()/8)
*
*Obligatorio Para leer todo el contenido de un archivo, debe escribir map(file channel. mapmode.read_only, 0, f.length()) así.
*
*/
Búfer de entrada MappedByteBuffer = nuevo archivo de acceso aleatorio (f, " r ")
. obtenerCanal(). map(filechannel.MapMode.readonly,
f.length()/2, f.length()/2
byte[] dst = nuevo byte[ BUFFER_SIZE]; //Leer contenido de 3M a la vez.
inicio largo = sistema . hora actual milisegundos();
for(int offset = 0; offset & ltinput buffer . capacidad(); offset += BUFFER_SIZE) {
if(búfer de entrada. capacidad()-offset>=tamaño del búfer){
for(int I = 0;i<BUFFER_SIZEi++)
dst[I] = búfer de entrada . get(offset+I);
} else {
for(int I = 0; i<inputBuffer.capacity() - offset ;i++)
dst [I]= búfer de entrada. get(desplazamiento+I);
}
int longitud =(búfer de entrada. capacidad() % BUFFER_SIZE == 0)? Tamaño del búfer
:entrada BUFFER . capacidad()% BUFFER _ TAMAÑO;
sistema salida . p>
// String(dst, 0, length) para recuperar la cadena guardada en el caché para su operación.
}
long end = system . hora actual millis();
System.out.println("Leer la mitad de un archivo requiere"+ (end). -start)+" ms ");
}
Public static void main2(String[] args) lanza una excepción {
int bufSize = 1024 ;
byte[] bs = nuevo byte[bufSize];
byte buffer byte buf = byte buffer allocate(1024);
canal de archivo = nuevo aleatorio. acceder al archivo(fff, "r"). obtener canal();
mientras (channel.read(byteBuf)!= -1) {
int tamaño = byte buf();
. byte buf . rewind();
byte buf .get(bs); // Toma el archivo como una cadena e imprímelo directamente como ejemplo.
System.out.print(nueva cadena (bs, 0, tamaño));
byte buf .
}
}
Public static void main(String[] args) arroja una excepción {
lector almacenado en búfer br = nuevo lector almacenado en búfer (nuevo lector de archivos (fff));
Línea de cadena = nulo
mientras ((línea = br.readLine())!= nulo) {
sistema println(línea);
>}
}
}