operaciones en archivos
//通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。
File(String pathname)
public String getAbsolutePath();//返回抽象路径名的绝对路径名字符串。
public boolean mkdirs();//创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。
public boolean mkdir()//创建此抽象路径名指定的目录。
//返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件。
public File[] listFiles()
// 删除此抽象路径名表示的文件或目录。
public boolean delete()
//测试此抽象路径名表示的文件是否是一个目录。
public boolean isDirectory()
//测试此抽象路径名表示的文件或目录是否存在。
public boolean exists()
Crear instancias de archivos con mkdir()
public static void main(String[] args) {
String path = "abcd\\sdf\\nkunoi\\a"; //给出创建文件的路径
//在E盘下面创建文件，将文件路径添加为文件
File file = new File("E:\\" + path);
//file.exists();判断当前目录是否存在
if(file.exists()) {
//file.mkdirs();先判断当前目录下是否存在路径文件，
//存在返回false，不存在，生产路径文件返回true
file.mkdirs()
}
}
La ruta generada bajo el disco E;
cabe señalar que
// file.mkdirs(); 可以创建多级目录(文件夹)，父目录不一定存在。
//即可以生成abcd\\sdf\\nkunoi\\a 的所有目录
// file.mkdir();只能创建一级目录(文件夹)，且父目录必须存在，否则创建失败。
//如果要创建sdf目录，那么abcd目录必须存在。nkunoi目录也一样，sdf目录必须存在
Escanea recursivamente todos los archivos en un directorio
Si queremos escanear todos los archivos en el directorio actual, podemos escanear recursivamente uno por uno,
el código es el siguiente:
package com.dxc.about_dir.test;
import java.io.File;
import java.io.FileFilter;
public class TestForDir {
public static void scanDir(File curDir) {
curDir.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.isDirectory()) {
//检查这个对象是否是文件
//是文件，则输出这个目录
System.out.println("目录：" + pathname);
//递归扫描该目录下的文件
scanDir(pathname);
return false;
}
//不是目录文件，并且判断该文件是否以".java"结尾
if (pathname.getName().endsWith(".java")) {
System.out.println("取得绝对路径：" +
pathname.getAbsolutePath());//取得绝对路径
System.out.println("取得相对路径：" +
pathname.getPath());//取得相对路径
}
return false;
}
});
}
public static void main(String[] args) {
File file = new File(".");
scanDir(file);
}
}
Este es el archivo en mi directorio actual
Este es el resultado de escanear el código
Operaciones Stream (Stream) y IO en archivos
Flujo de Java (Stream), archivo (File) e IO
El paquete Java.io contiene casi todas las clases necesarias para manipular la entrada y la salida. Todas estas clases de flujo representan fuentes de entrada y destinos de salida.
Los flujos en el paquete Java.io admiten una amplia variedad de formatos, como tipos primitivos, objetos, juegos de caracteres localizados y más.
Un flujo puede entenderse como una secuencia de datos. Un flujo de entrada representa la lectura de datos de un origen y un flujo de salida representa la escritura de datos en un destino.
Java proporciona un soporte potente y flexible para E/S, lo que lo hace más utilizado en la transferencia de archivos y la programación de redes.
Pero esta sección cubre la funcionalidad más básica relacionada con flujos y E/S. Aprenderemos estas funciones a través de un ejemplo.
leer archivo
FileInputStream(ruta);
Este flujo se utiliza para leer datos de un archivo y sus objetos se pueden crear con la palabra clave nuevo.
- public void close() lanza IOException{}
Cierra el flujo de entrada de este archivo y libera todos los recursos del sistema asociados con este flujo. Se lanza una IOException. - protected void finalize() lanza IOException {}
Este método borra la conexión con el archivo. Asegúrese de llamar a su método de cierre cuando ya no se haga referencia al flujo de entrada del archivo. Se lanza una IOException. - public int read(int r)throws IOException{}
Este método lee los bytes de datos especificados del objeto InputStream. Devuelto como un valor entero. Devuelve el siguiente byte de datos, o -1 si se ha llegado al final. - public int read(byte[] r) lanza IOException{}
Este método lee r.length bytes del flujo de entrada. Devuelve el número de bytes leídos. Devuelve -1 si es el final del archivo. - public int available() throws IOException{}
Devuelve la cantidad de bytes que se pueden leer de este flujo de entrada sin bloquear por la siguiente llamada de método en este flujo de entrada. Devuelve un valor entero.
Creé un archivo txt en el directorio abcd\sdf\nkunoi\a creado anteriormente.
El código para leer este archivo txt es
package com.dxc.about_io.test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestForFileIO {
public static void main(String[] args) {
FileInputStream fis;
try {
//该流用于从文件中读取数据
fis = new FileInputStream(
"E:\\abcd\\sdf\\nkunoi\\a\\b\\c\\1111.txt");
//从fis流中读取第一个字节
int value = fis.read();
while (value != -1) {
System.out.print((char) value);//输出读取的字节
value = fis.read();//举行读取字节，到结尾返回-1，循环结束
}
fis.close();//关闭文件
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
salida como
escribir archivo
FileOutputStream
Esta clase se utiliza para crear un archivo y escribir datos en el archivo.
Si el archivo de destino no existe antes de que la secuencia abra el archivo para la salida, la secuencia crea el archivo.
- public void close() lanza IOException{}
Cierra el flujo de entrada de este archivo y libera todos los recursos del sistema asociados con este flujo. Se lanza una IOException. - protected void finalize() lanza IOException {}
Este método borra la conexión con el archivo. Asegúrese de llamar a su método de cierre cuando ya no se haga referencia al flujo de entrada del archivo. Se lanza una IOException. - public void write(int w)throws IOException{}
Este método escribe los bytes especificados en el flujo de salida. - public void write(byte[] w)
escribe los bytes de w.length en la matriz especificada en OutputStream.
Ejemplo de código para leer y escribir archivos
Lea el siguiente archivo y escríbalo en otro directorio. Eso es lo que solemos llamar la operación de copia.
168mb sigue siendo bastante grande
Los tres ejemplos de código siguientes se utilizan para mostrar las diversas ventajas y desventajas de la copia de código:
Código 1: copia byte a byte
//下面代码将ABSOLUTE_ROOT 目录下的targetFile 复制写出，再写入到targetFilePath 目录下
public static void main(String[] args) {
String targetFile = "dxc.mp4";//我的目标文件
String targetFilePath = "D:\\a\\";//写入的目录
String ABSOLUTE_ROOT = "E:\\abcd\\sdf\\nkunoi\\a\\b\\c\\";//目标文件的目录
File inFile = new File(ABSOLUTE_ROOT + targetFile);//打开目标文件
File outFile = new File(targetFilePath + targetFile);//打开写入文件
long startTime = System.currentTimeMillis();//开始复制的时间
try {
//该流用于从文件中读取数据
FileInputStream fis = new FileInputStream(inFile);
//该流用于从文件中读取数据
FileOutputStream fos = new FileOutputStream(outFile );
int value = fis.read();//从fis流读入一个字节
while(value != -1) {
fos.write(value);//将读入的value值写入fos流
value = fis.read();//读下一个字节
}
fis.close();//关闭文件
fos.close();//关闭文件
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
long endTime = System.currentTimeMillis();//复制结束
endTime -= startTime;//复制用时
System.out.println(endTime/1000 + "秒" +endTime%1000 + "毫秒");
}
En este momento, se puede ver que el uso de la CPU y
el tiempo de ejecución de todo el programa
tomó un total de más de once minutos para ejecutar todo el programa.
Luego copie el archivo de video en el directorio D:\a
Código 2: lea todos los bytes directamente y luego escriba;
public static void main(String[] args) {
String targetFile = "dxc.mp4";
String targetFilePath = "D:\\a\\";
File inFile = new File("E:\\abcd\\sdf\\nkunoi\\a\\b\\c\\" + targetFile);
File outFile = new File(targetFilePath + targetFile);
long startTime = System.currentTimeMillis();
try {
FileInputStream fis = new FileInputStream(inFile);
FileOutputStream fos = new FileOutputStream(outFile );
long fileSize = inFile.length();//得到文件的大小
byte[] buffer = new byte[(int) fileSize];//申请文件大小的空间，
fis.read(buffer);//将文件写入byte[]里面；
fos.write(buffer); //将文件写出
fis.close();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
endTime -= startTime;
System.out.println(endTime/1000 + "秒" +endTime%1000 + "毫秒");
}
Tiempo de ejecución: 
el tiempo cambió de once minutos a 466 milisegundos. El indicador de velocidad es muy rápido.
/
Debido a que hemos solicitado un espacio lo suficientemente grande, todo el uso de memoria es muy serio. Se puede ver claramente que hay un gran salto. Si el archivo que se va a escribir es lo suficientemente grande, entonces el uso de la memoria explotará directamente, y no somos recomendables para todo este método.
¿Hay una mejor manera, un poco más rápido y un poco más suave en el uso de la memoria.
Podemos leer un poco del archivo perdido a la vez y luego escribirlo; leer un cierto número de bytes y volver a escribirlo; hasta el final de la lectura.
Por ejemplo, si tenemos dieciocho bytes, podemos leer y escribir cuatro bytes a la vez; después de cuatro veces, podemos leer y escribir dos bytes nuevamente, y habrá terminado.
Código tres:
public static void main(String[] args) {
final int BUFFER_SIZE = 1 << 16;//数组大小
String targetFile = "dxc.mp4";
String targetFilePath = "D:\\a\\";
File inFile = new File("E:\\abcd\\sdf\\nkunoi\\a\\b\\c\\" + targetFile);
File outFile = new File(targetFilePath + targetFile);
long startTime = System.currentTimeMillis();
try {
FileInputStream fis = new FileInputStream(inFile);
FileOutputStream fos = new FileOutputStream(outFile);
int fileSize = (int) inFile.length();
byte[] buffer = new byte[BUFFER_SIZE];//申请一定的空间
int readLen;
while (fileSize > 0) {
//先判断文件剩余大小，有没有数组大小大
//大于数组大小，就可以读写数组大小的长度；
//小于数组大小，就可以直接读写文件长度。
readLen = fileSize >= BUFFER_SIZE ? BUFFER_SIZE : fileSize;
//读写readLen大小的文件
readLen = fis.read(buffer, 0, readLen);
//文件总大小，减去已经读过的大小
fileSize -= readLen;
//写出文件
fos.write(buffer, 0, readLen);
}
fis.close();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
endTime -= startTime;
System.out.println(endTime/1000 + "秒" +endTime%1000 + "毫秒");
}
Puede ver que el tiempo dedicado a leer y escribir dxc.mp4
es de solo 102 milisegundos, lo que se puede decir que es muy rápido
y el uso de memoria también es muy pequeño.
Luego, lea y escriba archivos, debemos saber: no lea y escriba byte por byte, es demasiado lento y no puede leer y escribir todo a la vez, lo cual es demasiado violento para el uso de la memoria. Pero podemos configurar el tamaño para que pueda leer y escribir una cierta longitud cada vez, lo que no solo puede aumentar la velocidad, sino también evitar el uso violento de la memoria.