JavaIO流

IO流概述

IO（Input\Output）用于处理设备之间的数据的传输。在Java中以流的方式对数据的输入和输出进行管理。在Java.io包中提供了许多”流“类和接口来进行对不同数据的操作。

流的分类

1、按操作数据的单位可分为字节流 和字符流
2、按数据的流向划分为输入流、输出流
3、按照流的角色划分为节点流、处理流

流的体系结构

抽象基类	节点流（文件流） \ 缓冲流（处理流的一种）
InputStream	FileInputStream \ BufferedInputStream
OutputStream	FileOutputStream \BufferedOutputStream
Reader	FileReader \ BufferedReader
Writer	FileWriter \ BufferedWriter

节点流

FileReader

从指定文件读取数据并打印

 public void Test01() {
        FileReader f2 = null;
        try {
//        1、实例化File类的对象，指明要操作的文件
            File file = new File("hi.txt");
//        2、提供具体的流
            f2 = new FileReader(file);
//        3数据的读入
            //read()返回读入的一个字节，若无返回-1
            int data;
            while((data= f2.read())!=-1){
                System.out.println((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
        //  流的关闭操作
        try {
            if(f2!=null) //防止文件没有创建就结束
            f2.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
     }
    }

1、read()返回读入的一个字节，若无返回-1
2、异常的处理：为了保证资源一定可以执行关闭操作。需要try-catch-finally
3、读入的文件一定要存在，不然会报错FileNotFoundException

FileWriter

将数据从内存中写到硬盘

  public void Test03() throws IOException {
        FileWriter f2 = null;
        try {
//      1、创建File类对象，指明文件
            File file = new File("hi.txt");
//      2、提供要操作的流
            f2 = new FileWriter(file,true);
//      3、具体操作
            f2.write("I hava a apple\n");
            f2.write("I hava a iPhone");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (f2!=null) {
                //      4、关闭流
                try {
                    f2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

输出数据，指定文件可以不存在，会自动创建。
使用的流的构造器：
        FileWriter(file,false)/ FileWriter(file):会对原有的文件覆盖
        FileWriter(file,true)：不会覆盖原有的文件，在原有文件基础上追加内容

FileInputStream FileOutputStream

实现图片的复制

  public void Test01()  {
        FileInputStream f1 = null;
        FileOutputStream f2 = null;
        try {
//        1、实例化File类对象
            File file = new File("屏幕截图.png");
            File file1 = new File("屏幕截图1.png");
//        2、提供操作流
            f1 = new FileInputStream(file);
            f2 = new FileOutputStream(file1);
//        3、具体操作 复制过程
            byte[] bytes = new byte[5];
            int len;
            while((len=f1.read(bytes))!=-1){
                f2.write(bytes,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
 //        4、关闭流
            if(f1!=null){
                try {
                    f1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (f2!=null) {
                try {
                    f2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

该流常用于非文本文件，如视频、图片。

处理流

转换流

• 转换流——实现字节流和字符流的转换（属于字符流）
  InputStreamReader:将一个字节的输入流转换为字符的输入流
  OutputStreamWriter:将一个字符的输出流转换为字节的输出流
• 实现字节流和字符流的转换
• 编码：字节、字节数组——>字符数组、字符串
  解码：字符、字符数组——>字节、字节数组

  public void Test01(){
        InputStreamReader i1 = null;//指定字符集
        try {
            //输入流（字节流-->字符流）
            FileInputStream f1 = new FileInputStream("doclan.txt");
//        InputStreamReader f2 = new InputStreamReader(f1);  使用系统默认的字符集
//            实现字节流->字符流
            i1 = new InputStreamReader(f1, StandardCharsets.UTF_8);//指定字符集，但字符集必须与文件字符集一致
            char[] chars = new char[20];
            int len;
            while((len=i1.read(chars))!=-1){
                String s = new String(chars, 0, len);
                System.out.println(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if ( i1!=null){
                try {
                    i1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

缓冲流

• 缓冲流：
  BufferedInputStream
  BufferedOutputStream
  BufferedReader
  BufferedWriter
• 提高数据流读取、写入的速度
• 处理流就是“套接”在已有流的基础上

//    用缓冲流提高文件复制速度
//      BufferedInputSystem
//      BufferedOutputSystem
    @Test
    public void Test01(){
        BufferedInputStream b1 = null;
        BufferedOutputStream b2 = null;
        try {
//      1、  造目标文件
            File file = new File("测试.png");
            File file1 = new File("测试2.png");
//      2、造流
//        2.1造节点流
            FileInputStream f1 = new FileInputStream(file);
            FileOutputStream f2 = new FileOutputStream(file1);
//        2.2造处理流
            b1 = new BufferedInputStream(f1);
            b2 = new BufferedOutputStream(f2);
//        3、复制操作
            byte[] bytes = new byte[5];
            int len;
            while((len=b1.read(bytes))!=-1){
                b2.write(bytes,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally
//        4、关闭流
        /*
        要求：先关闭外层流，在关闭内层流
        说明：关闭外层流的同时，内层流也会自动关闭。
         */
        {
            if (b1!=null){
                try {
                    b1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (b2!=null){
                try {
                    b2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }