Java自学记录--IO流

 * I：输入，读取 硬盘到内存
 * O：输出，写入 内存写入硬盘
 * 流：字符，字节，1个字符=2个字节=8个二进制位
 * 顶层父类： 字节输入InputStream ；字节输出OutputStream；字符输入Reader ;字符输出Writer；

 * 在try catch 方法中，try后添加一个（），括号内定义流对象，可在作用域内生效，执行完毕后自动释放流对象
 * 格式：
 *      try(定义流对象){
 *          产生异常的代码
 *      }catch(异常类变量 变量名）
 *      {
 *          异常处理逻辑
 *      }

1.InputStream字节输入流

 * 字节输入流java.io.InputStream，定义了所有子类共性方法。
 * 方法
 *     int read()读取字节
 *     int read(byte[] b)读取一定数量的字节，存储在缓冲数组b中
 *          数组起缓冲作用，实际仍然是逐一读取，只是保存在数组中；长度通常定义为1024的整数倍
 *          int返回读取有效字节数
 * void close()关闭并释放
 *
 * 构造方法
 *      FileInputStream(String name)
 *      FileInputStream(File file)
 *      1，创建FileInputStream对象；
 *      2，将对象指向构造方法中要读读取文件的地址或文件。
 *
 * 使用步骤：
 *     1，创建对象，方法中绑定数据源；
 *     2，read（）方法读取文件；
 *     3，释放资源。
 *
 * 请求路径：JVM--OS
 *
 * 使用字节流读取中文文件：GBK中占用2个字节，UTF-8中占用3个字节

public static void main(String[] args) throws IOException {
        //读取单个数据
        FileInputStream fis = new FileInputStream("src\\IO\\test.txt");
        while (fis.read() != -1)
            System.out.println((char) fis.read());
        fis.close();
        
        //读取多个数据
        byte[] bytes=new byte[1024];
        int len=0;
        while((len=fis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
        fis.close();
    }

字符输入流练习：

* 从已有文件中读取字节，并将该字节写出到另一个文件中
public class InputStreamPrac {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src\\IO\\test.txt");
        FileOutputStream fos = new FileOutputStream("src\\IO\\test1.txt");
        byte[] bytes = new byte[1024];
        int len = 0;
        try {
            if ((len = fis.read(bytes)) != -1)
                fos.write(bytes, 0, len);
        } catch (IOException e) {
            e.printStackTrace();
        }
        fis.close();
        fos.close();
    }
}

2.OutputStream字符输出流：

* java.io.OutputStream 此抽象类表示输出字节流的所有类的超类
 * 定义了一些子类共性的成员方法：
 *      void close() 关闭输出流，释放与此流相关联的任何系统资源
 *      void flush() 刷新输出流，强制任何缓冲的输出字节被写出
 *      void write(byte[] b)将 b.length字节从指定字节数组写入输出流
 *      void write(byte[] b,int off,int len)从指定的字节数组写入len字节，从偏移量off楷书输出到此输出流
 *      abstract void write(int b)将指定的字节输出流
 *
 * FileOutStream extends OutputStream文件字节输出流，把内存中的数据写入文件中。
 * 构造方法：
 *          FileOutputStream（String name）创建一个向具有指定名称的文字中写入数据的文件名。
 *          FileOutputStream（File file）创建一个向指定File对象表示的文件中写入数据的文件输出流。
 *          参数 name file 写入数据的目的地：路径/文件。
 * 构造方法作用：
 *          1创建一个FileOutputStream对象；
 *          2根据构造方法中传递的文件或者文件路径，创建一个空文件；
 *          3吧FileOutputStream对象指向创建好的文件。
 *
 * 字节输出流的使用步骤：
 *         1.创建FileOutputStream对象，方法传入目的地；
 *         2.调用write方法写入文件；
 *         3.释放资源。
 *
 * 追加写、续写：
 *        FileOutputStream（String name，boolean append）
 *        FileOutputStream（File file，boolean appened） boolean 追加写开关
 *
 * 换行符号 \r\n

    public static void main(String[] args) throws IOException {
        FileOutputStream fos=new FileOutputStream("src\\IO\\test.txt",true);
        fos.write(49);
        fos.write(48);
        fos.write(48);
        byte[] a={49,48,48};
        byte[] b="大家好".getBytes();//读取中文
        fos.write("\r\n".getBytes());//换行
        fos.write(a);
        fos.write(b);
        fos.close();
    }

3.Reader字符输入流:

* java.io.Reader字符输入流，顶层父类，抽象类。
* int read（）读取单个字符并返回
* int read (char[] c) 读取多个字符，将字符读入数组
* void close（）关闭字符流
*
* FileReader extends InputStreamReader extends Reader
* FileReader：文件字符输入流
* 吧硬盘文件中的数据以字符的方式读取到内存中。
* 构造方法：
* FileReader（String filename）
* fileReader（File file）
* 创建对象，指向文件。
*
* 步骤：创建对象，绑定数据源；使用read读取；释放资源。

 public static void main(String[] args) throws IOException {
        FileReader fr=new FileReader("src\\IO\\test.txt");
        int len=0;
        while((len=fr.read())!=-1)
            System.out.println((char)len);
        fr.close();
    }

4.Writer字符输出流：

 * 字符输出流： java.io.writer
 *
 * 成员方法：
 *      void write(int c)写入单个字符
 *      void write(char[] c)写入字符数组
 *     (abstract) void write (char[] c,int off.int len)写入部分字符，off代表开始索引，len代表索引开始起的写入长度
 *      void flush()刷新 流的缓冲
 *      void close（）关闭流，需要先刷新
 *
 * java.io.FileWriter extends OutputStreamWriter extends Writer
 * 把内存中字符数据写入文件中。
 *
 * 构造方法：
 *      FileWriter(File file)
 *      FileWriter(String fileName)
 *      创建对象，根据路径创建文件，指向文件
 *
 * 使用步骤：
 *     1.创建对象，方法中绑定目的地；
 *     2.write方法写入内存缓冲区中（字符转换为字节）；
 *     3.使用Filewriter中方法flush()吧内存缓冲区中的数据刷新到文件中。刷新缓冲区，流对象可以继续使用；
 *     4.close()释放资源（将内存缓冲区中数据刷新到文件中）,刷新缓冲区，通知系统释放资源，流对象无法继续使用。
 *
 * 续写与换行
 *      使用两个参数的构造方法
 *      FileWriter(String name ,boolean append) append 续写开关

    public static void main(String[] args) throws IOException {
        FileWriter fw=new FileWriter("src\\IO\\test1.txt",false);
        char[] bytes={97,98,99};
        fw.write(bytes);
        fw.write("\r\n");
        fw.write(bytes);
        fw.flush();//刷新缓冲区，流对象可以继续使用
        fw.close();//刷新缓冲区，通知系统释放资源，流对象无法继续使用
    }