English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Hace tanto tiempo que trabajo en proyectos relacionados con WEB en Java, que prácticamente he olvidado algunas clases básicas. A menudo quiero recuperarme, pero siempre por alguna razón, no puedo cumplir con mi deseo.
En realidad, no es que no tengamos tiempo, a veces estamos demasiado cansados de hacer resúmenes, hoy tengo tiempo, he decidido con determinación recoger todo lo que he perdido.
La lectura y escritura de archivos es una tarea común en los proyectos, a veces debido al mantenimiento, a veces debido al desarrollo de nuevas funcionalidades. Nuestra tarea siempre es muy pesada, el ritmo de trabajo es rápido, tan rápido que no podemos detenernos para hacer un resumen.
Existen varios métodos comunes para la lectura y escritura de archivos
1、lectura/escritura por byte (InputStream/OutputStream）
2、lectura por carácter (FileReader/FileWriter）
3、lectura por línea (BufferedReader/BufferedWriter）
Código (tomando la lectura como ejemplo):
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
/**
* <b>文件读取类</b><br />
* 1、按字节读取文件内容<br />
* 2、按字符读取文件内容<br />
* 3、按行读取文件内容<br />
* @author qin_xijuan
*
*/
public class FileOperate {
private static final String FILE_PATH = "d:/work/the List of Beautiful Music.txt";
/**
* Leer el contenido del archivo por byte
* @param filePath：需要读取的文件路径
*/
public static void readFileBybyte(String filePath) {
File file = new File(filePath);
// InputStream: Esta clase abstracta es la superclase de todas las clases que representan flujos de entrada de bytes.
InputStream ins = null ;
try{
// FileInputStream: Obtiene bytes de entrada de un archivo en el sistema de archivos.
ins = new FileInputStream(file);
int temp ;
// read(): lee el siguiente byte de un flujo de entrada.
while((temp = ins.read())!=-1){
System.out.write(temp);
}
}
catch(Exception e){
e.getStackTrace();
}
finally{
if (ins != null){
try{
ins.close();
}
catch(IOException e){
e.getStackTrace();
}
}
}
}
/**
* Leer el contenido del archivo por carácter
* @param filePath
*/
public static void readFileByCharacter(String filePath){
File file = new File(filePath);
// FileReader: una clase conveniente para leer archivos de caracteres.
FileReader reader = null;
try{
reader = new FileReader(file);
int temp ;
while((temp = reader.read()) != -1){
if (((char) temp) != '\r') {
System.out.print((char) temp);
}
}
}
catch(IOException e){
e.getStackTrace();
}
finally{
if (reader != null){
try {
reader.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* Leer el contenido del archivo por línea
* @param filePath
*/
public static void readFileByLine(String filePath){
File file = new File(filePath);
// BufferedReader: lee texto desde un flujo de entrada de caracteres, almacena cada carácter en un búfer, lo que permite una lectura eficiente de caracteres, arreglos y líneas.
BufferedReader buf = null;
try{
// FileReader: una clase conveniente para leer archivos de caracteres.
buf = new BufferedReader(new FileReader(file));
// buf = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
String temp = null ;
while ((temp = buf.readLine()) != null ){
System.out.println(temp);
}
}
catch(Exception e){
e.getStackTrace();
}
finally{
if(buf != null){
try{
buf.close();
}
catch (IOException e) {
e.getStackTrace();
}
}
}
}
public static void main(String args[]) {
readFileBybyte(FILE_PATH);
readFileByCharacter(FILE_PATH);
readFileByLine(FILE_PATH);
}
}
//-----------------------------------------------------------------分割线-----------------------------------------------------------------------------
再经过两位同行的提点下，我对之前写的文件做了点修改，并通过读写一个1.2M的文本文件来测试各方法的性能。从多次测试结果来看，行读写确实是Java.nio更有效率。
经过修改之后的代码如下：
package com.waddell.basic;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
/**
* <b>文件读取类</b><br />
* 1、按字节读取文件内容<br />
* 2、按字符读取文件内容<br />
* 3、按行读取文件内容<br />
*
* @author qin_xijuan
*
*/
public class FileOperate {
private static final String FILE_PATH = "d:/work/jipinwodi.txt";
/**
* 以字节为单位读写文件内容
*
* @param filePath
* ：需要读取的文件路径
*/
public static void readFileBybyte(String filePath) {
File file = new File(filePath);
// InputStream: Esta clase abstracta es la superclase de todas las clases que representan flujos de entrada de bytes.
InputStream ins = null;
OutputStream outs = null;
try {
// FileInputStream: Obtiene bytes de entrada de un archivo en el sistema de archivos.
ins = new FileInputStream(file);
outs = new FileOutputStream("d:/work/readFileByByte.txt");
int temp;
// read(): lee el siguiente byte de un flujo de entrada.
while ((temp = ins.read()) != -1) {
outs.write(temp);
}
}
catch (Exception e) {
e.getStackTrace();
}
finally {
if (ins != null && outs != null) {
try {
outs.close();
ins.close();
}
catch (IOException e) {
e.getStackTrace();
}
}
}
}
/**
* lectura y escritura de contenido de archivo por carácter
*
* @param filePath
*/
public static void readFileByCharacter(String filePath) {
File file = new File(filePath);
// FileReader: una clase conveniente para leer archivos de caracteres.
FileReader reader = null;
FileWriter writer = null;
try {
reader = new FileReader(file);
writer = new FileWriter("d:/work/readFileByCharacter.txt");
int temp;
while ((temp = reader.read()) != -1) {
writer.write((char)temp);
}
}
catch (IOException e) {
e.getStackTrace();
}
finally {
if (reader != null && writer != null) {
try {
reader.close();
writer.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* lectura y escritura de contenido de archivo por línea
*
* @param filePath
*/
public static void readFileByLine(String filePath) {
File file = new File(filePath);
// BufferedReader: lee texto desde un flujo de entrada de caracteres, almacena cada carácter en un búfer, lo que permite una lectura eficiente de caracteres, arreglos y líneas.
BufferedReader bufReader = null;
BufferedWriter bufWriter = null;
try {
// FileReader: una clase conveniente para leer archivos de caracteres.
bufReader = new BufferedReader(new FileReader(file));
bufWriter = new BufferedWriter(new FileWriter("d:/work/readFileByLine.txt"));
// buf = new BufferedReader(new InputStreamReader(new
// new FileInputStream(file)));
String temp = null;
while ((temp = bufReader.readLine()) != null) {
bufWriter.write(temp+"\n");
}
}
catch (Exception e) {
e.getStackTrace();
}
finally {
if (bufReader != null && bufWriter != null) {
try {
bufReader.close();
bufWriter.close();
}
catch (IOException e) {
e.getStackTrace();
}
}
}
}
/**
* Usar ByteBuffer de Java.nio para copiar un archivo a otro
*
* @param filePath
*/
public static void readFileByBybeBuffer(String filePath) {
FileInputStream in = null;
FileOutputStream out = null;
try {
// Obtener los flujos de entrada y salida de los archivos de origen y destino
in = new FileInputStream(filePath);
out = new FileOutputStream("d:/work/readFileByBybeBuffer.txt");
// Obtener los canales de entrada y salida
FileChannel fcIn = in.getChannel();
FileChannel fcOut = out.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (true) {
// El método clear restablece el búfer, permitiéndole aceptar datos de entrada
buffer.clear();
// Leer los datos desde el canal de entrada al búfer
int r = fcIn.read(buffer);
if (r == -1) {
break;
}
// El método flip permite que el búfer pueda escribir los datos nuevos en otro canal
buffer.flip();
fcOut.write(buffer);
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (in != null && out != null) {
try {
in.close();
out.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static long getTime(){
return System.currentTimeMillis();
}
public static void main(String args[]) {
long time1 = getTime() ;
// readFileByByte(FILE_PATH);// 8734,8281,8000:7781,8047
// readFileByCharacter(FILE_PATH);// 734, 437, 437, 438, 422
// readFileByLine(FILE_PATH);// 110, 94, 94, 110, 93
readFileByBybeBuffer(FILE_PATH);
// 125, 78, 62, 78, 62
long time2 = getTime() ;
System.out.println(time2-time1);
}
}
Después de llamar a cada método en el método main, hay cinco grupos de datos, que son los siguientes5milisegundos de lectura y escritura de archivos en este test.
Para más información sobre Java.nio, consulte: https://es.oldtoolbag.com/article/131338.htm
Prueba personal:
public static void main(String args[]) {
long time1 = getTime() ;
// readFileByByte(FILE_PATH); //2338,2286
// readFileByCharacter(FILE_PATH);//160:162,158
// readFileByLine(FILE_PATH); //46,51,57
// readFileByBybeBuffer(FILE_PATH);//19,18,17
// readFileByBybeBuffer(FILE_PATH);//2048: 11,13
// readFileByBybeBuffer(FILE_PATH);//1024*100 100k:711k: 6,6
// readFileByBybeBuffer(FILE_PATH);//1024*100 100k:1422k: 7
// readFileByBybeBuffer(FILE_PATH);//1024*100 100k:9951k: 49,48
// readFileByBybeBuffer(FILE_PATH);//1024*1000 1M:711k: 7,7
// readFileByBybeBuffer(FILE_PATH);//1024*1000 1M:1422k: 7,8
// readFileByBybeBuffer(FILE_PATH);//1024*1000 1M:9951k: 48,49
// readFileByBybeBuffer(FILE_PATH);//1024*10000 10M:711k: 21,13,17
// readFileByBybeBuffer(FILE_PATH);//1024*10000 10M:1422k: 16,17,14,15
// readFileByBybeBuffer(FILE_PATH);//1024*10000 10M:9951k:64,60
long time2 = getTime() ;
System.out.println(time2-time1);
}
Resumen
Esto es todo sobre la lectura y escritura de archivos Java en este artículo/Todo el contenido detallado y resumido de NIO y comparación de rendimiento, espero que sea útil para todos. Los amigos interesados pueden continuar consultando otros temas relacionados en este sitio, y si hay deficiencias, por favor déjenos un mensaje. Gracias por el apoyo de los amigos a este sitio!
Aviso: El contenido de este artículo se ha obtenido de Internet, es propiedad del autor original, el contenido se ha subido por usuarios de Internet de manera autónoma, el sitio web no posee los derechos de propiedad, no ha sido editado por humanos y no asume ninguna responsabilidad legal. Si encuentra contenido sospechoso de infracción de derechos de autor, por favor envíe un correo electrónico a: notice#w3Para denunciar, por favor reemplaza # con @ en el correo electrónico y proporciona evidencia relevante. Una vez confirmado, el sitio eliminará inmediatamente el contenido sospechoso de infracción.