Después de trabajar, la tecnología utilizada cambia con los cambios del proyecto, a veces C#, a veces Java y, por supuesto, algunas otras tecnologías fragmentadas. En general, C# lleva más tiempo, seguido de Java. No tengo ninguna preferencia por los idiomas. Un idioma que pueda funcionar es un buen idioma. Y desde una perspectiva orientada a objetos, creo que para mí no hay diferencia entre C# y Java.
Este artículo revisa principalmente el contenido relacionado con las operaciones de E/S en Java. La E/S también es una característica básica de los lenguajes de programación en Java. La E/S se divide en dos tipos, uno es lectura secuencial y el otro es lectura aleatoria.
Veamos primero la lectura secuencial. Hay dos formas de realizar la lectura secuencial. Una es InputStream/OutputStream, que es un flujo de entrada y salida que opera en bytes. La otra es Reader/Writer, que opera en caracteres de entrada y salida. corrientes de la operación.
A continuación dibujamos la estructura de InputStream.
FileInputStream: opera archivos, a menudo usado junto con BufferedInputStream
PipedInputStream: se puede utilizar para comunicación entre subprocesos
ObjectInputStream: se puede utilizar para la serialización de objetos
ByteArrayInputStream: utilizado para procesar la entrada de matrices de bytes
LineNumberInputStream: puede generar el número de línea actual y puede modificarse en el programa
La siguiente es la estructura de OutputStream.
PrintStream: proporciona interfaces similares a print e println para generar datos
Veamos cómo usar Stream para operar la entrada y la salida.
Leer archivos usando InputStream
Copie el código de código de la siguiente manera:
Utilice FileInputStream para leer la información del archivo
byte estático público [] readFileByFileInputStream (archivo de archivo) lanza IOException
{
Salida ByteArrayOutputStream = nuevo ByteArrayOutputStream();
FileInputStream fis = nulo;
intentar
{
fis = nuevo FileInputStream(archivo);
byte[] buffer = nuevo byte[1024];
int bytesLeer = 0;
while((bytesRead = fis.read(buffer, 0, buffer.length)) != -1)
{
salida.write(búfer, 0, bytesRead);
}
}
captura (Excepción ex)
{
System.out.println("Se produce un error durante la lectura " + file.getAbsoluteFile());
}
finalmente
{
si (fis !=null) fis.close();
si (salida! = nulo) salida.close();
}
devolver salida.toByteArray();
}
Leer archivos usando BufferedInputStream
Copie el código de código de la siguiente manera:
byte estático público [] readFileByBufferedInputStream (archivo de archivo) arroja una excepción
{
FileInputStream fis = nulo;
BufferedInputStream bis = nulo;
Salida ByteArrayOutputStream = nuevo ByteArrayOutputStream();
intentar
{
fis = nuevo FileInputStream(archivo);
bis = nuevo BufferedInputStream(fis);
byte[] buffer = nuevo byte[1024];
int bytesLeer = 0;
while((bytesRead = bis.read(buffer, 0, buffer.length)) != -1)
{
salida.write(búfer, 0, bytesRead);
}
}
captura (Excepción ex)
{
System.out.println("Se produce un error durante la lectura " + file.getAbsoluteFile());
}
finalmente
{
if (fis != nulo) fis.close();
si (bis != nulo) bis.close();
si (salida! = nulo) salida.close();
}
devolver salida.toByteArray();
}
Copiar archivos usando OutputStream
Copie el código de código de la siguiente manera:
Copiar archivos usando FileOutputStream
copyFileByFileOutputStream (archivo de archivo) público estático vacío lanza IOException
{
FileInputStream fis = nulo;
FileOutputStream fos = nulo;
intentar
{
fis = nuevo FileInputStream(archivo);
fos = nuevo FileOutputStream(file.getName() + ".bak");
byte[] buffer = nuevo byte[1024];
int bytesLeer = 0;
while((bytesRead = fis.read(buffer,0,buffer.length)) != -1)
{
fos.write(búfer, 0, bytesRead);
}
fos.flush();
}
captura (Excepción ex)
{
System.out.println("Se produce un error durante la copia " + file.getAbsoluteFile());
}
finalmente
{
if (fis != nulo) fis.close();
si (fos != nulo) fos.close();
}
}
Copie el código de código de la siguiente manera:
Copie archivos usando BufferedOutputStream
copia vacía estática públicaFilebyBufferedOutputStream (archivo de archivo) lanza IOException
{
FileInputStream fis = nulo;
BufferedInputStream bis = nulo;
FileOutputStream fos = nulo;
BufferedOutputStream bos = nulo;
intentar
{
fis = nuevo FileInputStream(archivo);
bis = nuevo BufferedInputStream(fis);
fos = nuevo FileOutputStream(file.getName() + ".bak");
bos = nuevo BufferedOutputStream(fos);
byte[] buffer = nuevo byte[1024];
int bytesLeer = 0;
while((bytesRead = bis.read(buffer, 0, buffer.length)) != -1)
{
bos.write(búfer, 0, bytesRead);
}
bos.flush();
}
captura (Excepción ex)
{
System.out.println("Se produce un error durante la copia " + file.getAbsoluteFile());
}
finalmente
{
if (fis != nulo) fis.close();
si (bis != nulo) bis.close();
si (fos != nulo) fos.close();
si (bos != nulo) bos.close();
}
}
El código aquí maneja las excepciones de manera muy incompleta. Más adelante brindaremos un código completo y riguroso.
Echemos un vistazo a la estructura de Reader.
El Lector aquí corresponde básicamente al InputStream.
La estructura de Writer es la siguiente.
Veamos algunos ejemplos del uso de Reader o Writer.
Utilice Reader para leer el contenido del archivo
Copie el código de código de la siguiente manera:
Utilice BufferedReader para leer el contenido del archivo
ReadFile de cadena estática pública (archivo de cadena) lanza IOException
{
BufferedReader br = nulo;
StringBuffer sb = nuevo StringBuffer();
intentar
{
br = nuevo BufferedReader(nuevo FileReader(archivo));
Línea de cadena = nula;
mientras ((línea = br.readLine())! = nulo)
{
sb.append(línea);
}
}
captura (Excepción ex)
{
System.out.println("Se produce un error durante la lectura del archivo " +);
}
finalmente
{
si (br! = nulo) br.close();
}
devolver sb.toString();
}
Copiar archivos usando Writer
Copie el código de código de la siguiente manera:
Copiar archivos usando BufferedWriter
copyFile público estático vacío (archivo de cadena) lanza IOException
{
BufferedReader br = nulo;
BufferedWriter bw = nulo;
intentar
{
br = nuevo BufferedReader(nuevo FileReader(archivo));
bw = nuevo BufferedWriter(nuevo FileWriter(archivo + ".bak"));
Línea de cadena = nula;
mientras((línea = br.readLine())!= nulo)
{
bw.write(línea);
}
}
captura (Excepción ex)
{
System.out.println("Se produce un error al copiar " + archivo);
}
finalmente
{
si (br! = nulo) br.close();
si (bw! = nulo) bw.close();
}
}
Veamos cómo realizar acceso aleatorio a archivos. RandomAccessFile se utiliza principalmente en Java para realizar operaciones aleatorias en archivos.
Crear un archivo de tamaño fijo
Copie el código de código de la siguiente manera:
Crear archivos de tamaño fijo
public static void createFile (archivo de cadena, tamaño int) lanza IOException
{
Temperatura del archivo = nuevo archivo (archivo);
RandomAccessFile raf = nuevo RandomAccessFile(temp, "rw");
raf.setLength(tamaño);
raf.cerrar();
}
Escribir datos aleatorios en un archivo.
Copie el código de código de la siguiente manera:
Insertar datos aleatorios en un archivo
writeFile público estático vacío (archivo de cadena, contenido de byte [], int startPos, int contentLength) arroja IOException
{
RandomAccessFile raf = new RandomAccessFile(nuevo archivo(archivo), "rw");
raf.seek(startPos);
raf.write(contenido, 0, contenidoLongitud);
raf.cerrar();
}
A continuación, veamos algunas otras operaciones comunes.
Mover archivos
Copie el código de código de la siguiente manera:
Mover archivos
moveFile público estático booleano (String sourceFile, String destFile)
{
Fuente del archivo = nuevo archivo (archivo fuente);
if (!source.exists()) lanza una nueva RuntimeException ("el archivo fuente no existe.");
Destino del archivo = nuevo archivo (archivodest);
if (!(new File(dest.getPath()).exists())) new File(dest.getParent()).mkdirs();
devolver fuente.renameTo(dest);
}
Copiar archivos
Copie el código de código de la siguiente manera:
Copiar archivos
copyFile público estático vacío (String sourceFile, String destFile) lanza IOException
{
Fuente del archivo = nuevo archivo (archivo fuente);
if (!source.exists()) lanza una nueva RuntimeException ("El archivo no existe.");
if (!source.isFile()) lanza una nueva RuntimeException ("No es un archivo.");
if (!source.canRead()) throw new RuntimeException("El archivo no se puede leer.");
Destino del archivo = nuevo archivo (archivodest);
si (destino.existe())
{
if (dest.isDirectory()) lanza una nueva RuntimeException ("El destino es una carpeta.");
demás
{
destino.delete();
}
}
demás
{
Archivo parentFolder = nuevo archivo (dest.getParent());
if (!parentFolder.exists()) parentFolder.mkdirs();
if (!parentFolder.canWrite()) lanza una nueva RuntimeException ("No se puede escribir el destino.");
}
FileInputStream fis = nulo;
FileOutputStream fos = nulo;
intentar
{
fis = nuevo FileInputStream(fuente);
fos = nuevo FileOutputStream(dest);
byte[] buffer = nuevo byte[1024];
int bytesLeer = 0;
while((bytesRead = fis.read(buffer, 0, buffer.length)) != -1)
{
fos.write(búfer, 0, bytesRead);
}
fos.flush();
}
captura (IOException ex)
{
System.out.println("Se produce un error durante la copia " + archivo fuente);
}
finalmente
{
if (fis != nulo) fis.close();
si (fos != nulo) fos.close();
}
}
copiar carpeta
Copie el código de código de la siguiente manera:
copiar carpeta
copyDir vacío estático público (String sourceDir, String destDir) lanza IOException
{
Fuente del archivo = nuevo archivo (sourceDir);
if (!source.exists()) lanza una nueva RuntimeException ("La fuente no existe.");
if (!source.canRead()) lanza una nueva RuntimeException ("No se pudo leer la fuente.");
Destino del archivo = nuevo archivo (destDir);
if (!dest.exists()) dest.mkdirs();
Archivo[] arrFiles = source.listFiles();
para(int i = 0; i < arrFiles.length; i++)
{
si (arrFiles[i].isFile())
{
Lector BufferedReader = new BufferedReader(new FileReader(arrFiles[i]));
Escritor BufferedWriter = new BufferedWriter(new FileWriter(destDir + "/" + arrFiles[i].getName()));
Línea de cadena = nula;
while((línea = lector.readLine()) != nulo) escritor.write(línea);
escritor.flush();
lector.close();
escritor.close();
}
demás
{
copyDir(sourceDir + "/" + arrFiles[i].getName(), destDir + "/" + arrFiles[i].getName());
}
}
}
eliminar carpeta
Copie el código de código de la siguiente manera:
eliminar carpeta
del vacío estático público (ruta del archivo de cadena)
{
Archivo archivo = nuevo Archivo (filePath);
si (archivo == nulo || !archivo.exists()) retorno;
si (archivo.isFile())
{
archivo.eliminar();
}
demás
{
Archivo[] arrFiles = file.listFiles();
si (arrFiles.length > 0)
{
para(int i = 0; i < arrFiles.length; i++)
{
del(arrFiles[i].getAbsolutePath());
}
}
archivo.eliminar();
}
}
Obtener tamaño de carpeta
Copie el código de código de la siguiente manera:
Obtener tamaño de carpeta
público estático largo getFolderSize (directorio de cadena)
{
tamaño largo = 0;
Archivo archivo = nuevo archivo (dir);
if (!file.exists()) lanza una nueva RuntimeException ("el directorio no existe.");
si (file.isFile()) devuelve archivo.length();
demás
{
String[] arrFileName = file.list();
para (int i = 0; i < arrFileName.length; i++)
{
tamaño += getFolderSize(dir + "/" + arrFileName[i]);
}
}
tamaño de devolución;
}
Divida archivos grandes en varios archivos pequeños
Copie el código de código de la siguiente manera:
Divida archivos grandes en varios archivos más pequeños
public static void splitFile (String filePath, unidad larga) lanza IOException
{
Archivo archivo = nuevo Archivo (filePath);
if (!file.exists()) lanza una nueva RuntimeException ("el archivo no existe.");
tamaño largo = archivo.longitud();
if (unidad >= tamaño) return;
int recuento = tamaño % unidad == 0 ? (int)(tamaño/unidad): (int)(tamaño/unidad) + 1;
Cadena nuevoArchivo = nulo;
FileOutputStream fos = nulo;
FileInputStream fis = nulo;
byte[] buffer = nuevo byte[(int)unidad];
fis = nuevo FileInputStream(archivo);
posición de inicio larga = 0;
String countFile = filePath + "_Count";
Escritor PrintWriter = nuevo PrintWriter (nuevo FileWriter (nuevo archivo (countFile)));
escritor.println(filePath + "/t" + tamaño);
para (int i = 1; i <= contar; i++)
{
nuevoArchivo = rutadelarchivo + "_" + i;
startPos = (i - 1) * unidad;
System.out.println("Creando " + nuevoArchivo);
fos = nuevo FileOutputStream (nuevo archivo (nuevo archivo));
int bytesRead = fis.read(búfer, 0, búfer.longitud);
si (bytes leídos! = -1)
{
fos.write(búfer, 0, bytesRead);
escritor.println(nuevoArchivo + "/t" + startPos + "/t" + bytesRead);
}
fos.flush();
fos.cerrar();
System.out.println("StartPos:" + i*unidad + "; EndPos:" + (i*unidad + bytesRead));
}
escritor.flush();
escritor.close();
fis.cerrar();
}
Fusionar varios archivos pequeños en un archivo grande
Copie el código de código de la siguiente manera:
Fusionar varios archivos pequeños en un archivo grande
linkFiles vacíos estáticos públicos (String countFile) lanza IOException
{
Archivo archivo = nuevo archivo (countFile);
if (!file.exists()) lanza una nueva RuntimeException ("El archivo contado no existe.");
Lector BufferedReader = nuevo BufferedReader (nuevo FileReader (archivo));
Línea de cadena = lector.readLine();
Cadena nuevoArchivo = line.split("/t")[0];
tamaño largo = Long.parseLong(line.split("/t")[1]);
RandomAccessFile raf = nuevo RandomAccessFile(newFile, "rw");
raf.setLength(tamaño);
FileInputStream fis = nulo;
byte[] buffer = nulo;
mientras((línea = lector.readLine()) != nulo)
{
Cadena[] arrInfo = line.split("/t");
fis = nuevo FileInputStream(nuevo archivo(arrInfo[0]));
buffer = nuevo byte[Integer.parseInt(arrInfo[2])];
long startPos = Long.parseLong(arrInfo[1]);
fis.read(buffer, 0, Integer.parseInt(arrInfo[2]));
raf.seek(startPos);
raf.write(buffer, 0, Integer.parseInt(arrInfo[2]));
fis.cerrar();
}
raf.cerrar();
}
Ejecutar comando externo
Copie el código de código de la siguiente manera:
Ejecutar comando externo
public static void execExternalCommand (comando de cadena, argumento de cadena)
{
Proceso proceso = nulo;
intentar
{
proceso = Runtime.getRuntime().exec(comando + " " + argumento);
InputStream es = proceso.getInputStream();
BufferedReader br = nuevo BufferedReader (nuevo InputStreamReader (es));
Línea de cadena = nula;
mientras ((línea = br.readLine())! = nulo)
{
System.out.println(línea);
}
}
captura (Excepción ex)
{
System.err.println(ex.getMessage());
}
finalmente
{
si (proceso! = nulo) proceso.destroy();
}
}
