day20---流的读写，字节流，缓冲流，对象流，字符流

流的分类

按方向【重点】

• 输入流(Input)
• 输出流(Output)

按单位

• 字节流

  操作的是byte

• 字符流

  操作的是char

按功能

• 节点流
• 缓冲流

流的快速入门

1. 流的打开与关闭

        try {
            // 读一个文件，将此文件标识为一个InputStream对象
            // 输入一张图片
            // /Users/LEAF/Pictures/搞笑图片/AE865FF6-8454-40F9-839F-7FD10BE94B5F.gif
            InputStream is = new FileInputStream("/Users/LEAF/Pictures/搞笑图片/AE865FF6-8454-40F9-839F-7FD10BE94B5F.gif");

            // 写一个文件，将此文件标识为一个OutputStream对象
            // 输出
            // /Users/LEAF/Downloads/J2103-0820/copy.gif
            OutputStream os = new FileOutputStream("/Users/LEAF/Downloads/J2103-0820/copy.gif");
            // 释放资源
            is.close();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

2. 流的读与写

            byte[] buff = new byte[512];
            int len = 0;
            while (true) {
                // 读到的字节，都在buff里
                // 读到了多少个，存到len变量里
                // 读，一次读512byte
                len = is.read(buff);

                // 如果read的返回值为-1，代表读到了文件尾了，已经没有任何东西能读了
                if (len == -1) {
                    break;
                }

                // 写，一次写len 个 byte
                os.write(buff, 0, len);
            }

字节缓冲流

用于提升对系统磁盘io的使用效率
使用字节缓冲流，复制粘贴一张图片

创建缓冲流对象

            // 源: /Users/LEAF/Pictures/搞笑图片/47667F5C-11D5-4E68-806C-03D3CF76493C.gif
            InputStream is = new FileInputStream("/Users/LEAF/Pictures/搞笑图片/47667F5C-11D5-4E68-806C-03D3CF76493C.gif");

            // 目标: /Users/LEAF/Downloads/J2103-0820/copy2.gif
            OutputStream os = new FileOutputStream("/Users/LEAF/Downloads/J2103-0820/copy2.gif");

            // 输入缓冲流，能够提高读效率
            BufferedInputStream bis = new BufferedInputStream(is);

            // 输出缓冲流，能够提高写效率
            BufferedOutputStream bos = new BufferedOutputStream(os);

            // ...

            bos.close();
            bis.close();
            os.close();
            is.close();

对象字节流

创建User类

// 序列化: 将一个对象输出到流中
// 反序列化: 将流中输入到对象中
public class User implements Serializable {
    private String username;
    private String password;
    private String mobile;

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", mobile='" + mobile + '\'' +
                '}';
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }
}

对象输出

将一个对象，存到磁盘中

public class ObjectOPractice {
    public static void main(String[] args) {
        try {
            User user = new User();
            user.setUsername("张三");
            user.setPassword("123456");
            user.setMobile("13412341234");

            OutputStream os = new FileOutputStream("/Users/LEAF/Downloads/J2103-0820/user.obj");

            // 对象输出流，在创建(构造器)时，需要传入一个构造参数
            // 这个参数，表示的是对象，存到哪
            ObjectOutputStream bos = new ObjectOutputStream(os);

            bos.writeObject(user);

            bos.close();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对象输入

将磁盘中的文件，读到对象中

public class ObjectIPractice {
    public static void main(String[] args) {
        try {
            // 读一个文件
            InputStream is = new FileInputStream("/Users/LEAF/Downloads/J2103-0820/user.obj");

            // 将文件里的内容，创建出一个User对象
            ObjectInputStream ois = new ObjectInputStream(is);

            Object o = ois.readObject();

            System.out.println(o);

            ois.close();
            is.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

乱码

编码集
CharacterEncoding

字符流

字符输出流

public class FileOPractice {
    public static void main(String[] args) {
        try {
            // 创建字符输出流对象
            Writer writer = new FileWriter("/Users/LEAF/Downloads/J2103-0820/user.txt");

            // 输出内容
            String out = "abcdefg";
            char[] chars = out.toCharArray();

            // 写入
            writer.write(chars);

            // 关闭资源
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符输入流

public class FileIPractice {
    public static void main(String[] args) {
        try {
            Reader reader = new FileReader("/Users/LEAF/Downloads/J2103-0820/user.txt");
            StringBuffer sb = new StringBuffer();

            char[] buffer = new char[512];
            while (true) {
                int len = reader.read(buffer);

                if (len == -1) {
                    break;
                }

                sb.append(buffer, 0, len);
            }

            System.out.println(sb);

            reader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

总结

• InputStream

• OutputStream

• FileInputStream

• FileOutputStream

• BufferedInputStream

• BufferedOutputStream

• ObjectInputStream

• ObjectOutputStream

• Serializeble

• Reader

• Writer

• FileReader

• FileWriter