IO流知识梳理

IO流分为两大类，分别是字节流和字符流

根据数据传输方向划分（以程序为参照物），分为输入流和输出流。输入流指的是从文件>程序（读取数据），输出流是程序>文件（写出数据）。

根据读写的单位进行划分，分为字节流和字符流。字符流的单位是字符，字节流的单位是字节（Byte）。

根据功能进行划分，分为基础流和包装流。

字节输入流的抽象父类是InputStream，输出流的抽象父类是OutputStream

字符输入流的抽象父类是Reader，输出流的抽象父类是Writer

 

import org.junit.Test;
import java.io.*;

//带缓冲区的字节输入流
public class Demo01 {
    @Test
    public void method01()throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("IO.txt"))
        byte[] b = new byte[1024];
        int len;
        while((len = bis.read(d)) != -1){
            System.out.println(new String(b,0,len));
        }
        bis.close();
    }
//带缓冲区的字节输出流
    @Test
    public void method02()throws IOException{
        FileOutputStream fos = new FileOutputStream("IO1.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        bos.write("有道无术，术尚可求".getBytes());
        bos.close();
        fos.close();
    }
}

带缓冲区的字符流：

BufferedReader:        --        readLine()

BufferedWriter        --        newLine()

import org.junit.Test;
import java.io.*;

public class Demo01{
    @Test
    public void method01()throws Exception{
        BufferedReader br = new BufferedReader(new FileReader("IO1.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("IO1.1.txt"));
        char[] ch = new char[1024];
        int len;
        while((len = br.read(ch)) != -1){
            bw.write(ch,0,len);
        }
        br.close();
        bw.close();
    }
    @Test
    public void method02()throws Exception{
        BufferedReader br = new BufferedReader(new FileReader("IO1.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("IO1.2.txt"));
        String str;
        while((str = br.readLine()) != null){
            bw.writer(str);
            bw.newLine();//换行
        }
        br.close();
        bw.close();
    }
}

 使用对象流进行对象的读写操作，对象类必须实现 Serializable 接口

import java.io.Serializable;

public class User implements Serializable {
    private int id;
    private String name;
    private int age;

    public User() {
    
    }
    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

本质上读写操作是序列化和反序列化，写入对象到文件中为序列化，读取文件的对象为反序列化，私有的静态属性不会被序列化，私有的 transient 属性不会被序列化

import org.junit.Test;
import java.io.*;
import java.util.ArrayList;
//使用对象流存储多个对象信息
public class Demo01{
    @Test
    public void method01()throws IOException{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("IO2.txt"));
        ArrayList<User> list = new ArrayList<>();
        list.add(new User(1,"a",18));
        list.add(new User(2,"b",18));
        list.add(new User(3,"c",18));
        list.add(new User(4,"d",18));
        list.add(new User(5,"e",18));
        oos.writerObject(list);
        oos.close();
    }
}

 需要注意的是：readObject()方法读取集合需要强制转换

import org.junit.Test;
import java.io.*;
import java.util.List;
//通过对象流读取文件多个对象信息
public class Demo02 {
    @Test
    public void method01()throws IOException,ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("IO2.txt"));
        List<User> list = (list<User>)ois.readObject();
        for(User user:list){
            System.out.println(user);
        }
        ois.close();
    }
}

转换流：本质上是字符流，是字节通向字符的桥梁

        InputStreamReader:文件中的字节转换成程序中的字符

        OutputStreamWriter:程序中的字符转换成文件中的字节

import org.junit.Test;
import java.io.*;

public class Demo01{
    //输出转换流    写入文件
    @Test
    public void method01() throws IOException{
        FileOutputStream fos = new FileOutputStream("IO1.txt");
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
        bw.write("拼搏到无能为力，坚持到感动自己");
        bw.close();
        fos.close();
    }
    //输入转换流    写入程序
    @Test
    public void method02() throws Exception{
        FileInputStream fis = new FileInputStream("IO1.txt");
        BufferedReader br = new BufferedReader(new InputStreamReader(fis));
        String str = br.readLine();
        System.out.println(str);
        br.close;
        fis.close;
    }
}

使用转换流读取不同的编码格式数据

import org.junit.Test;
import java.io.*;

public class Demo01{
    @Test
    public void method01() throws Exception{
        InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\File\\IO1.txt"),"GBK");
        char[] ch = new char[1024];
        int len;
        while((len = isr.read(ch)) != -1){
            System.out.println(new String(ch,0,len));
        }
        isr.close();
    }
}

内存流：本质是字节流

        ByteArrayOutputStream:内存输出流        

        ByteArrayInputStream:内存输入流

特点:        1、无法关闭

                2、操作数据量小，效率高

                3、一般操作临时文件

import java.io.*;

public class Demo01{
    public static void main(String[] args) throws IOException{
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        bos.write("好好学习，天天向上".getBytes());
        bos.writeTo(new FileOutputStream("IO.txt"));
        bos.close();
    }
}

打印流：只有输出没有输入，直接打印数据

                PrintStream:打印字节流

                PrintWriter:打印字符流

import org.junit.Test;
import java.io.*;

public class Demo01 {
    //打印字节流
    @Test
    public void method01() throws Exception{
        PrintStream ps = new PrintStream("IO1.txt");
        ps.print(97);
        ps.close();
    }
    //打印字符流
    @Test
    public void method02() throws Exception{
        PrintWriter pw = new PrintWriter("IO2.txt");
        byte num = 100;
        pw.print(num);
        pw.close();
    }
    /输出重定向     --  改变输出的目的源
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("有道无术");
        //改变目的源
        System.setOut(new PrintStream("IO4.txt"));
        System.out.println("术尚可求");
    }
}

随机访问流：RandomAccessFile

                        1、只有一个类，由一个类创建不同的对象来实现输入和输出

                        2、拥有指针（偏移量）

                        3、每次实例化对象，不会清空文件，偏移量为0，从0开始进行覆盖写入或者读取

                        4、可以实现在文件任意位置进行读写操作（断点续传）

import org.junit.Test;
import java.io.RandomAccessFile;

public class Demo01 {
    @Test
    public void method01() throws Exception {
        RandomAccessFile r = new RandomAccessFile("E:\\File\\QQ1.mp4", "r");
        RandomAccessFile rw = new RandomAccessFile("E:\\File\\QQ2.mp4", "rw");
        //指定数据源和目的源的偏移量
        r.seek(rw.length());
        rw.seek(rw.length());
        //拷贝
        byte[] b = new byte[5];
        int len;
        while((len = r.read(b)) != -1){
            rw.write(b,0,len);
        }
        r.close();
        rw.close();
    }
}

/*使用随机文件流类RandomAccessFile将一个文本文件倒置读出*/

import java.io.IOException;
import java.io.RandomAccessFile;

/*使用随机文件流类RandomAccessFile将一个文本文件倒置读出*/
public class Demo02 {
    public static void main(String[] args) throws IOException {
        /*RandomAccessFile r = new RandomAccessFile("IO2.txt","r");
        //定义一个偏移量
        long pointer = r.length()-1;
        while(pointer>=0){
            //设置偏移量
            r.seek(pointer);
            System.out.print((char)r.read());
            pointer--;
        }
        r.close();*/
        RandomAccessFile r = new RandomAccessFile("IO2.txt","r");
        byte[] bytes = new byte[1024];
        int len;
        //定义一个接收的字符串
        String str;
        //定义StringBuilder
        StringBuilder sb = new StringBuilder();
        while((len = r.read(bytes))!=-1){
            //把文本赋值给字符串
            str = new String(bytes,0,len);
            //传递字符串到sb
            sb.append(str);
        }
        //字符串反转
        sb.reverse();
        System.out.println(sb.toString());
    }
}