Java_24_IO流_1

输入（input）：

读取外部数据（硬盘、磁盘、光盘等存储设备的数据）到程序中（内存）中。

输出（output）：

将程序中的数据（内存）输入到硬盘光盘等存储设备中。

流的分类

1.按操作数据单位不同分为：字节流（8 bit），字符流（16 bit）
字节流 ——》 视频、图片
字符流 ——》 文本
2.按数据流的流向不同分为：输入流（Reader）和输出流（Writer）
3.按流的角色的不同分为：节点流和处理流

io流

流的分类

IO流体系

需要重点学的是就是蓝框的

io流体系

一、FileReader使用

1.实例化File类的对象，指明要操作的文件
2.提供具体的流
3.数据的读入
4.流的关闭操作

注意事项：

1.read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
2.异常的处理：为了流资源一定可以执行关闭操作，需要使用try-catch-finally
3.读入的文件必须存在，否则会报错

package StringChuLi;

import org.junit.Test;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/**
 * 一、流的分类
 * 1.操作数据单位：字节流、字符流
 * 2.数据的流向：输入流、输出流
 * 3.流的角色：字节流、处理流
 *
 * 二、流的体系结构
 * 抽象基类          节点流（文件流）       缓冲流（处理流的一种）
 * InputStream      FileInputStream     BufferInputStream
 * OutputStream     FileOutputStream    BufferOutputStream
 * Reader           FileReader          BufferReader
 * Writer           FileWriter          BufferWriter
 *
 *
 * @Author: GenGen
 * @Description: 6Ge
 * @DateTime: 2022/4/8 21:22
 **/
public class IO_Dome01 {
    public static void main(String[] args) {
        File file = new File("D:\\三年之约\\holle.txt");
    }
    @Test
    public void testFileReader() {
        /*
        1.read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
        2.异常的处理：为了流资源一定可以执行关闭操作，需要使用try-catch-finally
        3.读入的文件必须存在，否则会报错
         */

        // 这里先声明FileReader，才可以在下面finally中才可以使用close()
        FileReader fr  = null;
        try {
            // 1、实例化File类的对象，指明要操作的文件
            File file = new File("D:\\三年之约\\holle.txt");
            // 2、提供具体的流
            fr = new FileReader(file);
            int data;
            // 3、数据的读入
            data = fr.read();
            while (data != -1) {
                System.out.print((char)data);
                data = fr.read();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            /*
            判断fr是否实例化
             */
            if (fr != null){
                try {
                    // 4、流的关闭操作
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

升级写法

用一个char[] 数组去接收读入的数据，效率比老方法快也是推荐写法。

//对read（）操作的升级：使用read的重载方法
        @Test
        public void testFileReader1(){
            FileReader fr = null;
            try {
                //1.File类的实例化
                File file = new File("D:\\三年之约\\holle.txt");
                //2.FileReader流的实例化
                fr = new FileReader(file);
                //3，读入的操作
                char[] chars = new char[5];
                int len;
                while ((len = fr.read(chars)) != -1){

                    // 方式一：
                    //错误写法
                    /*
                    for (int i = 0; i < chars.length; i++) {
                        System.out.print(chars[i]);
                    }
                     */

                    //正确写法
                    /*for (int i = 0; i < len; i++) {
                    /    System.out.print(chars[i]);
                    }*/

                    // 方式二：
                    // 错误写法
                    /* String str = new String(chars);
                    System.out.print(str);
                    */
                    //正确写法
                    String str = new String(chars,0,len);
                    System.out.print(str);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fr != null) {
                    try {
                        //4.资源的关闭
                        fr.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
}