文件操作和IO—javaEE

1.文件

文件包含数据本身和文件的头信息（metadata），文件的头信息包括文件名、修改时间、文件大小等

1.1文件系统的结构

（1）文件路径
①绝对路径：从根结点到叶子结点的整个路径

语法：cd 绝对路径

②相对路径：从任意一个节点出发到目的节点经过的路径

语法：cd …/到上一级
cd ./到当前目录

注意：文件的上一级指的是以文件所在目录找上一级

目录：从E:\me\课表及日历到E:\me\实验\2021实验

文件：从E:\me\课表\大一上.png到E:\python\py.txt

…/…/python/py.txt
（2）文件的划分：文件类型和二进制类型（不同维度可以划分不同的文件类型）
①文本本质上也是基于二进制来保存数据的，是使用了一种编码格式保存的文本，打开文本也要指定和保存时一样的编码格式

注意：保存和打开的编码格式要一致，否则会乱码，其他地方也是一样，例如：涉及网络数据操作，数据库保存数据（创建数据库是指定的编码格式），java操作数据库的数据（URL中指定）要一致；java中的文本是string，可以通过字符串.getBytes(“编码格式”)，返回的是byte[]

②二进制类型的文件（图片、视频、音频等）：可以使用文本编辑器打开，但是看到的是乱码

注意：java中的二进制数据byte[]，也可以转文本（string）：new String（byte数组）或者String（byte数组，“编码格式”）

（3）文件权限：读、写、执行
（4）文件分隔符：Windows是\，Linux是/

1.2java中的文件操作（metadata的操作）

（1）属性（Fileds）
文件系统分隔符

（2）构造方法（constructor）
这里传入的路径可以是绝对路径，也可以是相对路径

注意：java中，file对象可以是文件，也可以是目录；new一个不存在的路径，这个file对象还是实例化了，只是不存在

（3）方法（methods）

package file;
import java.io.File;
import java.io.IOException;

public class createFile {
    public static void main(String[] args) throws IOException {
        //创建一个文件
        File file = new File("E:/TMP/1.txt");
        //不存在就创建这个文件
        if(!file.exists()){
            file.createNewFile();
        }
    }
}

package file;
import java.io.File;

public class createDirectory {
    public static void main(String[] args) {
        //创建一级目录
        File file = new File("E:/TMP/文件1");
        if(!file.exists()){
            file.mkdir();
        }
        //创建多级目录
        File file1 = new File("E:/TMP/文件2/2/3");
        if (!file1.exists()){
            file1.mkdirs();
        }
    }
}

package file;
import java.io.File;
import java.util.Date;

public class getInformation {
    public static void main(String[] args) {
        File file = new File("E:/TMP/1.txt");
        System.out.println(file.getName());//1.txt 文件名称
        System.out.println(file.getPath());//E:\TMP\1.txt 文件路径
        System.out.println(file.length());//33 文件大小（字节数）
        System.out.println(file.lastModified());//1681133071149上次修改时间
        System.out.println(new Date(file.lastModified()));//Mon Apr 10 21:24:31 CST 2023 转化为日期型
        System.out.println(file.isFile());//true 是否是文件
        System.out.println(file.isDirectory());//false 是否是目录
    }
}

package file;
import java.io.File;

public class rename {
    public static void main(String[] args) {
        //重命名
//        File file = new File("E:/TMP/1.txt");
//        file.renameTo(new File("E:/TMP/1_rename.txt"));
        //移动
        File file = new File("E:/TMP/1_rename.txt");
        file.renameTo(new File("E:/TMP/文件1/1_rename.txt"));
    }
}

返回目录的子文件或目录

package file;
import java.io.File;
import java.util.Arrays;

public class getChildren {
    public static void main(String[] args) {
        File file = new File("E:/TMP/文件1");
        //返回目录的子文件或目录
        File[] files = file.listFiles();
        System.out.println(Arrays.toString(files));
    }
}

返回所有子文件和目录

package file;
import java.io.File;
public class getAllChildren {
    public static void main(String[] args) {
        File file = new File("E:/TMP/文件1");
        getChildrenList(file);
    }
    private static void getChildrenList(File file){
        System.out.println(file);
        //如果是目录，就查找子文件或目录
        if (file.isDirectory()){
            //子目录或文件
            File[] files = file.listFiles();
            //递归找下一级的子目录或文件
            for (File child : files){
                getChildrenList(child);
            }
        }
    }
}

package file;
import java.io.File;

public class delete {
    public static void main(String[] args) {
        //删除文件
//        File file = new File("E:/TMP/文件1/1_rename.txt");
//        file.delete();
        //删除目录：目录下没有东西才可以删除，如果有东西，需要一个一个遍历依次删除
        File file = new File("E:/TMP/文件2");
        file.delete();
    }
}

2.io操作

2.1定义

io操作是将数据从一个设备传输到另一个设备（i是input（输入）；o是output（输出）），下图是本地文件io的过程

2.2io划分

（1）从来源划分：文件io、网络io
（2）从方向划分：输入流（读取数据）、输出流（写数据）

• System.in：标椎输入流
• System.out：标椎输出流
• System.err：错误输出流

操作流的注意事项：对于读取数据来说：已读的部分就不能再次读取了；io的输入流可以再嵌套输入流，io的输出流可以再次嵌套输出流；使用完输入、输出流要关闭流

2.3java的io流之输入流

（1）class InputStream是最定级的输入流，所有真实使用的io流都是他的子类
这三种方法都是返回值是-1就表示输入流结束了

package ioReader;
import java.io.FileInputStream;
import java.io.IOException;

public class ioRead1 {
    //一个字节一个字节的读
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("E:/TMP/文件1/2.txt");
        byte[] bytes = new byte[fileInputStream.available()];
        int len;
        for (int i = 0;(len = fileInputStream.read()) != -1;i++){
            bytes[i] = (byte) len;
        }
        System.out.println(new String(bytes,"UTF-8"));
    }
}

（2）class FileInputStream
文件的输入流，读取文件的内容，可以读取文本文件、二进制数据到字节数组中

package ioReader;
import java.io.FileInputStream;
import java.io.IOException;

public class ioRead {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("E:/TMP/文件1/2.txt");
        byte[] bytes = new byte[1024];//字节数组用来保存读取的数据
        int len;//每次读取的长度
        //读到文件结束，返回值是-1就是文件结束
        while ((len = fileInputStream.read(bytes)) != -1){
            //字节数组中0-len就是读取的数据
            //二进制转换为字符串，要和保存的时候的编码格式保持一致
            //string的构造方法就是把字节数组从offset位置读取到offset+len的位置，读取len的字节
            //UTF-8指定编码类型
            String str = new String(bytes,0,len,"UTF-8");
            System.out.println(str);
        }
    }
}

（3）输入流可以嵌套其他输入流
比较常见的字符输出流是BufferedReader（带缓冲区，读文本文件且效率较高），io包下带reader的都是字符输入流

package ioReader;
import java.io.*;

public class ioReaderChar {
    //字符输入流读取文件（适用的最多的是BufferedReader）
    public static void main(String[] args) throws IOException {
        //先获取一个字节流
        FileInputStream fileInputStream = new FileInputStream("E:/TMP/文件1/2.txt");
        //再包装为一个字节字符转换流
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"UTF-8");
        //再包装为一个字节流
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String str;
        //每次读取一行，没有结束就一直读
        while ((str = bufferedReader.readLine()) != null){
            System.out.println(str);
        }
    }
}

关于缓冲区：
无缓冲区：一个字节一个字节读取或者字节数组读取效率都比较低；内存速度远高于硬盘，但是这种操作（进程read）都要等硬盘传输完，进程这个过程中是阻塞等待

有缓冲区：使用了缓冲区，达到一定数量再进行读取，提高了效率

2.4java的io流之输出流

（1）class outputStream是输出流的顶级抽象类，所有使用的输出流都是它的子类

（2）class FileOutputStream是文件字节输出流
通过继承outputStream的三个write方法就能写字节数据，也可以写二进制数据或文本

注意：输出流写了数据，如果这个输出对象有flush方法记得调用，表示刷新缓冲区，因为写数据可能不是直接往硬盘上写，而是先写到缓冲区，flush方法就是刷新缓冲区，写入硬盘

package ioWriter;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ioCopyFile {
    //字节流复制文件
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("E:/TMP/文件1/2.txt");
        FileOutputStream fileOutputStream = new FileOutputStream("E:/TMP/2_copy.txt");
        byte[] bytes = new byte[1024 * 8];
        int len;
        for (int i = 0;(len = fileInputStream.read(bytes))!=-1 ; i++) {
            //字节数组中0-len范围是读取的数据，同时往输出流写数据
            fileOutputStream.write(bytes,0,len);
            fileOutputStream.flush();
        }
        fileOutputStream.close();
        fileInputStream.close();
    }
}

（3）BufferedWrite：io包下带write的都是字符输出流，注意要输出到字节流中，需要先使用字节字符转换流outputStreamWrite

new BufferedWriter(new OutputStreamWriter(new FileOutputStream(),“编码格式”))

package ioWriter;
import java.io.*;

public class ioWriterFile {
    //字节流写文件
    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("E:/TMP/文件1/2.txt");
        String str = "大家好";
        fileOutputStream.write(str.getBytes("UTF-8"));
        fileOutputStream.close();
    }
}