Clase de archivo
1. Método de construcción
Archivo público (nombre de ruta de cadena): crea una nueva instancia de archivo mediante la cadena de ruta dada en un nombre de
ruta abstracto ruta puede ser el final del archivo o carpeta es el final de
la ruta puede ser una ruta relativa o una ruta absoluta
puede ser existente o
un objeto Create a File no existente , simplemente encapsule la ruta de la cadena como un objeto File, independientemente de la existencia
public class Demo01 {
public static void main(String[] args) {
show();
}
private static void show() {
File fl=new File("D:\\JAVA\\File\\text.txt");
System.out.println(fl); //D:\JAVA\File\text.txt
}
}
Archivo público (cadena principal, cadena secundaria): cree una nueva instancia de archivo a partir de la cadena del nombre de la ruta principal y la cadena del nombre de la ruta secundaria
principal: ruta principal
hijo: ruta secundaria
Beneficios: la ruta principal y la ruta secundaria se pueden escribir por separado, de uso flexible
public class Demo01 {
public static void main(String[] args) {
show();
}
private static void show() {
File fl=new File("D:\\JAVA\\File","text.txt");
System.out.println(fl); //D:\JAVA\File\text.txt
}
}
Archivo público (archivo principal, cadena secundaria): crea una nueva instancia de archivo a partir del nombre de la ruta abstracta principal y la cadena del nombre de la ruta secundaria.
Beneficios: la ruta principal puede utilizar el método File para realizar algunas operaciones en la ruta
public class Demo01 {
public static void main(String[] args) {
show();
}
private static void show() {
File parent=new File("D:\\JAVA\\File");
File fl=new File(parent,"text.txt");
System.out.println(fl); //D:\JAVA\File\text.txt
}
}
2. Métodos comunes
public String getAbsolutePath (): devuelve la cadena de ruta absoluta de este archivo
public String getPath (): convierte este archivo en una cadena de nombre de ruta
public String getName (): devuelve el nombre del archivo o directorio representado por este archivo
public long length ( ): Devuelve la longitud del archivo representado por este archivo.
public class Demo01 {
public static void main(String[] args) {
File f=new File("F:\\JAVA\\File");
System.out.println(f.getAbsolutePath());
System.out.println(f.getPath());
System.out.println(f.getName());
System.out.println(f.length());
/*
F:\JAVA\File
F:\JAVA\File
File
0
*/
}
}
Método de evaluación
public boolean existe (): si el archivo o directorio representado por este archivo existe realmente
public boolean isDirectory (): si este archivo representa un directorio
public boolean isFile (): si este archivo representa un archivo
public class Demo01 {
public static void main(String[] args) {
File f=new File("F:\\JAVA\\File");
System.out.println(f.exists());
System.out.println(f.isDirectory());
System.out.println(f.isFile());
/*
true
true
false
*/
}
}
Eliminar método
public boolean createNewFile (): si y solo si el archivo con el nombre aún no existe, cree una nueva carpeta vacía
1. Este método solo puede crear archivos, no carpetas
2. La ruta para crear archivos debe existir, de lo contrario, una ocurrirá una excepción
public class Demo01 {
public static void main(String[] args) throws IOException {
File f=new File("F:\\JAVA\\File\\text.txt");
boolean b=f.createNewFile(); //只能创建文件，不能创建文件夹
System.out.println(b);
}
}
public boolean delete (): elimina el archivo o directorio representado por este archivo.
Si hay un archivo en la carpeta, devuelve falso; si no hay ningún archivo, devuelve verdadero
public class Demo01 {
public static void main(String[] args) throws IOException {
File f1=new File("F:\\JAVA\\File\\text\\text1\\text2");
boolean b1=f1.delete();
System.out.println(b1);
}
}
public boolean mkdir (): crea un directorio representado por este archivo, crea una carpeta vacía de un solo nivel
public boolean mkdirs (): crea un directorio representado por este archivo, incluidos los directorios principales necesarios pero no existentes, crea un carpeta vacía, también puede crear carpetas de varios niveles
public class Demo01 {
public static void main(String[] args) throws IOException {
File f1=new File("F:\\JAVA\\File\\text");
boolean b=f1.mkdir();
System.out.println(b);
File f2=new File("F:\\JAVA\\File\\text\\text1\\text2");
boolean b2=f2.mkdirs();
System.out.println(b2);
}
} //只创建文件夹
Recorrido de directorio
public String [] list (): devuelve una matriz de cadenas, que representa todos los subarchivos o directorios en el directorio de
archivos public File [] listFiles (): devuelve una matriz de archivos, que representa todos los archivos o directorios en el directorio de archivos
public class Demo01 {
public static void main(String[] args) throws IOException {
File f1=new File("F:\\JAVA");
//获取当前目录下的文件以及文件夹的名称
String[] names=f1.list();
for (String name : names) {
System.out.println(name);
}
//获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
File[] files=f1.listFiles();
for (File file : files) {
System.out.println(file);
}
}
}
Estilo IO
Descripción general de 1.IO
Flujo de entrada: flujo que lee datos de otros dispositivos a la memoria
Flujo de salida: flujo que escribe datos de la memoria a otros dispositivos.
2. Secuencia de bytes
Flujo de salida de bytes
public void close (): cierre este flujo de salida y libere cualquier recurso del sistema asociado con él
public void flush (): elimine este flujo de salida y fuerce
la escritura de los bytes de salida almacenados en búfer public void write (byte [] b): Escribe b.length bytes de la matriz de bytes especificada en esta secuencia de salida
public void write (byte [] b, int off, int len): escribe len bytes de la matriz de bytes especificada, inicia la salida desde el desplazamiento desactivado a esta secuencia de salida
public abstract escritura vacía (int b): envía el byte especificado a la secuencia
Método de construcción:
FileOutputStream (nombre de cadena): crea una salida que escribe datos en un archivo con el nombre especificado File Stream
FileOutputStream (archivo de archivo): Crea una secuencia de salida de archivo que escribe datos en el archivo representado por el objeto File especificado. La
función del método de construcción:
1. Crear un objeto FileOutputStream
2. Crearlo de acuerdo con la ruta de archivo / archivo pasada en el método de construcción Un archivo vacío
3. El objeto FileOutputStream ser asignado al archivo creado
public class Demo01 {
public static void main(String[] args) throws IOException {
//创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
FileOutputStream fos=new FileOutputStream("F:\\JAVA\\File\\text1.txt");
//调用FileOutputStream对象中的write方法，把数据写入到文件中
fos.write(97);
//释放资源
fos.close();
}
}
public class Demo01 {
public static void main(String[] args) throws IOException {
//创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
FileOutputStream fos=new FileOutputStream(new File("F:\\JAVA\\File\\text2.txt"));
//调用FileOutputStream对象中的write方法，把数据写入到文件中
/*public void write(byte[] b)一次写多个字节
如果写的第一个字节是正数，那么现实的时候会查询ASCII表
如果写的第一个字节是负数，那第一个字节会和第二个字节组成一个中文显示
*/
byte[] bytes={
65,66,67,68,69};
//fos.write(bytes) ABCDE
fos.write(bytes,1,2); //BC
//释放资源
fos.close();
}
}
Continuación y salto de línea:
el método de construcción que utiliza dos parámetros:
FileOutputStream (nombre de cadena, agregado booleano): crea una secuencia de archivo de salida que escribe datos en el archivo con el nombre especificado
FileOutputStream (archivo de archivo, booleano): crea un archivo especificado Salida de archivo flujo de datos escritos en el archivo representado por el objeto de archivo
Parámetros:
nombre, archivo: ruta para escribir datos
booleano agregar: verdadero crear un objeto no sobrescribirá el archivo original, continuar escribiendo datos al final del archivo; falso crear un nuevo archivo sobrescribir archivo original
public class Demo02 {
public static void main(String[] args) throws IOException {
FileOutputStream fos=new FileOutputStream("F:\\JAVA\\File\\text1.txt",true);
fos.write("Kobe".getBytes());
fos.close();
}
}
Símbolo de nueva línea:
public class Demo02 {
public static void main(String[] args) throws IOException {
FileOutputStream fos=new FileOutputStream("F:\\JAVA\\File\\text1.txt",true);
for (int i=0;i<10;i++){
fos.write("Kobe".getBytes());
fos.write("\r\n".getBytes());
}
fos.close();
}
}
El flujo de entrada de bytes
lee datos del disco duro en la memoria
int read (): lee el siguiente byte de datos del flujo de entrada
int read (byte [] b): lee un cierto número de palabras de la sección del flujo de entrada y lo almacena en la matriz de búfer b.
Método de construcción:
FileInputStream (String nmae)
FileInputStream (archivo de archivo)
Función:
1. Crear un objeto FileInputStream
2. Leerá el archivo en el método de construcción especificado por el objeto FileInputStream
public class Demo03 {
public static void main(String[] args) throws IOException {
//创建FileInputStream对象，构造方法中绑定要读取的数据
FileInputStream fis=new FileInputStream("F:\\JAVA\\File\\text1.txt");
//使用FileInputStream对象中的方法read，读取文件
/* int len=fis.read();
System.out.println(len);*/
int len=0;
while((len=fis.read())!=-1){
System.out.println((char)len);
}
//释放资源
fis.close();
}
}
public class Demo03 {
public static void main(String[] args) throws IOException {
//创建FileInputStream对象，构造方法中绑定要读取的数据
FileInputStream fis=new FileInputStream("F:\\JAVA\\File\\text2.txt");
//使用FileInputStream对象中的方法read，读取文件
byte[] bytes=new byte[1024];
int len=0;
while((len=fis.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
//用len记录长度使读取有效字节数
}
//释放资源
fis.close();
}
}
3. Flujo de caracteres
Secuencia de entrada de caracteres
public void close (): cierre esta secuencia y libere los recursos del sistema asociados con esta secuencia
pública int read (): lea un carácter de la secuencia de entrada
public int read (char [) cbuf): lea desde la secuencia de entrada Tome algunos caracteres y guárdelos en la matriz de caracteres cbuf
Método de construcción:
FileReader (archivo de archivo): cree un nuevo FileReader, dado el objeto File que se leerá
FileReader (String fileName): cree un nuevo FileReader, dado el nombre de archivo, el
flujo de salida de caracteres para leer
void write (int c): escribe un solo carácter
void write (char [] cbuf): escribe matriz de caracteres
abstract void write (char [] cbuf, int off, int len): escribe Ingresa una cierta parte de la matriz de caracteres, el índice de inicio de la matriz off, el número de caracteres escritos por len
void write (String str): escribe una cadena
void write (String, str, int off.int len): escribe una cierta parte de la cadena Una parte, el inicio índice de la cadena de apagado, el número de caracteres escritos por len
void flush (): vaciar el búfer del flujo
void close (): cerrar el flujo, pero primero vaciar
public class Demo05 {
public static void main(String[] args) throws IOException {
//使用FileWriter对象，构造方法中绑定要写入数据的目的地
FileWriter fw=new FileWriter("F:\\\\JAVA\\\\File\\\\text2.txt");
//使用FileWriter中的方法write，把数据写入到内存缓冲区(字符转换为字节的过程)
fw.write(97);
//使用FileWriter中的方法flush()，把内存缓冲区中的数据，刷新到文件中
fw.flush();
//释放资源
fw.close();
}
}
flush (): vaciar el búfer, el objeto de flujo puede continuar usando
close (): vaciar el búfer primero y luego notificar al sistema que libere el recurso, el objeto de flujo ya no se puede usar
public class Demo05 {
public static void main(String[] args) throws IOException {
//使用FileWriter对象，构造方法中绑定要写入数据的目的地
FileWriter fw=new FileWriter("F:\\\\JAVA\\\\File\\\\text2.txt");
char[] cs={
'h','i','w','o','r','l','d'};
fw.write(cs);
fw.write(cs,2,2);
fw.write("hello,world");
fw.close();
}
}
Continuación y avance de línea: igual que arriba
4. Manejo de excepciones de IO
JDK7: agregue un () después del intento, el objeto de flujo se puede definir entre paréntesis, luego el alcance del objeto de flujo es válido en el intento, el código en el intento se ejecuta, el objeto de flujo se liberará automáticamente
JDK9: antes del intente Defina el objeto de flujo, puede introducir el nombre del objeto de flujo en () después de intentarlo. El objeto de flujo también se puede liberar una semana después de que se ejecute el código de prueba, sin escribir finalmente