一、基础概念

1、IO 流 -->   I  input     O  output   Stream
2、IO流  -->  输入输出流     所谓的入和出都是相应于内存的。
     txt  -->   java(JVM ，内存)                            输入流
     java代码  String a = "hello world"   -->  txt    输出流
3、按照传输的数据类型 分为 字节流 和 字符流
     字节 -->  byte  = 8 bit    -->  电影、音乐, 图片 -->   每一个电影以及音乐缺少一点点都可以导致       整部电影播放不了，所以需要细粒度的传输。

     可以表示英文的，英文的字符可以用一个字节表示
     字符  --> char   -->  文本的传输

常用编码：  

ASCII码：
   一个英文字母（不分大小写）占一个字节的空间，一个中文汉字占两个字节的空间。
   一个二进制数字序列，在计算机中作为一个数字单元，一般为8位二进制数，换算为十进制。最  小值0，最大值255。如一个ASCII码就是一个字节。
UTF-8编码：
    一个英文字符等于一个字节，一个中文（含繁体）等于三个字节。
Unicode编码：
    一个英文等于两个字节，一个中文（含繁体）等于两个字节。
符号：
    英文标点占一个字节，中文标点占两个字节。举例：英文句号“.”占1个字节的大小，中文句号      “。”占2个字节的大小。

二、常用流的父类

字节流的两个父类:

     - 字节输入流:InputStream
     - 字节输出流:OutputStream

字符流的两个父类:

     - 字符读入流:Reader
     - 字符写出流:Writer

IO流使⽤的注意事项：

     - 四大父类流，都是抽象类， 都不能实例化对象。需要借助他们的子类实现数据的读写。
     - 流对象一旦实例化完成， 将建立一个程序与文件之间的连接。 这个连接会持有这个文件。 如果这个连接不断， 此时这个文件就是一个被使用中的状态， 此时将无法对这个文件进行其他的操作，例如删除。
     - 一个流在使用完成之后， 切记！ 一定要进行流的关闭。

三、知识预备

1、绝对路径和相对路径

绝对路径：就是真实的路径,是计算机中完整路径,必须准确,否则不能找到,起点是系统的根目录,也就是各个盘符，例如：C:/Users/a1394/Desktop/OneDrive

相对路径：绝对路径是一种简化版的路径,以当前文件,活动窗口目录为根目录,进行向上或者向下切入。

2、不同操作系统中分隔符区别

目录分隔符： Windows \       Linux /

路径分隔符： Windows ；    Linux :

3、常用类File

File常用的构造方法：

// 构造方法一：通过一个参数创建file

File file = new File("C:\\Users\\User\\Desktop\\a.txt");
System.out.println(file.exists());

File file2 = new File("C:\\Users\\User\\Desktop\\b.txt");
System.out.println(file2.exists());

// 构造方法二：根据两个参数决定一个路径
File file3 = new File("C:\\Users\\User\\Desktop","a.txt");

// 文件夹也可以是File类的实例化对象
File director = new File("C:\\Users\\User\\Desktop");
File file4 = new File(director, "a.txt");

File类的常用方法：

package com.day14;

import java.io.File;
import java.io.IOException;
import java.util.Date;

/**
 * @Author
 * @Description TODO
 * @Date 2022/3/18 10:15
 * @Version 1.0
 */
public class Demo03 {
    public static void main(String[] args) throws IOException {
        //
        File file = new File("D:\\桌面文件\\银行系统.txt");
        System.out.println(file.exists());  //判断⼀个⽂件(⽬录)是否存在。
        System.out.println(file.isFile());  //判断⼀个路径指定的是否是⼀个⽂件。
        System.out.println(file.isDirectory()); //判断⼀个路径指定的是否是⼀个⽂件夹。
        System.out.println(file.canExecute());  //判断⼀个⽂件(⽬录)是否是可执⾏的。
        System.out.println(file.canRead());   //判断⼀个⽂件(⽬录)是否是可读的。
        System.out.println(file.canWrite());  //判断⼀个⽂件(⽬录)是否是可写的。
        System.out.println(file.isHidden());  //判断⼀个⽂件(⽬录)是否是隐藏的。
        System.out.println(file.getAbsolutePath());  //获取⼀个⽂件(⽬录)的路径。
        System.out.println(file.getName());  //获取⼀个⽂件(⽬录)的⽬录。
        System.out.println(file.getParent());  //获取⼀个⽂件(⽬录)的⽗级路径(字符串)。
        System.out.println(file.lastModified()); //获取⼀个⽂件(⽬录)上次修改的时间。

        //获取⽂件上次修改的时间(时间戳)--是最后修改的时间,不是查看的时间   
        long time = file.lastModified();
        Date date = new Date(time);
        System.out.println(date);

        File file1 = new File("D:\\桌面文件\\a.txt");
        if (!file1.exists()){
            file1.createNewFile();
        }

        file1.delete();
    }
}

四、字节流操作

1、输入字节流：

每次读取一个字节的方式，效率较低

        //这个地方a.txt    
        // 指的是classes文件夹  表现形式就是 项目目录下
        try(InputStream fileInputStream = new FileInputStream("a.txt")){

            // 每次读取一个字节  -->  这个字节可以读取英文的字符
            //  a -->  占两个字节是错误的，占一个
            /**
             *   read()    字节流每次读取一个字节
             *             如果读取到-1 说明结束了
             */
            /*int read = fileInputStream.read();
            System.out.println((char)read);
            int read2 = fileInputStream.read();
            System.out.println((char)read2);
            int read3 = fileInputStream.read();
            System.out.println((char)read3);
            int read4 = fileInputStream.read();
            System.out.println((char)read4);
            int read5 = fileInputStream.read();
            System.out.println((char)read5);
            int read6 = fileInputStream.read();
            System.out.println(read6);

            System.out.println((char)-1);
            System.out.println((char)-2);*/

            /**
             *  使用循环的方式获取字节流
             *
             */
            int a ;
            while( (a = fileInputStream.read()) != -1){
                System.out.print((char)a);
            }

        }catch (Exception e){
            e.printStackTrace();
        }

2、每次读取一个数组的长度，效率较高

// 这个地方  a.txt    // 指的是classes文件夹  表现形式就是 项目目录下
        try(InputStream fileInputStream = new FileInputStream("a.txt")){

            // 拉煤的车，数组的长度就是 车的载重
            byte[] bytes = new byte[2];
           /* // 这个方法指的是使用一个数组去承载想要读取的数据
            fileInputStream.read(bytes);

            // 现在有一个byte数组，里面有数据，怎么转String
            System.out.println(new String(bytes));
            fileInputStream.read(bytes);
            System.out.println(new String(bytes));

            // read 通过数组读取，读取的个数是返回值。
            fileInputStream.read(bytes);
            System.out.println(new String(bytes, 0, 1));
            //System.out.println(new String(bytes));*/
            int num;
            while( (num = fileInputStream.read(bytes)) != -1){
                System.out.print(new String(bytes, 0, num));
            }

        }catch (Exception e){
            e.printStackTrace();
        }

3、字节输出流：

每次写一个字节

try (OutputStream outputStream = new FileOutputStream("C:\\Users\\User\\Desktop\\b.txt")) {

            String str = "HelloWorld";
            byte[] bytes = str.getBytes();
            // outputStream 有一个方法，每次写一个字节
            for (byte b:bytes) {
                outputStream.write(b);
            }


        } catch (Exception e) {
            e.printStackTrace();
        }

4、拷贝功能

 File file = new File("C:\\Users\\User\\Pictures\\mmexport1647173350471.jpg");
        String name = file.getName();
        try(
                InputStream inputStream = new FileInputStream(file);
                FileOutputStream outputStream = new FileOutputStream("D:\\"+name)
        ){
            byte[] arr =new byte[3];
            int num ;
            while((num = inputStream.read(arr)) != -1){
                outputStream.write(arr,0,num);
            }

        }catch (Exception e){
            e.printStackTrace();
        }

五、字符流操作

1、读取文本内容：

 try(Reader reader = new FileReader("C:\\Users\\User\\Desktop\\b.txt")){

            char[] arr = new char[8];
            int num;
            while((num =reader.read(arr)) != -1){
                String s = new String(arr, 0, num);
                System.out.print(s);
            }

        }catch (Exception e){
            e.printStackTrace();
        }

2、写入文本内容：

try (Writer writer = new FileWriter("C:\\Users\\User\\Desktop\\c.txt",true)) {

            String str = "HelloWorld";
            char[] bytes = str.toCharArray();
            // outputStream 有一个方法，每次写一个字节
            for (char b:bytes) {
                writer.write(b);
            }
            writer.write('\n');
            // 强制将缓存中的数据刷入到文件中
            writer.flush();

        } catch (Exception e) {
            e.printStackTrace();
        }

3、尝试使用字节流去拷贝图片

package com.day14;

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

/**
 * @Author
 * @Description TODO
 * @Date 2022/3/18 14:49
 * @Version 1.0
 */
public class Demo09 {
    public static void main(String[] args) {

        try(FileInputStream fileInputStream = new FileInputStream("E:\\壁纸\\永劫无间-宁红叶.png");
            final FileOutputStream fileOutputStream = new FileOutputStream("D:\\3.jpg");
        ){
            byte[] arr = new byte[1024];
            int num;
            while ((num = fileInputStream.read(arr))!= -1){
                fileOutputStream.write(arr,0,num);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

拷贝成功：

 4、尝试使用字符流去拷贝图片，发现可以拷贝，但是打不开，拷贝失败：

File file = new File("C:\\Users\\User\\Pictures\\mmexport1640224454506.jpg.jpg");
        String name = file.getName();
        try(
                FileReader inputStream = new FileReader(file);
                FileWriter outputStream = new FileWriter("D:\\"+name)
        ){
            char[] arr =new char[10];
            int num ;
            while((num = inputStream.read(arr)) != -1){
                outputStream.write(arr,0,num);
            }
            outputStream.flush();

        }catch (Exception e){
            e.printStackTrace();
        }