我们先来认识狭义上的文档(file)。针对硬盘这种持久化存储的I/O设备，当我们想要进行数据保存时，往往不是保存成⼀个整体，而是独立成⼀个个的单位进行保存立的单位就被抽象成文件的概念，就类似办公桌上的⼀份份真实的文件⼀般。

public class Test {
    public static void main(String[] args) {
        File parentFile=new File("D:/Mytest");
        File file1=new File(parentFile,"eg1.txt");  //构造方法1
        File file2=new File("D:/Mytest/eg1.txt");  //构造方法2
        File file3=new File("D:/Mytest","eg1.txt"); //构造方法3
    }
}

File类既可以可以构建文件的对象，也可以构建目录的对象

上面的三个File类的实例对象指向的是同一个文件

创建一个File的实例对象可以用绝对路径，也可以用相对路径

2.1.2 File类中的方法

getAbsolutePath() 与 getCanonicalPath() 区别

 File file=new File("./eg2");
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getCanonicalPath());

直接用相对路径来构造文件对象时，如果是在idea中运行的该代码：其中的 . 代表的是基准目录--代码运行所在的工作目录（如果不是在idea运行就另当别论）

file.getAbsolutePath()获得的是该文件所在的绝对路径（实际上是把它的基准目录的绝对路径和构造File对象所传入的文件名的字符串的一个简单拼接）

而file.getCanonicalPath()获得的是修饰过的该文件所在的绝对路径

当我们在创建File类对象时，我们传入的文件/目录可以不存在，不存在不会影响创建对象--因为File有一个能力，它能创建新的文件/目录，但是在真正的 .creatnewFile()/.mkdir()//mkdirs之前，我们调用.exists() 还是会返回flase
我们在创建文件/目录时可能会失败--原因：1.硬盘满了 2. 没有权限
createNewFile() ：若构造File类对象时传入的文件已存在，直接返回 false ，不会覆盖或报错
mkdir()--创建单层目录 / mkdirs() --创建多层嵌套目录：若构造File类对象时传入目录已存在，同样返回 false ，不会修改已有目录。（如果在调用mkdirs()时若传入的目录有部分存在--跳过创建已有目录，直接创建不存在的目录）
renameTo（File dest）：在使用该方法时必须需要两个File类对象（源 source 从哪里来目标 dest 到哪里去），下面来展示一下它的几个作用 1.重命名

        File source=new File("D:/Mytest/eg1.txt");
        File dest=new File("D:/Mytest/eg2.txt");
             source.renameTo(dest);

2. 移动

        File source=new File("D:/Mytest/eg2.txt");
        File dest=new File("D:/Mytest222/eg2.txt");
             source.renameTo(dest);

3. 移动+重命名

File source=new File("D:/Mytest222/eg2.txt");
        File dest=new File("D:/Mytest/eg1.txt");
             source.renameTo(dest);

delete（）与deletonExit（）区别

delete（）：直接删除从硬盘中删除，不是放进回收站

deletonExit（）：在JVM进程退出前才删除（方便操作临时文件）

2.2 文件内容操作

读：把文件内容获取出来

写：对文件内进行修改

对于上述读和写的操作，操作系统提供了相关的API函数，而Java对这些API进行了进一步的封装--一组类--流对象

而Java标准库中对此分出来两个的类别：字节流和字符流

2.2.1 字节流

字节流 : 读写时，以字节为基本单位

需要用到 InputStream（输入）和outputStream（输出）这两个抽象类，当然我们在进行具体的操作是用到它们的子类

2.2.1.1 InputStream中的方法

InputStream只是⼀个抽象类，要使用还需要具体的实现类。关于InputStream的实现类有很多，基本可以认为不同的输入设备都可以对应⼀个InputStream类，我们现在只关心从文件中读取，所以使用 FileInputStream

2.2.1.2 FileInputStream

FileInputStream 的构造方法

FileInputStream只能用来读文件

FileInputStream.read() 方法有三个方式：

1.int read（）：一次只读一个字节，如果还未读到文件末尾，返回的是读取的单个字节对应的 int 类型值，如果已经读到文件末尾，则返回 -1

public class Test {
    public static void main(String[] args) throws IOException {
        File file=new File("D:/Mytest/eg1.txt");
        InputStream inputStream=new FileInputStream(file);//创建流对象的过程就相当于“打开文件”
        while (true){
           int n= inputStream.read();//打开完毕，就可以进行读操作
           if(n==-1){
               break;
           }
            System.out.printf("%x\n",n);
        }
    }
}

2. int read（byte [ ] b) : 一次读若干字节，一次性最多读满数组容量的字节数，如果还没读到文件末尾，返回的是本次读取到的实际字节数目，如果已经读到文件末尾，则返回 -1，其中的 byte [ ] b 是“输出型参数”，读取到的字节会放在该数组中。由于 byte [ ] b 后面没有指定读取字节所要放的位置，所以每一次读（调用read（））都会从下标为0的地方进行存放本次所读取到的字节（每一次读不会清空前一次读所存放在b数组的内容）

public class Test {
    public static void main(String[] args) throws IOException {
        File file=new File("D:/Mytest/eg1.txt");
        InputStream inputStream=new FileInputStream(file);
        byte[] bytes=new byte[1024];
        while (true){
           int n=inputStream.read(bytes);
           if(n==-1){
               break;
           }
            for (int i = 0; i


3. int read（byte [ ] b，int off ，int len) ：off 指定了每一次读取字节后存放到数组b的起始位置，len 指定了每一次预期读取的最大字节数
我们知道InputStream的核心操作：1.打开文件（创建流对象）2. 读文件(read) 3. 关闭文件（close），我们已经了解了前两个操作，现在我们来了解如何关闭文件--- close（）
关闭文件
特殊情况下，我们不用不必关闭文件：如果在进程中读取文件完毕后，立即退出--原因---进程退出整个PCB都释放了（操作系统内核释放的）
关闭文件有两种方式，一种是手动调用close（），另外更推荐的一种是使用 try with resources，使用这个就可以不用手动调 close（），代码如下：
public class Test {
    public static void main(String[] args) {
        File file = new File("D:/Mytest/eg1.txt");
        try(  InputStream inputStream = new FileInputStream(file)){
            byte[] bytes = new byte[1024];
            while (true) {
                int n ;
                n = inputStream.read(bytes);
                if (n == -1) {
                    break;
                }
                for (int i = 0; i < n; i++) {
                    System.out.printf("%x\n", bytes[i]);
                }
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}
2.2.1.3 outputStream中的方法
OutputStream同样只是⼀个抽象类，要使用还需要具体的实现类。我们现在还是只关心写入文件 中，所以使用FileOutputStream
2.2.1.4 FileOutputStream
FileOutputStream的构造方法
FileOutputStream 只能用来写文件
FileOutputStream的 write（）有三种方式，如下所示
1. void write（int b）一次写一个字节
public class Test {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream=new FileOutputStream("D:/Mytest/eg1.txt");
        outputStream.write(65);  //文件写入 A
    }
}
2. void（byte [ ] b）一次写完整的字节数组，与读不同，写是一次性写完（所以不用使用while循环）
public class Test {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream=new FileOutputStream("D:/Mytest/eg1.txt");
        byte[] bytes=new byte[]{65,66,67,68,69,70};
        outputStream.write(bytes);  //文件写入ABCDEF
    }
}
3. void（byte [ ] b，int off ，int len）指定写入数组的一部分
public class Test {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream=new FileOutputStream("D:/Mytest/eg1.txt");
        byte[] bytes=new byte[]{65,66,67,68,69,70};
        outputStream.write(bytes,1,5); //在文件中写入BCDEF
    }
}
注意对于FileOutputStream写文件，每一次打开文件（new FileOutputStream的文件对象）都会先清除文件的全部内容，如果我们想从文件的末尾开始写而不清除原文件的内容（追加写）---在创建文件FileOutputStream对象时设置为true------如OutputStream outputStream=new FileOutputStream("D:/Mytest/eg1.txt",true);
对于写的操作同样需要关闭文件---同样使用更简便的方式--- try with resources
public class Test {
    public static void main(String[] args)  {
        try( OutputStream outputStream=new FileOutputStream("D:/Mytest/eg1.txt")){
            byte[] bytes=new byte[]{65,66,67,68,69,70};
            outputStream.write(bytes);
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
}
2.2.2 字符流
字符流 : 读写时，以字符为基本单位
需要用到 Reader（输入）和 Writer（输出）这两个抽象类，当然我们在进行具体的操作是用到它们的子类（与字节流的写与读类似）
2.2.2.1 Reader 与 FileReader
FileReader类是Reader抽象类的子类，只用于字符流的读操作
FileReader的 read（）的四种方式
和 FileInputStream.read( )的三个方法是类似的，只是它的第三个方式使用的 CharBuffer（是对char的高级封装 ） 
public class Test {
    public static void main(String[] args) throws IOException {
     try(Reader reader=new FileReader("D:/Mytest/eg1.txt")){
         while(true){
             int n=reader.read();
             if(n==-1){
                 break;
             }
             char c=(char)n;
             System.out.println(c);
         }
     }
        catch (IOException e){
         e.printStackTrace();
        }
    }
}
public class Test {
    public static void main(String[] args) throws IOException {
     try(Reader reader=new FileReader("D:/Mytest/eg1.txt")){
         char[] chars=new char[1024];
         while(true){
             int n=reader.read(chars);
             if(n==-1){
                 break;
             }
             for (int i = 0; i 

不管是字节流的读和写，还是字符流的读和写都要关闭文件
2.2.2.2 Writer 与 FileWriter
FileWriter类是Writer 抽象类的子类，只用于字符流的写操作
FileWriter的 write（）的五种方式
由于与字节流的操作基本类似，这里就不过多讲解了
public class Test {
    public static void main(String[] args) throws IOException {
     try(Writer writer=new FileWriter("D:/Mytest/eg1.txt",true)){
         writer.write("abcdef");
     }
        catch (IOException e){
         e.printStackTrace();
        }
    }
}
2.2.3 Scanner搭配 InputStream 使用
我们平时使用 Scanner 是把控制台输入的内容读取到程序中，而一般传入的参数System.in中的 in 实际上是InputStream类型的
所以我们不仅能使用Scanner读取控制台输入的内容（Scanner的输入源本质是 InputStream），也能从构建成InputStream类型的文件对象中读取内容到程序中,然后我们就能通过Scanner提供的一系列针对性的读取方法---能够根据数据类型灵活解析InputStream中的内容
public class Test {
    public static void main(String[] args) throws FileNotFoundException {
        InputStream inputStream=new FileInputStream("D:/Mytest/eg1.txt");
        Scanner sc=new Scanner(inputStream);
        while (sc.hasNext()){
            System.out.println(sc.nextInt());
        }
    }
}
2.2.4 PrintWriter 类
PrintWriter 类是writer 抽象类的间接子类，能够针对文件进行格式化的写入
PrintWriter 的 printf（）方法既可以输出/写入内容到控制台中，也可以写入到文件中，关键就在于实例化 PrintWriter 对象时传入的参数，如果是传入文件--就写入到文件中。如果是传入的System.out--就写入/输出到控制台中
public class Test {
    public static void main(String[] args) throws FileNotFoundException {
    try(PrintWriter p=new PrintWriter("D:/Mytest/eg1.txt")){
       p.printf("%d+%d=%d",10,20,30);
   }catch (IOException e){
        e.printStackTrace();
    }
    }
}
文件中：