Operaciones de archivos y IO

mucho tiempo sin verte ~

contenido

1. Documentos

1.1 Archivo ordinario

1.1.1 Disco duro

1.2 Archivo de directorio

1.2.1 Estructura

1.2.2 Ruta

1.3 Clasificación de documentos

2. Archivos de operaciones en java

2.1 Operaciones relacionadas del sistema de archivos

2.2.1 Introducción de la clase Archivo

2.2.2 Listar archivos

2.2.3 Crear archivo

2.2.4 Crear un directorio

2.2.5 Eliminar archivos

2.2 Operaciones relacionadas con el contenido del archivo

2.2.1 Abrir archivo

2.2.2 Lectura de archivos

2.2.3 Escribir archivo

2.2.4 Cerrar el archivo

3. Tres casos de manipulación de archivos

3.1 Buscar archivos y eliminar

3.2 Copia de archivos ordinarios

3.3 Búsqueda del contenido del archivo

---

1. Documentos

Los archivos que solemos decir son archivos ordinarios almacenados en el disco duro. (Esta sección trata principalmente de archivos comunes)

1.1 Archivo ordinario

Los archivos en forma de txt, jpg, mp3, etc. almacenados en el disco duro se denominan archivos ordinarios.

1.1.1 Disco duro

① Disco duro mecánico:

a. La estructura básica del disco duro mecánico: (a continuación se muestra una breve introducción al disco duro mecánico)

Disco (plato): El medio que almacena datos

Cabezas y motores: la sección de ejecución

Placa de circuito: Sección de control

B. Principio de funcionamiento:

Cuando se enciende el disco duro mecánico, los platos del interior funcionarán a alta velocidad y el cabezal magnético encontrará los datos correspondientes en la superficie del disco. Sin embargo, debido a la estructura de hardware limitada del disco duro mecánico, cuanto mayor sea la velocidad del disco, mayor será la velocidad de lectura y escritura, y es fácil saber que la velocidad del disco no puede ser infinitamente alta, por lo que tiene ha estado estancada durante 10 años. Así que presentamos el disco duro de estado sólido del que hablaremos a continuación.

②Unidad de estado sólido (SSD):

Esta es una unidad de estado sólido.

La estructura de hardware de las unidades de estado sólido es completamente diferente a la de las unidades de disco duro mecánicas.La velocidad de lectura y escritura de las unidades de estado sólido es mucho más rápida que la de las unidades de disco duro mecánicas.

 Y ahora estamos hablando principalmente de discos duros mecánicos.

1.2 Archivo de directorio

1.2.1 Estructura

En una computadora, mantener y almacenar archivos se logra a través del "sistema de archivos" en el sistema operativo.

En el sistema de archivos, los directorios y archivos en el disco generalmente se organizan a través de una estructura de árbol, que es un número bifurcado en N.

Dejame darte un ejemplo:

Esto es lo que llamamos una estructura de árbol.

1.2.2 Ruta

①Ruta absoluta:

Una ruta absoluta se refiere a una ruta específica que comienza con una letra de unidad. Por ejemplo: C:\Archivos de programa\Java

②Ruta relativa:

Comenzando con . o .., donde . representa la ruta actual

..representa el directorio principal de la ruta actual (ruta superior)

Una ruta relativa debe tener un directorio de referencia. La ruta relativa comienza desde el directorio de referencia y encuentra el archivo correspondiente de acuerdo con la ruta de referencia.

Por ejemplo: la ruta de referencia en este momento es: C:\Program Files\Java. Y en este punto estoy buscando javac.exe.

./javac.exe es todo lo que se necesita para lo anterior. representa la ruta base actual .

Y para encontrar src.zip puedes escribir ../src.zip. .. es equivalente a volver a la ruta de nivel superior (C:\Archivos de programa) del punto de referencia y luego encontrar la ruta de destino.

 Para explicarlo en palabras sencillas, la ruta absoluta es relativa a la totalidad de la transacción y el problema relativo es relativo a la parte de la transacción.

1.3 Clasificación de documentos

①Archivo de texto:

El archivo almacena caracteres (esencialmente, bytes almacenados, pero los bytes adyacentes solo forman un carácter). Por lo general, similares a .txt, .c, .java son archivos de texto.

②Archivo binario:

Los archivos almacenan bytes. Similar a .class, .jpg, .doc son archivos binarios

③ Cómo distinguir entre archivos binarios y archivos de texto:

La forma más fácil es abrirlo con el Bloc de notas, si está distorsionado, es un archivo binario , de lo contrario, es un archivo de texto.

2. Archivos de operaciones en java

2.1 Operaciones relacionadas del sistema de archivos

Se refiere a algunas funciones que se pueden realizar a través del administrador de recursos de archivos, la clase File se proporciona en Java, y a través de esta clase se realizan una serie de operaciones, nos centraremos en explicarlo a continuación.

2.2.1 Introducción de la clase Archivo

①Método de construcción del archivo:

El método de construcción de Archivo puede pasar una ruta para especificar un archivo.Esta ruta puede ser una ruta absoluta o una ruta relativa.

②Algunos métodos de archivo:

③Demostramos el funcionamiento de algunos de estos métodos:

Código:

import java.io.File;
import java.io.IOException;
public class demo1 {
    public static void main(String[] args) throws IOException {
        File f=new File("C:/ProgramData/test.txt");
        System.out.println("获取到文件的父目录:"+f.getParent());
        System.out.println("获取到文件名:"+f.getName());
        System.out.println("获取到文件路径:"+f.getPath());
        System.out.println("获取到文件的绝对路径:"+f.getAbsolutePath());
        //这里需要抛出一个异常，并且这里是化简过的绝对路径
        System.out.println("获取到文件的绝对路径:"+f.getCanonicalPath());
        System.out.println("===============");
        //这里的路径是一个基准路径
        File f1=new File("./ProgramData/test.txt");
        System.out.println("获取到文件的父目录:"+f1.getParent());
        System.out.println("获取到文件名:"+f1.getName());
        System.out.println("获取到文件路径:"+f1.getPath());
        System.out.println("获取到文件的绝对路径:"+f1.getAbsolutePath());
        //这里需要抛出一个异常，并且这里是化简过的绝对路径
        System.out.println("获取到文件的绝对路径:"+f1.getCanonicalPath());
    }
}

 Para explicar parte del contenido del código:

2.2.2 Listar archivos

Código:

import java.io.File;
import java.util.Arrays;
public class demo2 {
    public static void main(String[] args) {
        File f = new File("./");
        //查看此目录下的内容(列出目录内容)
        System.out.println(Arrays.toString(f.list()));
        //按照file对象的方法打印
        System.out.println(Arrays.toString(f.listFiles()));
    }
}

resultado:

 

2.2.3 Crear archivo

Código:

import java.io.File;
import java.io.IOException;
public class demo2 {
    public static void main(String[] args) throws IOException {
        //创建一个文件
        File f=new File("./test.txt");
        //判断文件是否存在
        System.out.println(f.exists());
        //创建文件
        f.createNewFile();
        //文件创建结束，判断是否存在
        System.out.println(f.exists());
    }
}

Resultado de salida:

2.2.4 Crear un directorio

①Crear un directorio:

Código:

import java.io.File;
import java.io.IOException;
public class demo2 {
    public static void main(String[] args) throws IOException {
        //创建一个文件
        File f=new File("./aa");
        //创建一个目录
        f.mkdir();
    }
}

resultado:

②Crea múltiples directorios

Código:

import java.io.File;
import java.io.IOException;
public class demo2 {
    public static void main(String[] args) throws IOException {
        //创建一个文件
        File f=new File("./aa/bb/cc");
        //创建一个目录
        f.mkdirs();
    }
}

resultado:

 

2.2.5 Eliminar archivos

Código:

import java.io.File;
import java.io.IOException;
public class demo2 {
    public static void main(String[] args) throws IOException {
        //创建一个文件
        File f=new File("./test.txt");
        //判断文件是否存在
        System.out.println(f.exists());
        //删除文件
        f.delete();
        //删除文件后是否存在
        System.out.println(f.exists());
    }
}

Resultado de la operación:

2.2 Operaciones relacionadas con el contenido del archivo

Para la lectura y escritura del contenido del archivo, la biblioteca estándar de Java proporciona un conjunto de clases, que se dividen en dos series según el contenido del archivo:

① Objeto de flujo de bytes, para archivos binarios , lectura y escritura en bytes

Leer: InputStream Escribir: OutputStream

②Objeto de flujo de caracteres, para archivos de texto , lectura y escritura en unidades de caracteres

Leer: Lector Escribir: Escritor

¡Darse cuenta! ! ! Las cuatro categorías anteriores son clases abstractas, si queremos implementarlas, necesitamos usar sus subclases

FileInputStream, FileOutputStream, FileReader, FileWriter。

Este grupo es un puntero especial para leer y escribir en archivos ordinarios

2.2.1 Abrir archivo

Al instanciar el objeto, ingrese la ruta especificada, que no se detalla aquí, pero se refleja en el código

2.2.2 Lectura de archivos

① InputStream y Reader leen archivos a través del método de lectura. Hablemos primero del método de lectura:

A. Sin versión de parámetro:

Lea un byte a la vez, el valor de retorno es el byte de lectura (¡nota! Cuando se lee -1, significa que el archivo ha sido leído)
B. Una versión de parámetro:

Lea varios bytes a la vez, coloque el resultado de la lectura en la matriz especificada y el valor devuelto es el número de bytes leídos
C. Versión de tres parámetros:

Lea varios bytes a la vez, coloque el resultado de la lectura en la matriz especificada en el parámetro y el valor devuelto es el número de bytes leídos. ¡Darse cuenta! ! ! Aquí, los elementos no se colocan desde la posición inicial de la matriz, sino desde la posición media (fuera del subíndice), y len indica cuántos elementos se pueden colocar como máximo

②Lea el archivo a través de inputStream

a. Leer un byte a la vez

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class demo2 {
    public static void main(String[] args) {
        InputStream inputStream = null;
        try {//创建对象,也是打开文件,有可能没有文件,因此需要抛异常
            inputStream = new FileInputStream("C:/Users/张洋洋的小布偶/Desktop/test.txt");//需要指定路径,可以是相对路径也可以是绝对路径,也可以是File对象
            //尝试一个一个字节的读,把整个文件读完
            while(true){
                int x = inputStream.read();
                if(x == -1){
                    break;//表示读完了所有的字节
                }
                System.out.println(x);//打印
            }
        } catch (IOException e) {
            //这个包含了FileNotFoundException(子类),因此可以合并,IO操作失败的可能性是非常大的
            e.printStackTrace();
        }finally {
            //读完之后需要关闭文件,释放资源
            try {
                inputStream.close();//这个放在finally里面更好有需要把定义放到外面去
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

(Podemos encontrar que es bastante problemático usarlo finalmente para cerrar el archivo, pero al mismo tiempo, Java proporciona un método de prueba, que se puede cerrar automáticamente después de leer la prueba, lo demostraremos a continuación)

B. Lee varios bytes a la vez

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class demo2 {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("C:\\Users\\张洋洋的小布偶\\Desktop/test.txt")) {
            while (true) {
                byte[] tmp = new byte[1024];
                int x = inputStream.read(tmp);
                if (x == -1) {
                    break;//表示读完了所有的字节
                }
                for (int i = 0; i < x; i++) {
                    //打印
                    System.out.println(tmp[i]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 El resultado es el siguiente:

③ Lea el archivo a través de Reader

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class demo2 {
    public static void main(String[] args) {
        try(Reader reader = new FileReader("C:\\Users\\张洋洋的小布偶\\Desktop/test.txt")) {
            while (true){
                char[] c = new char[1024];
                int x = reader.read(c);//一次读多个
                if(x == -1){
                    break;
                }
                /*for (int i = 0; i < x; i++) {
                    System.out.println(c[i]);
                }*/
                String s = new String(c,0,x);//如果传入的是byte也可以指定字符编码
                System.out.println(s);//这样也可以读
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

El resultado es el siguiente:

2.2.3 Escribir archivo

①Flujo de salida

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class demo2 {
    public static void main(String[] args) {
        try (OutputStream outputStream = new FileOutputStream("C:\\Users\\张洋洋的小布偶\\Desktop/test.txt")) {
            /*outputStream.write(98);
            outputStream.write(97);一次写一个
            outputStream.write(97);*/
            //也可以一次写多个
            byte[] b = new byte[]{98,97,97};
            outputStream.write(b);//一次写多个     这里的写操作每次按照写方式打开文件,都会清空原有的文件的内容,然后再从起始位置往后写
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

El resultado es el siguiente:

 ②Escritor

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class demo2 {
    public static void main(String[] args) {
        try(Writer writer = new FileWriter("C:\\Users\\张洋洋的小布偶\\Desktop/test.txt")){
            writer.write("aaa");//写操作
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

El resultado es el siguiente:

 

2.2.4 Cerrar el archivo

Después de cada lectura, debe cerrar el archivo para liberar recursos

3. Tres casos de manipulación de archivos

3.1 Buscar archivos y eliminar

① Pensamiento: recursividad

②Código:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;
//实现查找文件并删除文件
public class Demo13 {
    public static void main(String[] args) {
        //先输入要扫描的目录,以及要删除的文件名
        Scanner input = new Scanner(System.in);
        System.out.println("请输入要扫描的路径:");
        String rootDirPath = input.next();
        System.out.println("请输入要删除的文件名:");
        String toDeleteName = input.next();
        File rootDir = new File(rootDirPath);//构建文件对象
        if(!rootDir.isDirectory()){
            //不是一个目录
            System.out.println("你输入的路径有误");
            return;//可以抛一个异常
        }
        //遍历这个目录,寻找要删除的文件
        scanDir(rootDir,toDeleteName);
    }
    public static void scanDir(File rootDir,String toDeleteName){
        File[] files = rootDir.listFiles();
        if(files == null){
            //rootDir是空目录,返回
            return;
        }
        //不是空目录就遍历此目录里面的所有内容,如果是普通文件就看是不是要删除的文件,不是文件是目录的话,就再遍历这个目录
        for(File f : files){//列出rootDir里面有什么内容
            if(!f.isFile()){
                scanDir(f,toDeleteName);
            }
            if(f.isFile()){
                if(f.getName().contains(toDeleteName)){
                    //不要求名字完全一样,只要文件名中包含了关键字就可以删除
                    //进行删除操作
                    deleteFile(f);
                }
            }
        }
    }
    public static void deleteFile(File f){
        try {
            System.out.println(f.getCanonicalPath() + "确认要删除文件吗(Y/N)");
            Scanner input = new Scanner(System.in);
            String chose = input.next();
            if(chose.equals("Y") || chose.equals("y")){
                f.delete();//进行删除
                System.out.println("文件删除成功");
            }else{
                System.out.println("文件放弃删除");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.2 Copia de archivos ordinarios

①Encuentre el archivo y cópielo

②Código:

import java.io.*;
import java.util.Scanner;
//文件复制,需要让用户支出两个文件路径,一个是原路径(被复制的文件),另一个是目标路径(复制后生成的文件)
public class Demo14 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入要拷贝的源路径:");
        String str = input.next();
        System.out.println("请输入要拷贝的目标路径:");
        String sub = input.next();
        File file = new File(str);
        if(!file.isFile()){//需要判断是不是正确的路径,目标路径不需要判断,因为没有的话,是会自己创建的
            System.out.println("不是一个正确的源路径");
            return;
        }
        //将源文件里面的内容读出来,然后再用写操作写到目标文件中去
        try(InputStream inputStream = new FileInputStream(str)) {
            try(OutputStream outputStream = new FileOutputStream(sub)) {
                byte[] b = new byte[1024];
                while(true){
                    int x = inputStream.read(b);
                    if(x == -1){
                        break;
                    }
                    outputStream.write(b,0,x);//需要指定长度,不能把所有的b都放进去
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.3 Búsqueda del contenido del archivo

① Pensamiento: recursividad

②Código:

import java.io.*;
import java.util.Scanner;
//进行文件内容的查找,扫描指定目录,找到名称或内容中包含指定字符的所有普通文件(不包含目录)
public class Demo15 {
    public static void main(String[] args) throws IOException {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入要扫描的文件路径:");
        String rootDirPath = input.next();
        System.out.println("请输入要查询的关键字:");
        String word = input.next();
        File rootDir = new File(rootDirPath);
        if(!rootDir.isDirectory()){
            System.out.println("输入的路径非法!");
            return;
        }
        sDir(rootDir,word);
    }
 
    private static void sDir(File rootDir, String word) throws IOException {
        File[] files = rootDir.listFiles();
        if(files == null){
            return;
        }
        for (File f:files) {
            if(f.isDirectory()){
                sDir(f,word);
            }
            if(f.isFile()){
                //针对文件进行查找
                if(containsWord(f,word)){
                    System.out.println(f.getCanonicalPath());
                }
            }
        }
    }
 
    private static boolean containsWord(File f, String word) {
        StringBuilder stringBuilder = new StringBuilder();
        //把f中的内容都读出来,放到StringBuilder中,看是否包含关键字
        try(Reader reader = new FileReader(f)){
            char[] c = new char[1024];
            while(true){
                int x = reader.read(c);
                if(x == -1){
                    break;
                }
                stringBuilder.append(c,0,x);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //indexOf返回的是子串的下标,如果word存在,那么下标一定不是-1,
        return stringBuilder.indexOf(word) != -1;
    }
}