Java：IO流【简单输入流输出流】

1.1 IO流概述

IO流的作用主要是用来处理设备之间的数据传输。数据的传输，可以看作是一种数据的流动，按照流动的方向，以内存为基准，分为输入Input和输出Output，即流向内存是输入流，流出内存是输出流。
Java中I/O操作主要是指使用java.io包下的内从，进行输入、输出操作。输入也叫做读取数据，输出也叫做写出数据。

1.2 IO流分类

根据数据的流向分为：输入流和输出流。

• 输入流 ：把数据从 其他设备 上读取到 内存 中的流。
• 输出流 ：把数据从 内存 中写出到 其他设备 上的流。

格局数据的类型分为：字节流和字符流。

• 字节流 ：以字节为单位，读写数据的流。
• 字符流 ：以字符为单位，读写数据的流。
  

字节流

2.1 一切皆为字节

一切文件数据（文本、图片、视频）在存储时，都是以二妗子数字的形式保存，都一个一个的字节，传输时同样如此。所以，字节流可以传输任意文件数据。

2.2 字节输出流【OutputStream】

java.io.OutputStream: 字节输出流
    此抽象类是表示输出字节流的所有类的超类

定义了一些子类共性的成员方法：
    - public void close()   :   关闭此输出流并释放与此流相关联的任何系统资源
    - public void flush()   :   刷新此输出流并强制任何缓冲的输出字节被写出
    - public void write(byte[] b)   :   将 b.length 字节从指定的字节数组写入此输出流
    - public void write(byte[] b, int off, int len) :   从指定的字节数组写入 len 字节，从偏移量 off开始输出到此输出流
    - public abstract void  write(int b)    :   将指定的字节输出流

java.io.FileOutputStream extends OutputStream
FileOutputStream    :   文件字节输出流
作用：把内存中的数据写入到硬盘的文件中

构造方法：
    FileOutputStream(String name)   创建一个向具有指定名称的文件中写入数据的输出文件流
    FileOutputStream(File file)     创建一个向指定File对象表示的文件中写入数据的文件输出流
    参数：写入数据的目的
        String nmae :   目的地是一个文件的路径
        File file   :   目的地是一个文件
    构造方法的作用：
        1. 创建一个FileOutputStream 对象
        2. 会根据构造方法中传递的文件/文件路径，创建一个空的文件
        3. 会把FileOutputStream 对象指向创建好的文件

写入数据的原理（内存 ---> 硬盘）
    java程序 -->  JVM(Java虚拟机) ---> OS(操作系统) ---> OS调用写数据的方法 ---> 把数据写入到文件中

字节输出流的使用步骤（重点）：
    1. 创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
    2. 调用FileOutputStream对象中的方法write，把数据写入到文件中
    3. 释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提供程序的效率）

public class _01Output {
    public static void main(String[] args) throws IOException {
        // 1. 创建FileOutputStream对象
        FileOutputStream fos = new FileOutputStream("src\\heima\\IO\\OutputStream\\b.txt");
        // 2. 调用方法write，把数据写入到文件中
//        fos.write(97);
//        fos.write(98);
        // 3. 释放资源
        // 在文件中显示100，写3个字节
        fos.write(49);
        fos.write(48);
        fos.write(48);
        /*
            - public void write(byte[] b)   :   将 b.length 字节从指定的字节数组写入此输出流
            一次写多个字节：
                如果写的第一个字节是整数（0-127），那么显示的时候会查询ASCII表
                如果写的第一个字节是负数，那么第一个字节会和第二个字节一起组成一个中文显示，查询系统默认码表（GBK）
         */
        byte[] b = {65,66,67,68,69};
//        byte[] b = {-65,66,-67,68,69};
        fos.write(b);
        /*
            public void write(byte[] b, int off, int len) :   从指定的字节数组写入 len 字节，从偏移量 off开始输出到此输出流
            off: 数组的开始索引
            len: 写几个字节
         */
        fos.write(b,1,2);

        /*
            写入字符的方法，可以使用String类中的方法把字符串，转换为字节数组
                byte[] getBytes()   把字符床转换为字节数组
        */
        byte[] b1 = "亚洲".getBytes();
        System.out.println(Arrays.toString(b1));
        fos.write(b1);

        /*
            追加写/续写：使用两个参数的构造方法
            FileOutputStream(String name, boolean append)   创建一个向具有指定 name 的文件中写入数据的输出文件流
            FileOutputStream(File file, boolean append)     创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
            参数：
                String name, File file : 写入数据的目的地
                boolean append: 追加写开关
                    true：创建对象不会覆盖源文件，继续在文件的末尾追加写数据
                    false：创建一个新文件，覆盖源文件
            写换行：写换行符号
                windows:\r\n
                linux:/n
                mac:/r
         */
        FileOutputStream fos1 = new FileOutputStream("src\\heima\\IO\\OutputStream\\c.txt");
        for (int i = 0; i < 10; i++) {
            fos1.write("亚洲，帅".getBytes());
            fos1.write("\r\n".getBytes());
        }
        fos.close();
    }
}

2.3 字节输入流【InputStream】

java.io.InputStream 字节输入流
此抽象类是表示字节输入流的所有类的超类。

定义了所有子类共性的方法
    int read() 从输入流中读取数据的下一个字节
    int read(byte[] b) 从输入流中读取一定数量的字节，并将其春初在缓冲区数组 b 中
    void close() 关闭此输入流并释放与该流关联的所有系统资源。

java.io.FileInputStream extends InputStream
FileInputStream: 文件字节输入流
作用： 把硬盘文件中的数据，读取到内存中使用
构造方法；
    FileInputStream(String name)
    FileInputStream(File file)
    参数: 读取文件的数据源
        String name : 文件的路径
        File file : 文件
    构造方法的作用：
        1. 会构建一个FileInputStream 对象
        2. 会把FileInputStream对象指定构造方法中要读取的文件

读取数据的原理（硬盘--->内存）
    java程序 --> JVM --> OS --> OS读取数据的方法 --> 读取文件

字节输入流的使用步骤：
    1. 创建FileInputStream对象，构造方法中绑定要读取的数据源
    2. 使用FileInputStream对象中的方法read，读取文件
    3. 释放资源

public class _02Input {
    public static void main(String[] args) throws IOException {
        // 1. 创建FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("src\\heima\\IO\\c.txt");
        int len = 0;    // 记录读取到的单个字节
        while((len = fis.read()) != -1){
            System.out.println((char)len);    // a b c
        }

        /*
            一次读取多个字节
            int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。
            方法返回的int值是每次读取的有效字节个数
         */

        FileInputStream fis1 = new FileInputStream("src\\heima\\IO\\c.txt");
        byte[] bytes = new byte[1024];
        int len1 = 0;
        while ((len1 = fis1.read(bytes)) != -1){
            // String(byte[], int offset, int length) 把字节数组的一部分转换为字符串 offset: 数组的开始索引 length：转换的字节个数
            System.out.println(new String(bytes,0,len1));
            System.out.println(len1);
        }
        fis.close();
        fis1.close();
    }
}

字符流

3.1 字符输入流【Reader】

java.io.Reader: 字符输入流，是字符输入流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类
共性的成员方法：
    int read() 读取单个字符并返回
    int read(char[] cbuf) 一次读取多个字符，将字符读入数组
    void close() 关闭该流并释放与之关联的所有资源

java.io.FileReader extends InputStreamReader extends Reader
FileReader : 文件字符输入流
作用：把硬盘文件中的数据以字符的方式读取到内存中

构造方法：
    FileReader(String fileName)
    FileReader(File file)
    参数：读取文件的数据源
        String fileName: 文件的路径
        File file ：一个文件

字符输入流使用步骤：
    1. 创建FileReader对象，构造方法中绑定要读取的数据源
    2. 使用FileReader对象中的方法read读取文件
    3. 释放资源

public class _04Reader {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("src\\heima\\IO\\c.txt");
//        int len = 0;
//        while ((len =fr.read()) != -1){
//            System.out.print((char)len);
//        }
        char[] chars = new char[1024];
        int len = 0;
        while ((len = fr.read(chars)) != -1){
            System.out.println(len);
            System.out.println(new String(chars));
        }
    }
}

3.2 字符输出流【Writer】

java.io.Writer: 字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类

共性的成员方法：
    - void write(int c) 写入单个字符
    - void write(char[] cbuf) 写入字符数组
    - abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分，off数组的开始索引，len写的字符个数
    - void write(String str) 写入字符串
    - void flush() 刷新该流的缓冲
    - void close() 关闭此流，但要先刷新它
    flush方法和close方法的区别
        - flush ：刷新缓冲区，流对象可以继续使用。
        - close:  先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

java.io.FileWriter extends OutputStreamWriter extends Writer
FileWriter 文件字符输出流
作用：把内存中字符数组写入文件中
构造方法：
    FileWriter(File file) 根据给定的File对象构造一个FileWriter对象
    FileWriter(String fileName) 根据给定的文件名构造一个FileWriter对象

使用：
    1. 创建
    2. 使用：write方法，把数组写入到内存缓冲区中（字符转换为字节的过程）
    3. 刷新：把内存缓冲区的数据，刷新到文件中
    4. 释放资源（会先把内存缓存区中的数据刷新到文件中）

public class _05Writer {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("src\\heima\\IO\\d.txt");
//        FileWriter fw = new FileWriter("src\\heima\\IO\\d.txt",true); // 追加和续写

        fw.write(99);
        fw.flush();

        char[] cs = {'a','b','c','d','e'};
        fw.write(cs);
        fw.write("亚洲风Style");
        fw.write("亚洲风Style",2,3);
        fw.close();
    }
}

4. IO异常处理

JDK7的新特性
在try的后边可以增加一个(),在括号中可以定义流对象
那么这个流对象的作用域就在try中有效
try中的代码执行完毕,会自动把流对象释放,不用写finally
格式:
    try(定义流对象;定义流对象....){
        可能会产出异常的代码
    }catch(异常类变量 变量名){
        异常的处理逻辑
    }

JDK9新特性
try的前边可以定义流对象
在try后边的()中可以直接引入流对象的名称(变量名)
在try代码执行完毕之后,流对象也可以释放掉,不用写finally
格式:
    A a = new A();
    B b = new B();
    try(a,b){
        可能会产出异常的代码
    }catch(异常类变量 变量名){
        异常的处理逻辑
    }

public class _06TryCatch {
    public static void main(String[] args) throws IOException {
//        FileInputStream fis = new FileInputStream("src\\heima\\IO\\2.png");
//        FileOutputStream fos = new FileOutputStream("src\\heima\\IO\\4.png");
//        try(fis;fos){
//            int len = 0;
//            byte[] bytes = new byte[1024];
//            while ((len = fis.read(bytes)) != -1){
//                fos.write(bytes);
//            }
//        }catch(IOException e){
//            System.out.println(e);
//        }
        try(        FileInputStream fis = new FileInputStream("src\\heima\\IO\\2.png");
                    FileOutputStream fos = new FileOutputStream("src\\heima\\IO\\4.png");){
            int len = 0;
            byte[] bytes = new byte[1024];
            while ((len = fis.read(bytes)) != -1){
                fos.write(bytes);
            }
        }catch(IOException e){
            System.out.println(e);
        }
    }
}

5. Properties类

java.util.Properties集合 extends Hashtable<k,v> implements Map<k,v>
Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载
Properties 集合是一个唯一和IO流相结合的集合
    可以使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
    可以使用Properties集合中的方法load，把硬盘中保存的文件（键值对），读取到集合中使用
属性列表中每个键及其对应值都是一个字符串。
    Properties集合是一个双列集合，key和value默认都是字符串

public class _07Properties {
    public static void main(String[] args) throws IOException {
//        show01();
//        show02();
        show03();
    }
    /*
    可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用
    void load(InputStream inStream)
    void load(Reader reader)
    参数:
        InputStream inStream:字节输入流,不能读取含有中文的键值对
        Reader reader:字符输入流,能读取含有中文的键值对
    使用步骤:
        1.创建Properties集合对象
        2.使用Properties集合对象中的方法load读取保存键值对的文件
        3.遍历Properties集合
    注意:
        1.存储键值对的文件中,键与值默认的连接符号可以使用=,空格(其他符号)
        2.存储键值对的文件中,可以使用#进行注释,被注释的键值对不会再被读取
        3.存储键值对的文件中,键与值默认都是字符串,不用再加引号
 */
    private static void show03() throws IOException {
        Properties prop = new Properties();
        prop.load(new FileReader("src\\heima\\IO\\prop.txt"));
        Set<String> set = prop.stringPropertyNames();
        for (String str :
                set) {
            String value = prop.getProperty(str);
            System.out.println(str + " = " + value);
        }
    }

    /*
        可以使用Properties集合中的方法store , 把集合中的临时数据，持久化写入到硬盘中存储
        void store(OutputStream out, String comments)
        void store(Writer writer, String comments)
        参数:
            OutputStream out:字节输出流， 不能写入中文
            Writer writer:字符输出流,可以写中文
            String comments:注释,用来解释说明保存的文件是做什么用的
                    不能使用中文,会产生乱码,默认是Unicode编码
                    一般使用""空字符串
     */
    private static void show02() throws IOException {
        Properties prop = new Properties();
        prop.setProperty("Asia","170");
        prop.setProperty("亚洲","172");
        prop.setProperty("洛璃","171");

        FileWriter fw = new FileWriter("src\\heima\\IO\\prop.txt");
        prop.store(fw,"Save data");
    }

    /*
        使用Properties集合存储数据，遍历取出Properties集合中的数组
        Properties集合有一个双列集合，Key和value默认都是字符串
        Properties集合有一些操作字符串的特有方法
            Object setProperties(String key, String value) 调用 Hashtable的方法 put
            String getProperties(String key) 通过key找到value值，此方法相当于Map集合中的get(key)方法
            Set<String> stringPropertiesNames() 返回此属性列表中的键值，其中该键及其对应值是字符串，此方法相当于Map集合中的keySet方法
     */
    private static void show01() {
        Properties prop = new Properties();
        prop.setProperty("Asia","170");
        prop.setProperty("Asia1","172");
        prop.setProperty("Asia2","171");
        Set<String> set = prop.stringPropertyNames();

        for (String str :
                set) {
            String value = prop.getProperty(str);
            System.out.println(str + "=" + value);
        }
    }
}