[会写代码的健身爱好者成长史]之java-io流

1.什么是流

流是内存与存储设备的一个传输数据的通道

如果按照流向划分

从存储设备到内存叫输入流，input

从内存到存储设备叫输出流，output

如果按照单位划分

字节流：以节点为单位，可以读写所有的数据

字符流：以字符为单位，可以读写文本数据

如果按照功能划分

节点流和过滤流：

FileInputStream读取本地文件数据

public static void main(String[] args) throws IOException {
        //创建一个FileInputStream，并指定一个要读取的文件路径
        FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\aa.txt");
        byte[] bytes = new byte[1024];
        int count = 0;
        //当count=-1的时候说明已经读完了
        while ((count=fileInputStream.read(bytes))!=-1){
            //new String(bytes,0,count)
            //通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
            //参数： bytes：要解码为字符的 byte 
            //offset： 要解码的第一个 byte 的索引 
            //length： 要解码的 byte 数 的长度
            System.out.println(new String(bytes,0,count));
        }
        fileInputStream.close();
    }

FileOutputStream字节输出流

public static void main(String[] args) throws IOException {
        //创建一个FileOutputStream，并指定一个要读取的文件路径，如果当前路径没有此文件则会自动创建
        //如果有true则表示接着里面的文件内容写，如果不加true则表示会重置里面的内容，写入新的内容
        FileOutputStream fos = new FileOutputStream("D://bbb.txt",true);
        String write = "chinasoft";
        //获取write字符串对应的字节数组
        fos.write(write.getBytes());
        fos.close();
    }

实现文件复制

/**
 *实现文件复制
 */
public class IOTest {

    public static void main(String[] args) throws IOException {
        //创建输入和输出流
        FileInputStream fileInputStream = new FileInputStream("D://bbb.txt");
        FileOutputStream fileOutputStream = new FileOutputStream("D://ccc.txt");
        int count;
        byte[] bytes = new byte[1024];
        while ((count=fileInputStream.read(bytes))!=-1){
            //边读边写，将读到的文件内容，写到新的文件里面去
            fileOutputStream.write(bytes,0,count);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }
}

字节缓冲流

首先会创建一个缓冲区，在读取数据的时候，如果缓冲区里面有，就没必要从硬盘中读取

可以提高io的效率，减少访问磁盘的次数

 1.BufferedInputStream缓冲字节输入流

public static void main(String[] args) throws IOException {
        //创建BufferedInputStream 字节缓冲输入流,内部有个缓冲区，可以提高io的效率，减少访问磁盘的次数
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://ccc.txt"));
        int count =0;
        while ((count=bis.read())!=-1){
            System.out.print((char) count);
        }
    }

2.BufferedOutputStream缓冲字节输出流

public static void main(String[] args) throws IOException {
        //创建BufferedOutputStream 字节缓冲输入流,内部有个缓冲区，可以提高io的效率，减少访问磁盘的次数
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D://fff.txt", true));
        String write = "hello";
        //如果在没有关闭流或者没有刷新的时候，内容其实是写到BufferedOutputStream缓冲区里面的
        bos.write(write.getBytes());
        //当调用flush方法，内容才写入到对应的文件里面去
        bos.flush();
        //关闭流，close方法里面其实就已经调用了flush方法，所以bos.flush() 不加也行，但是可能会出现数据丢失的问题
        // 如果程序正在运行，往文件里写数据的时候，此时断电了，最起码已经flush的数据是可以写到文件里面
        bos.close();
    }

对象流

1.ObjectOutputStream

public static void main(String[] args) throws IOException {
        //创建一个对象流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D://www.txt"));
        //序列号写入操作，写入一个User对象，名字aaa,年纪18
        //序列化的User类，必须要实现Serializable接口
        oos.writeObject(new User("aaa",18));
        //关闭流，里面自动调用了flush方法
        oos.close();
    }

2.ObjectInputStream

public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建一个对象流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D://www.txt"));
        //读取文件(反序列化),返回的Object,强转为User对象
        User o = (User) ois.readObject();
        //关闭流
        ois.close();
        System.out.println(o);
    }

 3.关于序列化和反序列化

1.序列化必须实现 Serializable 接口

2.序列化类里面的对象属性也要求要实现Serializable 接口

3.序列化的时候序列化的id，serialVersionUID，要求保证序列化和反序列化的类是同一个类

4.在属性前面加上 java关键字  transient，表明这个属性不可被序列化

5.静态属性不能被序列号

6.可以一次实现多个对象的序列化，借用集合即可 

字符流

1.FileReader

public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建一个字符流
        FileReader fileReader = new FileReader("D://bbb.txt");
        int count = 0;
        StringBuilder stringBuilder = new StringBuilder();
//        //一个字符一个字符的读
//        while ((count=fileReader.read())!=-1){
//             stringBuilder.append((char) count);
//        }
        char [] chars = new char[1024];
        while ((count = fileReader.read(chars))!=-1){
            String s = new String(chars, 0, count);
            stringBuilder.append(s);
        }
        fileReader.close();
        System.out.println(stringBuilder);
    }

2.FileWriter

public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建一个字符流
        FileWriter fileWriter = new FileWriter("D://bbb.txt",true);
        String write = "在电线杆上多嘴,你说这一句很有夏天的感觉";
        fileWriter.write(write);
        fileWriter.close();
    }

3.字符流复制文本文件 

public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建一个字符流,使用fileReader和fileWriter复制文本文件，不能复制图片或者二进制文件
        FileReader fileReader = new FileReader("D://bbb.txt");
        FileWriter fileWriter = new FileWriter("D://ccc.txt",true);
        int data=0;
        char [] chars = new char[1024];
        while ((data=fileReader.read(chars))!=-1){
            fileWriter.write(chars);
        }
        fileReader.close();
        fileWriter.close();
    }

字符缓冲流

1.BufferedReader 

public static void main(String[] args) throws IOException {
        //创建一个字符缓冲流
        BufferedReader bufferedReader = new BufferedReader(new FileReader("D://bbb.txt"));
        String line = "";
        //一行一行的读取
        while ((line=bufferedReader.readLine())!=null){
            System.out.println(line);
        }
        bufferedReader.close();
    }

2.BufferedWriter 

 public static void main(String[] args) throws IOException {
        //创建一个字符缓冲流
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D://bbb.txt",true));
        //写入
        bufferedWriter.newLine();//写入一个换行符
        bufferedWriter.write("手中的铅笔在纸上来来回回");
        bufferedWriter.close();
    }

打印流

public static void main(String[] args) throws IOException {
        //创建一个打印流
        PrintWriter printWriter = new PrintWriter("D://print.txt");
        //打印,原样打印，写的是什么，打印的就是什么
        printWriter.println(97);
        printWriter.println(true);
        //关闭
        printWriter.close();
    }

转换流

1.InputStreamReader 

public static void main(String[] args) throws IOException {
        //创建一个转换流
        InputStreamReader isr  = new InputStreamReader(new FileInputStream("D://bbb.txt"),"utf-8");
        int count = 0;
        while ((count=isr.read())!=-1){
            System.out.print((char) count);
        }
        isr.close();
    }

2.OutputStreamWriter 

public static void main(String[] args) throws IOException {
        //创建一个打印流
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D://bbb.txt",true),"utf-8");
        String write = "--jay";
        osw.write(write);
        osw.close();
    }