Múltiples formas de leer archivos en Java 1. Lea el contenido del archivo de múltiples maneras.
1. Leer el contenido del archivo por bytes
2. Leer el contenido del archivo por carácter
3. Lea el contenido del archivo línea por línea
4. Leer aleatoriamente el contenido del archivo.
*/
importar java.io.BufferedReader;
importar java.io.File;
importar java.io.FileInputStream;
importar java.io.FileReader;
importar java.io.IOException;
importar java.io.InputStream;
importar java.io.InputStreamReader;
importar java.io.RandomAccessFile;
importar java.io.Reader;
clase pública ReadFromFile {
/**
* Leer archivos en bytes, que a menudo se utiliza para leer archivos binarios, como imágenes, sonidos, imágenes, etc.
* @param fileName El nombre del archivo
*/
público estático vacío readFileByBytes (String fileName) {
Archivo archivo = nuevo archivo (nombre de archivo);
InputStream en = nulo;
intentar {
System.out.println("Lea el contenido del archivo en bytes, un byte a la vez:");
//Leer un byte a la vez
en = nuevo FileInputStream(archivo);
int tempbyte;
mientras((tempbyte=in.read()) != -1){
System.out.write(tempbyte);
}
cercar();
} captura (IOException e) {
e.printStackTrace();
devolver;
}
intentar {
System.out.println("Lea el contenido del archivo en bytes, varios bytes a la vez:");
//Leer varios bytes a la vez
byte[] tempbytes = nuevo byte[100];
int lectura de bytes = 0;
en = nuevo FileInputStream (nombre de archivo);
ReadFromFile.showAvailableBytes(en);
//Lee varios bytes en la matriz de bytes, byteread es el número de bytes leídos al mismo tiempo
mientras ((byteread = in.read(tempbytes)) != -1){
System.out.write(tempbytes, 0, lectura de bytes);
}
} captura (Excepción e1) {
e1.printStackTrace();
} finalmente {
si (en != nulo){
intentar {
cercar();
} captura (IOException e1) {
}
}
}
}
/**
* Leer archivos en unidades de caracteres, a menudo utilizados para leer texto, números y otros tipos de archivos.
* @param fileName nombre del archivo
*/
readFileByChars vacío estático público (nombre de archivo de cadena) {
Archivo archivo = nuevo archivo (nombre de archivo);
Lector lector = nulo;
intentar {
System.out.println("Lea el contenido del archivo en unidades de caracteres, un byte a la vez:");
//Leer un carácter a la vez
lector = nuevo InputStreamReader (nuevo FileInputStream (archivo));
tempchar int;
mientras ((tempchar = lector.read()) != -1){
//Para Windows, cuando los dos caracteres rn están juntos, representan una nueva línea.
//Pero si estos dos caracteres se muestran por separado, las líneas se cambiarán dos veces.
//Por lo tanto, escudo r, o escudo n. De lo contrario, habrá muchas líneas en blanco.
si (((char)tempchar) != 'r'){
System.out.print((char)tempchar);
}
}
lector.close();
} captura (Excepción e) {
e.printStackTrace();
}
intentar {
System.out.println("Lea el contenido del archivo en unidades de caracteres, varios bytes a la vez:");
//Leer varios caracteres a la vez
char[] tempchars = nuevo char[30];
int charread = 0;
lector = nuevo InputStreamReader (nuevo FileInputStream (nombre de archivo));
//Lee varios caracteres en la matriz de caracteres, charread es el número de caracteres leídos a la vez
mientras ((charread = lector.read(tempchars))!=-1){
//Del mismo modo protegemos a r para que no se muestre
if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){
System.out.print(tempchars);
}demás{
para (int i=0; i<charread; i++){
si(tempchars[i] == 'r'){
continuar;
}demás{
System.out.print(tempchars[i]);
}
}
}
}
} captura (Excepción e1) {
e1.printStackTrace();
}finalmente {
si (lector! = nulo) {
intentar {
lector.close();
} captura (IOException e1) {
}
}
}
}
/**
* Leer archivos en unidades de línea, a menudo utilizado para leer archivos formateados orientados a líneas
* @param fileName nombre del archivo
*/
readFileByLines vacío estático público (nombre de archivo de cadena) {
Archivo archivo = nuevo archivo (nombre de archivo);
Lector BufferedReader = nulo;
intentar {
System.out.println("Lea el contenido del archivo en unidades de línea, leyendo una línea completa a la vez:");
lector = nuevo BufferedReader(nuevo FileReader(archivo));
Cadena tempString = nulo;
línea interna = 1;
//Leer una línea a la vez hasta que se lea null como final del archivo
mientras ((tempString = lector.readLine()) != nulo){
//muestra el número de línea
System.out.println("linea " + linea + ": " + tempString);
línea++;
}
lector.close();
} captura (IOException e) {
e.printStackTrace();
} finalmente {
si (lector! = nulo) {
intentar {
lector.close();
} captura (IOException e1) {
}
}
}
}
/**
* Leer aleatoriamente el contenido del archivo.
* @param fileName nombre del archivo
*/
readFileByRandomAccess público estático vacío (String fileName) {
RandomAccessFile randomFile = nulo;
intentar {
System.out.println("Leer el contenido de un archivo aleatorio:");
// Abre una secuencia de archivos de acceso aleatorio en modo de solo lectura
randomFile = new RandomAccessFile(nombredearchivo, "r");
//Longitud del archivo, número de bytes
long fileLength = randomFile.length();
//Leer la posición inicial del archivo
int comenzarIndex = (longitud del archivo > 4)?
//Mueve la posición inicial del archivo leído a la posición de inicio de índice.
randomFile.seek(beginIndex);
byte[] bytes = nuevo byte[10];
int lectura de bytes = 0;
//Lee 10 bytes a la vez. Si el contenido del archivo tiene menos de 10 bytes, lee los bytes restantes.
//Asigna el número de bytes leídos a la vez a byteread
mientras ((byteread = randomFile.read(bytes)) != -1){
System.out.write(bytes, 0, lectura de bytes);
}
} captura (IOException e){
e.printStackTrace();
} finalmente {
si (archivo aleatorio! = nulo) {
intentar {
archivo aleatorio.close();
} captura (IOException e1) {
}
}
}
}
/**
* Muestra el número de bytes restantes en el flujo de entrada.
* @param en
*/
espectáculo vacío estático privadoAvailableBytes(InputStream in){
intentar {
System.out.println("El número de bytes en el flujo de entrada de bytes actual es:" + in.available());
} captura (IOException e) {
e.printStackTrace();
}
}
público estático vacío principal (String [] argumentos) {
Nombre de archivo de cadena = "C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(nombre de archivo);
ReadFromFile.readFileByChars(nombre de archivo);
ReadFromFile.readFileByLines(nombredearchivo);
ReadFromFile.readFileByRandomAccess (nombre de archivo);
}
}
2. Agregue contenido al final del archivo.
importar java.io.FileWriter;
importar java.io.IOException;
importar java.io.RandomAccessFile;
/**
* Agregar contenido al final del archivo.
*/
clase pública AppendToFile {
/**
*Un método para agregar archivos: use RandomAccessFile
* @param fileName nombre del archivo
* @param contenido contenido adicional
*/
appendMethodA público estático vacío (nombre de archivo de cadena,
Contenido de cadena){
intentar {
// Abre una secuencia de archivos de acceso aleatorio, en modo lectura y escritura
RandomAccessFile randomFile = new RandomAccessFile(nombredearchivo, "rw");
//Longitud del archivo, número de bytes
long fileLength = randomFile.length();
//Mueve el puntero de escritura del archivo al final del archivo.
randomFile.seek(fileLength);
randomFile.writeBytes(contenido);
archivo aleatorio.close();
} captura (IOException e){
e.printStackTrace();
}
}
/**
* Método B para agregar archivos: use FileWriter
* @param nombre de archivo
* @param contenido
*/
appendMethodB vacío estático público (nombre de archivo de cadena, contenido de cadena) {
intentar {
//Abrir un escritor de archivos. El segundo parámetro verdadero en el constructor significa escribir el archivo en forma de anexo.
Escritor de FileWriter = nuevo FileWriter (nombre de archivo, verdadero);
escritor.write(contenido);
escritor.close();
} captura (IOException e) {
e.printStackTrace();
}
}
público estático vacío principal (String [] argumentos) {
Nombre de archivo de cadena = "C:/temp/newTemp.txt";
Contenido de cadena = "¡nuevo anexo!";
//Agregar archivos según el método A
AppendToFile.appendMethodA(nombre de archivo, contenido);
AppendToFile.appendMethodA(fileName, "append end. n");
//Mostrar contenido del archivo
ReadFromFile.readFileByLines(nombredearchivo);
//Agregar archivos según el método B
AppendToFile.appendMethodB(nombre de archivo, contenido);
AppendToFile.appendMethodB(fileName, "append end. n");
//Mostrar contenido del archivo
ReadFromFile.readFileByLines(nombredearchivo);
}
}