JAVA IO流

需求 : 如何实现读写文件内部的内容?

一， 流 :

数据以先入先出的方式进行流动

相当于管道,作用用来传输数据

数据源-->流-->目的地

1， 流的分类 :

1. 流向分 : 以程序为中心

• 输入流：从文件输入到程序

• 输出流：从程序输送到文件

2. 操作单元 :

• 字节流 : 万能流，图像，音频都可以操作

• 字符流 : 只能操作纯文本文件

3. 功能分 :

• 节点流 : 真实实现读写的

• 功能流(包装流|处理流) : 加强节点流的功能,提高节点流的性能

所有的功能流都需要包裹节点流进行使用

所有的分类相辅相成

二，流

字节流

java.io包

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

数据源 : 文件 | 字节数据

文件 : FileInputStream

字节数据 : ByteArrayInputStream

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

1.FileInputStream : 文件字节输入流

功能分 : 节点流 操作单元分 : 字节流 流向分 : 输入流

从文件中读入数据到程序实现步骤 :

1.与文件建立联系 File->数据源

2.创建文件字节输入流->管道

3.读取数据

4.使用数据

5.关闭资源

 public static void main(String[] args) throws IOException {
        //1.与文件建立联系 File->数据源
        File src = new File("D://AAA/test.txt");
        //2.创建文件字节输入流->管道
        //InputStream is = new FileInputStream(src);
        InputStream is = new FileInputStream("D://AAA/test.txt");
        //3.读取数据
        int len = -1;  //记录每次读到字节数组中数据的个数
        byte[] car = new byte[1024];
        while((len=is.read(car))!=-1){
            //4.使用数据
            System.out.println(new String(car,0,len));
        }
        //5.关闭资源
        is.close();
    }

字符流 :

字符输入流 Reader 用于读取字符流的抽象类。

FileReader : 文件字符输入流

read()

read(char[])

字符输出流 Writer 用于写入字符流的抽象类。

FileWriter 文件字符输入流

void write(char[] cbuf) 写一个字符数组。

abstract void write(char[] cbuf, int off, int len) 写一个字符数组的一部分。

void write(int c) 写一个字符。

void write(String str) 写一个字符串。

void write(String str, int off, int len) 写一个字符串的一部分。

    public static void main(String[] args) throws IOException {
        //1.建立联系
        File src = new File("D://test.txt");
        File dest = new File("D://BBB/test.txt");
        //2.构建流
        Reader rd = new FileReader(src);
        Writer rt = new FileWriter(dest);
        //3.读写
        char[] car = new char[1024];
        int len = -1;
        while((len=rd.read(car))!=-1){
            rt.write(car,0,len);
        }
        //4.刷出
        rt.flush();
        //5.关闭
        rt.close();
        rd.close();
    }

节点流 :

文件字节流 :

文件字节输入流

文件字节输出流

文件字符流

文件字符输入流

文件字符输出流

功能流 : 包裹节点流进行使用

1. 字节缓冲流 : 缓冲字节节点流读写效率

1.1字节输入缓冲流 BufferedInputStream

字节输出缓冲流 BufferedOutputStream

1.2 字符缓冲流 : 缓冲字符节点流读写效率

    public static void main(String[] args) throws IOException {
        //1.构建流
        InputStream is=new BufferedInputStream(new FileInputStream("D:\\src.txt"));
        OutputStream os=new BufferedOutputStream(new FileOutputStream("D:\\hehe.txt"));
        //2.读写
        byte[] car=new byte[1024];
        int len=-1;
        while((len=is.read(car))!=-1){
            os.write(car,0,len);
        }
        //3.刷出
        os.flush();
        //4.关闭
        os.close();
        is.close();
    }

2.字符缓冲流

2.1字符缓冲流 : 缓冲字符节点流读写效率

字符输入缓冲流 BufferedReader

从字符输入流中读取文本，缓冲字符，以便有效地读取字符，数组和行。

可以指定缓冲区大小，或者可以使用默认大小。 对于大多数用途，默认值足够大。

新增功能 ： String readLine() 读一行文字。

2.2 字符输出缓冲流 BufferedWriter

新增功能 ： void newLine() 写一个行分隔符。

    public static void main(String[] args) throws IOException {
        //1.构建流
        BufferedReader rd=new BufferedReader(new FileReader("D:\\src.txt"));
        BufferedWriter rw=new BufferedWriter(new FileWriter("D:\\hehe.txt"));
        //2.读写
        String msg=null;
        while((msg=rd.readLine())!=null){
            rw.write(msg);
            rw.newLine();
        }

        //3.刷出
        rw.flush();
        //4.关闭
        rw.close();
        rd.close();
    }

注意 ： 有新增方法不能发生多态，无法调用

基本数据类型流：字节流的功能流

读写数据的同时保存数据类型（基本数据类型|String）

DataInputStream:新增方法，读取对应类型的数据

    //读入数据+数据类型（基本数据类型+String）
    public static void readFile(String src) throws IOException {
        //1.构建输入流
        DataInputStream is=new DataInputStream(new FileInputStream(src));
        //2.读入数据
        int i=is.readInt();
        boolean flag=is.readBoolean();
        char ch=is.readChar();
        String str=is.readUTF();

        //3.处理数据
        System.out.println(i);
        System.out.println(flag);
        System.out.println(ch);
        System.out.println(str);
    }

DataOutputStream: 新增方法 写出某种类型的数据

    //写出数据+数据类型
    public static void writeToFile(String dest) throws IOException {
        //1.构建输出流
        DataOutputStream os=new DataOutputStream(new FileOutputStream(dest));

        //2.准备数据
        int i=1;
        boolean flag=false;
        char ch='a';
        String str="哈哈";


        //3.写出
        os.writeInt(i);
        os.writeBoolean(flag);
        os.writeChar(ch);
        os.writeUTF(str);

        //4.刷出
        os.flush();

        //5.关闭
        os.close();
    }

注意：读入的一定是曾经写出的源文件

读入和写出的顺序必须保持一致

功能流 ： 字节流的功能流

Data流|基本数据类型流 : 读写数据的同时保留数据类型(基本数据类型|String)

基本数据类型输入流 : DataInputStream

新增功能 : xxx readXxx();

基本数据类型输出流 : DataOutputStream

新增功能 : void writeXxx();

注意 :

先写出后读入,写出与读入的顺序保持一致

引用数据类型流|Object流|对象流 功能流

序列化：将对象数据转换成为可存储或可传输状态的过程

序列化输出流 ObjectOutputStream

反序列化输入流 ObjectInputStream