Constructor de clase de archivo
Es una representación abstracta de nombres de ruta de archivo y directorio;
los archivos y directorios se pueden encapsular en objetos a través de archivo;
Método de construcción de clase de archivo:
instancia
File f1 = new File ("/Users/renshengw/Downloads/被讨厌的勇气.pdf");
System.out.println(f1);
File f2 =new File("/Users/renshengw/Downloads","被讨厌的勇气.pdf");
System.out.println(f2);
File f3 = new File("/Users/renshengw/Downloads");
File f4 = new File(f3,"被讨厌的勇气.pdf");
System.out.println(f4);
Función de creación de la clase de archivo
createNewFile()
crea el archivo si el archivo no existe y devuelve verdadero
si el archivo existe no crea el archivo y devuelve falso
mkdir() crea un directorio
mkdirs() crea un directorio de varios niveles;
public static void main(String[] args) throws IOException {
// 创建一个文件
File f1 = new File ("/Users/renshengw/Downloads/被讨厌的勇气.txt");
System.out.println(f1.createNewFile());
//创建一个文件目录
File f2 = new File("/Users/renshengw/Downloads/被讨厌的勇气");
// System.out.println(f2.mkdir());
f2.mkdir();
//创建一个多级目录
File f3 = new File("/Users/renshengw/Downloads/被讨厌的勇气/来吧");
System.out.println(f3.mkdirs());
Función de juicio y adquisición de la clase File
File f = new File("myfile\\java.txt");//创建一个文件对象
//调用file类的相关方法
System.out.println(f.exists());
System.out.println(f.isFile());
System.out.println(f.isDirectory());
System.out.println(f.getAbsoluteFile());
System.out.println(f.getPath());
System.out.println(f.getName());
//创建一个抽象路径名表示的目录路径的对象
File f2 = new File("/Users/renshengw/Documents/Develop/1209biancheng");
String[] strArray = f2.list();//调用 list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组；
//遍历得到目录下的文件名
for (String str :strArray){
System.out.println(str);
}
//调用istFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组
File[] fileArray = f2.listFiles();
for (File file: fileArray){
System.out.println(file);
if(file.isFile()){
//如果是文件则输出
System.out.println(file.getName());
}
}
Eliminar método: eliminar
Ruta absoluta: un nombre de ruta completo que no requiere ninguna otra información para ubicar el archivo que representa
Ruta relativa: se requiere información tomada de otros nombres de ruta para la interpretación
Precauciones para el método de eliminación de eliminación:
si hay contenido (directorio, archivo) en un directorio, no se puede eliminar directamente, el contenido del directorio se debe eliminar primero y el directorio se puede eliminar al final
recursión
Descripción general: desde el punto de vista de la programación, la recursión se refiere al fenómeno de llamar al método en sí mismo en la definición del método.
Ideas recursivas para resolver problemas:
convierta un problema complejo capa por capa en un problema de menor escala similar al problema original a resolver; la
estrategia recursiva puede describir los múltiples cálculos repetidos necesarios para el proceso de resolución de problemas con solo una pequeña cantidad de programas
Para resolver el problema de forma recursiva, debe encontrar dos cosas:
salida recursiva: de lo contrario, se producirá un desbordamiento de memoria;
reglas recursivas: un problema de menor escala similar al problema original;
ejemplo de código factorial:
public static void main(String[] args) {
int result = fc(5);
System.out.println(result);
}
public static int fc(int n){
if(n==1){
return 1;
}else
{
return fc(n-1)*n;
}
}
Ejemplo de código para atravesar directorios:
public static void main(String[] args) {
File srcfile = new File("/Users/renshengw/Downloads");
getallfile(srcfile);
}
public static void getallfile(File srcfile){
File[] files = srcfile.listFiles();
if(files != null){
for(File file :files){
if(file.isDirectory()){
//如果得到的是目录
getallfile(file);//调用获得目录下所有内容
}else{
System.out.println(file.getAbsolutePath());
}
}
}
}
flujo de bytes (entrada/salida)
Stream: Es un concepto abstracto y un término general para la transmisión de datos. La transferencia de datos entre dispositivos se denomina flujo.
Flujo de entrada: leer datos
Flujo de salida: escribir datos
Flujo de bytes escribir datos
Cadena de entrada, Cadena de salida
La clase abstracta InputString es la superclase de todas las clases que representan flujos de bytes de entrada. La clase abstracta
OutputString es la superclase de todas las clases que representan flujos de bytes de entrada.
Los nombres de las subclases tienen como sufijo los nombres de sus clases principales.
FileOutputString: flujo de salida de archivo para escribir datos en el archivo
// 创建对象，让字节输出流对象指向文件
FileOutputStream fos = new FileOutputStream("1209/file.txt");//这里相当会同时执行new File的动作；
// 写数据
fos.write(90);
// 释放资源，必备，关闭此输出流
fos.close();
Tres métodos para escribir datos, write(byte[]b, int off, int len), off es
un método de Tips: String, obtenga una matriz de bytes de acuerdo con la cadena: byte[] getBytes()
FileInputString lee datos de un archivo
int read()
lee un byte de datos de este flujo de entrada.
int read(byte[] b)
lee hasta b.length bytes de datos del flujo de entrada en una matriz de bytes.
int read (byte[] b, int off, int len)
lee hasta len bytes de datos de este flujo de entrada en una matriz de bytes.
FileInputStream fis = new FileInputStream("1209/file2.txt");
int by =fis.read();
System.out.println(by);
//从该输入流读取最多 b.length个字节的数据到一个字节数组
byte[] byt = new byte[100];
int some = fis.read(byt);
System.out.println(some);
//从该输入流读取最多 len个字节的数据到字节数组。
System.out.println(new String(byt,0,10));
Leer datos, el valor devuelto al llegar a los últimos datos es: -1;
Lea todos los datos recorriendo:
//定义一个输入流
FileInputStream fis = new FileInputStream("1209/file.txt");
//第一种遍历方式，运用了没有数据返回值是-1这个特点
int by =fis.read();
while (by != -1) {
System.out.print((char) by);//强制将int转换成char，便于阅读
by = fis.read();
}
//改进后的第二种遍历方式，定义条件只要写一次
int bys ;
while((bys=fis.read())!= -1){
System.out.print((char)bys);
}
//释放资源
fis.close();
Flujo de bytes escribir salto de línea de datos y agregar escritura
El flujo de bytes escribe datos para realizar el símbolo de nueva línea:
windows \r\n
linux \n
Mac \n
Agregar escritura:
FileOutputStream(String name, boolean append)
escribir verdadero en el segundo parámetro, puede agregar
finalmente: proporciona un bloque finalmente para realizar todas las operaciones claras durante el manejo de excepciones, como la liberación de recursos en el flujo de E/S
Características: la declaración controlada por finalmente se ejecutará a menos que la JVM salga;
copiar archivo de texto
También se puede utilizar para leer texto e imágenes.
FileInputStream fis = new FileInputStream("1209/file.txt");
FileOutputStream fos = new FileOutputStream("1209/output.txt");
byte[] byt = new byte[1024];
int len;
while((len= fis.read())!= -1){
fos.write(byt,0,len);
}
fos.close();
fis.close();
Flujo de búfer de bytes: propósito de mejorar la eficiencia del procesamiento de bytes
BufferedOutputString
puede escribir bytes en el flujo de salida de datos subyacente sin invocar el sistema subyacente para cada byte escrito, lo que reduce los recursos de llamadas subyacentes.
BufferedInputString
al crear un BufferedInputStream creará una matriz de búfer interna. A medida que se leen u omiten bytes del flujo, el búfer interno se rellena según sea necesario desde el flujo de entrada contenido, muchos bytes a la vez. La operación de marcado recuerda un punto en el flujo de entrada, y la operación de restablecimiento hace que todos los bytes leídos de la operación de marcado más reciente se vuelvan a leer antes de que se obtengan nuevos bytes del flujo de entrada que lo contiene.
El flujo de búfer de bytes solo proporciona un búfer, y los datos reales de lectura y escritura deben basarse en el objeto de flujo de bytes básico para operar,
por lo que el método de construcción debe pasar el objeto del flujo de bytes y su método es consistente con el flujo de bytes.
Ejemplo de código de flujo de salida almacenado en búfer:
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("1209/file.txt"));
bos.write("11".getBytes());
bos.close();
Instancia de copia de archivo de entrada y salida almacenada en búfer:
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("1209/file.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("1209/output.txt"));
byte[] byt = new byte[1024];
int len;
while ((len = bis.read(byt)) != -1) {
bos.write(byt, 0, len);
}
bos.close();
bis.close();