File类

1. File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)。
2. File类声明在java.io包下。
3. File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。

4. 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的”终点”.

   常用构造器

5. public File(String pathname) 以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果 pathname是相对路径（在project中，相对路径的根目录是project的根文件夹），则默认的当前路径在系统属性user.dir中存储。

6. public File(String parent,String child) 以parent为父路径，child为子路径创建File对象。
7. public File(File parent,String child) 根据一个父File对象和子文件路径创建File对象。 ```java //构造器1 File file1 = new File(“hello.txt”);//相对于当前module File file2 = new File(“D:\workspace_idea1\JavaSenior\day08\he.txt”);

System.out.println(file1); System.out.println(file2);

//构造器2： File file3 = new File(“D:\workspace_idea1”,”JavaSenior”); System.out.println(file3);

//构造器3： File file4 = new File(file3,”hi.txt”); System.out.println(file4);

<a name="PVrl2"></a>
## 常用方法
<a name="WvHnw"></a>
###  获取功能
- `public String getAbsolutePath()`：获取绝对路径
- `public String getPath() `：获取路径
- `public String getName() `：获取名称
- `public String getParent()`：获取上层文件目录路径。若无，返回null
- `public long length()` ：获取文件长度（即：字节数）。不能获取目录的长度。
- `public long lastModified()` ：获取最后一次的修改时间，毫秒值
如下的两个方法适用于文件目录：
- `public String[] list()` ：获取指定目录下的所有文件或者文件目录的名称数组
- `public File[] listFiles()` ：获取指定目录下的所有文件或者文件目录的File数组
```java
File file = new File("D:\\workspace_idea1\\JavaSenior");
String[] list = file.list();
for(String s : list){
    System.out.println(s);
}
System.out.println();
File[] files = file.listFiles();
for(File f : files){
    System.out.println(f);
}

重命名功能

• public boolean renameTo(File dest)：把文件重命名为指定的文件路径。
  比如：file1.renameTo(file2)为例：要想保证返回true，需要file1在硬盘中是存在的，且file2不能在硬盘中存在。

判断功能

• public boolean isDirectory()：判断是否是文件目录
• public boolean isFile()：判断是否是文件
• public boolean exists()：判断是否存在
• public boolean canRead() ：判断是否可读
• public boolean canWrite() ：判断是否可写
• public boolean isHidden() ：判断是否隐藏

创建功能

• public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false.
• public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
• public boolean mkdirs() ：创建文件目录。如果此文件目录存在，就不创建了。如果上层文件目录不存在，一并创建.

删除磁盘中的文件或文件目录

• public boolean delete()：删除文件或者文件夹
  删除注意事项：Java中的删除不走回收站。

IO流

Java IO原理

• I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输，如读/写文件，网络通讯等。
• Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。
• java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

流的分类

• 按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit) 。
• 按数据流的流向不同分为：输入流，输出流。
• 按流的角色的不同分为：节点流（文件流），处理流。

  1. 节点流：可以从特定数据源读写数据，如FileReader、FileWriter。
  2. 处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。

流的体系

蓝色为重点

节点流（文件流）

对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理，非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,…)，使用字节流处理。具体的操作流程都类似，只需根据不同的文件类型选取相应的函数即可。

⚠️如果用字节流处理文本文件可能会出现乱码。 https://blog.csdn.net/weixin_44720982/article/details/124314583

• 读取文件

1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1。
2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理。
3. 读入的文件一定要存在，否则就会报FileNotFoundException。

@Test
public void testFileReader() {
    FileReader fr = null;
    try {
        //1.File类的实例化
        File file = new File("hello.txt");

        //2.FileReader流的实例化
        fr = new FileReader(file);

        //3.读入的操作
        //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
        char[] cbuf = new char[5];  //cbuf:charbuffer
        int len;
        while((len = fr.read(cbuf)) != -1){
            //方式一：
            //错误的写法
            //                for(int i = 0;i < cbuf.length;i++){
            //                    System.out.print(cbuf[i]);
            //                }
            //正确的写法
            //                for(int i = 0;i < len;i++){
            //                    System.out.print(cbuf[i]);
            //                }
            //方式二：
            //错误的写法,对应着方式一的错误的写法
            //                String str = new String(cbuf);
            //                System.out.print(str);
            //正确的写法
            String str = new String(cbuf,0,len);
            System.out.print(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fr != null){
            //4.资源的关闭
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

• 写入文件

1. 输出操作，对应的File可以不存在的。并不会报异常。
2. File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。

3. File对应的硬盘中的文件如果存在：

   1. 如果流使用的构造器是：FileWriter(file,false) / FileWriter(file)：对原有文件的覆盖。

   2. 如果流使用的构造器是：FileWriter(file,true)：不会对原有文件覆盖，而是在原有文件基础上追加内容。 ```java @Test public void testFileWriter() { FileWriter fw = null; try { //1.提供File类的对象，指明写出到的文件 File file = new File(“src/IO/hello.txt”);

      //2.提供FileWriter的对象，用于数据的写出 fw = new FileWriter(file,true);

      //3.写出的操作 fw.write(“I have a dream!\n”); fw.write(“you need to have a dream!\n”); } catch (IOException e) { e.printStackTrace(); } finally { //4.流资源的关闭 if(fw != null){

       try {
           fw.close();
       } catch (IOException e) {
           e.printStackTrace();
       }
      

      } }

}

- **文件复制**
1. 文本文件字符流复制。
```java
@Test
public void testFileReaderFileWriter() {
    FileReader fileReader = null;
    FileWriter fileWriter = null;
    try {
        File file = new File("src/IO/hi.txt");
        File copyFile = new File("src/IO/copy_hi.txt");

        fileReader = new FileReader(file);
        fileWriter = new FileWriter(copyFile, true);

        char[] cbuf = new char[5];
        int len;
        while ((len = fileReader.read(cbuf)) != -1) {
            fileWriter.write(cbuf, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fileReader != null) {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (fileWriter != null) {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

1. 非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,…)字节流复制。 ```java public void copyFile(String srcPath,String destPath){ FileInputStream fis = null; FileOutputStream fos = null; try {

    //造文件
    File srcFile = new File(srcPath);
    File destFile = new File(destPath);
   
    //造流
    fis = new FileInputStream(srcFile);
    fos = new FileOutputStream(destFile);
   
    //复制的过程
    byte[] buffer = new byte[1024];
    int len;
    while((len = fis.read(buffer)) != -1){
        fos.write(buffer,0,len);
    }
   

   } catch (IOException e) {

    e.printStackTrace();
   

   } finally {

    if(fos != null){
        //
        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if(fis != null){
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
   
    }
   

   } }

@Test public void testCopyFile(){

long start = System.currentTimeMillis();

String srcPath = "C:\\Users\\Administrator\\Desktop\\01-视频.avi";
String destPath = "C:\\Users\\Administrator\\Desktop\\02-视频.avi";


//        String srcPath = "hello.txt";
//        String destPath = "hello3.txt";

copyFile(srcPath,destPath);


long end = System.currentTimeMillis();

System.out.println("复制操作花费的时间为：" + (end - start));//618

}

<a name="D7PBR"></a>
### 
<a name="I8Qs7"></a>
### 缓冲流
提升流的读取、写入的速度（内部提供了一个缓冲区�）。

- **文件复制**
1. 文本文件复制。
```java
@Test
public void testBufferedReaderBufferedWriter(){
    BufferedReader br = null;
    BufferedWriter bw = null;
    try {
        //创建文件和相应的流
        br = new BufferedReader(new FileReader(new File("dbcp.txt")));
        bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));

        //读写操作
        //方式一：使用char[]数组
        //            char[] cbuf = new char[1024];
        //            int len;
        //            while((len = br.read(cbuf)) != -1){
        //                bw.write(cbuf,0,len);
        //    //            bw.flush();
        //            }

        //方式二：使用String
        String data;
        while((data = br.readLine()) != null){
            //方法一：
            //                bw.write(data + "\n");//data中不包含换行符
            //方法二：
            bw.write(data);//data中不包含换行符
            bw.newLine();//提供换行的操作

        }


    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //关闭资源
        if(bw != null){

            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(br != null){
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}

�

1. 非文本文件复制。

   public void copyFileWithBuffered(String srcPath,String destPath){
    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;
   
    try {
        //1.造文件
        File srcFile = new File(srcPath);
        File destFile = new File(destPath);
        //2.造流
        //2.1 造节点流
        FileInputStream fis = new FileInputStream((srcFile));
        FileOutputStream fos = new FileOutputStream(destFile);
        //2.2 造缓冲流
        bis = new BufferedInputStream(fis);
        bos = new BufferedOutputStream(fos);
   
        //3.复制的细节：读取、写入
        byte[] buffer = new byte[1024];
        int len;
        while((len = bis.read(buffer)) != -1){
            bos.write(buffer,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4.资源关闭
        //要求：先关闭外层的流，再关闭内层的流
        if(bos != null){
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
   
        }
        if(bis != null){
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
   
        }
        //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
        //        fos.close();
        //        fis.close();
    }
   }
   

   转换流

   提供了在字节流和字符流之间的转换。
   

• 解码：字节、字节数组 —->字符数组、字符串
  编码：字符数组、字符串 —-> 字节、字节数组
• 字符集

https://www.bilibili.com/video/BV1Kb411W75N?p=602&share_source=copy_web

• ASCII：美国标准信息交换码。用一个字节的7位可以表示。
• ISO8859-1：拉丁码表。欧洲码表用一个字节的8位表示。
• GB2312：中国的中文编码表。最多两个字节编码所有字符。
• GBK：中国的中文编码表升级，融合了更多的中文文字符号，最多两个字节编码
• Unicode：国际标准码，融合了目前人类使用的所有字符，为每个字符分配唯一的字符码，所有的文字都用两个字节来表示。
• UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。

/*
    此时处理异常的话，仍然应该使用try-catch-finally

    综合使用InputStreamReader和OutputStreamWriter
     */
@Test
public void test2() throws Exception {
    //1.造文件、造流
    File file1 = new File("dbcp.txt");
    File file2 = new File("dbcp_gbk.txt");

    FileInputStream fis = new FileInputStream(file1);
    FileOutputStream fos = new FileOutputStream(file2);

    InputStreamReader isr = new InputStreamReader(fis,"utf-8");
    OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

    //2.读写过程
    char[] cbuf = new char[20];
    int len;
    while((len = isr.read(cbuf)) != -1){
        osw.write(cbuf,0,len);
    }

    //3.关闭资源
    isr.close();
    osw.close();


}

（了解）标准输入、输出流

• System.in：标准的输入流，默认从键盘输入。
• System.out：标准的输出流，默认从控制台输出。

• System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流。� ```java /*练习： 从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作， 直至当输入“e”或者“exit”时，退出程序。

  方法一：使用Scanner实现，调用next()返回一个字符串 方法二：使用System.in实现。System.in —-> 转换流 —-> BufferedReader的readLine()*/

BufferedReader br = null; try { InputStreamReader isr = new InputStreamReader(System.in); br = new BufferedReader(isr);

while (true) {
    System.out.println("请输入字符串：");
    String data = br.readLine();
    if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
        System.out.println("程序结束");
        break;
    }

    String upperCase = data.toUpperCase();
    System.out.println(upperCase);

}

} catch (IOException e) { e.printStackTrace(); } finally { if (br != null) { try { br.close(); } catch (IOException e) { e.printStackTrace(); }

}

}

�
<a name="vi3ml"></a>
### （了解）打印流
实现将基本数据类型的数据格式转化为字符串输出。提供了一系列重载的print() 和 println()。
```java
PrintStream ps = null;
try {
    FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
    // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
    ps = new PrintStream(fos, true);
    if (ps != null) {// 把标准输出流(控制台输出)改成文件
        System.setOut(ps);
    }


    for (int i = 0; i <= 255; i++) { // 输出ASCII字符
        System.out.print((char) i);
        if (i % 50 == 0) { // 每50个数据一行
            System.out.println(); // 换行
        }
    }


} catch (FileNotFoundException e) {
    e.printStackTrace();
} finally {
    if (ps != null) {
        ps.close();
    }
}

（了解）数据流

用于读取或写出基本数据类型的变量或字符串。
�

• 写出数据 ```java /* 练习：将内存中的字符串、基本数据类型的变量写出到文件中。

  注意：处理异常的话，仍然应该使用try-catch-finally. */ @Test public void test3() throws IOException { //1. DataOutputStream dos = new DataOutputStream(new FileOutputStream(“data.txt”)); //2. dos.writeUTF(“刘建辰”); dos.flush();//刷新操作，将内存中的数据写入文件 dos.writeInt(23); dos.flush(); dos.writeBoolean(true); dos.flush(); //3. dos.close();

}

- **读取数据**
```java
/*
    练习：将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。

    注意：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
*/
@Test
public void test4() throws IOException {
    //1.
    DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
    //2.
    String name = dis.readUTF();
    int age = dis.readInt();
    boolean isMale = dis.readBoolean();

    System.out.println("name = " + name);
    System.out.println("age = " + age);
    System.out.println("isMale = " + isMale);

    //3.
    dis.close();

}

对象流

用于存储和读取基本数据类型数据或对象的处理流。（它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来）

• 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制 。
• 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制。

Person需要满足如下的要求，方可序列化

1. 需要实现接口：Serializable。
2. 当前类提供一个全局常量：serialVersionUID。
3. 除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化（默认情况下，基本数据类型可序列化）

*补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量。

public class Person implements Serializable{

    public static final long serialVersionUID = 475463534532L;

    private String name;
    private int age;
    private int id;
    private Account acct;

    ...
}

• 序列化 ```java / 序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去。 使用ObjectOutputStream实现。 / @Test public void testObjectOutputStream(){ ObjectOutputStream oos = null;

  try {

    //1.
    oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
    //2.
    oos.writeObject(new String("我爱北京天安门"));
    oos.flush();//刷新操作
  
    oos.writeObject(new Person("王铭",23));
    oos.flush();
  
    oos.writeObject(new Person("张学良",23,1001,new Account(5000)));
    oos.flush();
  

  } catch (IOException e) {

    e.printStackTrace();
  

  } finally {

    if(oos != null){
        //3.
        try {
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
  
    }
  

  }

}

- **反序列化**
```java
/*
    反序列化：将磁盘文件中的对象还原为内存中的一个java对象
    使用ObjectInputStream来实现
     */
@Test
public void testObjectInputStream(){
    ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(new FileInputStream("object.dat"));

        Object obj = ois.readObject();
        String str = (String) obj;

        Person p = (Person) ois.readObject();
        Person p1 = (Person) ois.readObject();

        System.out.println(str);
        System.out.println(p);
        System.out.println(p1);

    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        if(ois != null){
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

随机存取文件流

1. RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口。
2. RandomAccessFile既可以作为一个输入流，又可以作为一个输出流。
3. 如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。
   如果写出到的文件存在，则会对原有文件内容进行覆盖（默认情况下从头覆盖）。
4. 可以通过相关的操作，实现RandomAccessFile“插入”数据的效果。

��

• 文件复制

  @Test
  public void test1() {
  
    RandomAccessFile raf1 = null;
    RandomAccessFile raf2 = null;
    try {
        //1.
        raf1 = new RandomAccessFile(new File("爱情与友情.jpg"),"r");
        raf2 = new RandomAccessFile(new File("爱情与友情1.jpg"),"rw");
        //2.
        byte[] buffer = new byte[1024];
        int len;
        while((len = raf1.read(buffer)) != -1){
            raf2.write(buffer,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //3.
        if(raf1 != null){
            try {
                raf1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
  
        }
        if(raf2 != null){
            try {
                raf2.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
  
        }
    }
  }
  

• 数据插入

  @Test
  public void test3() throws IOException {
  
    RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
  
    raf1.seek(3);//将指针调到角标为3的位置
    //保存指针3后面的所有数据到StringBuilder中
    StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
    byte[] buffer = new byte[20];
    int len;
    while((len = raf1.read(buffer)) != -1){
        builder.append(new String(buffer,0,len)) ;
    }
    //调回指针，写入“xyz”
    raf1.seek(3);
    raf1.write("xyz".getBytes());
  
    //将StringBuilder中的数据写入到文件中
    raf1.write(builder.toString().getBytes());
  
    raf1.close();
  
    //思考：将StringBuilder替换为ByteArrayOutputStream
  }
  

  �

NIO

NIO.2

�