Java基础入门19：File、IO 流2（字符流、缓冲流、转换流、打印流、数据流、序列化流、IO框架）

最新推荐文章于 2024-09-15 19:46:31 发布

叶芋爱耗者

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量956

点赞数 32

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_80944764/article/details/141160323

版权

字符流

FileReader(（文件字符输入流）

作用：以内存为基准，可以把文件中的数据以字符的形式读入到内存中去。

package com.itchinajie.d1_char_stream;

import java.io.FileReader;
import java.io.Reader;
/*
* 目标：掌握文件字节输入流每次读取一个字符
* */
public class FileReaderTest1 {
    public static void main(String[] args) {
        try (
                //1、创建文件字符输入流管道与源文件接通
                Reader fr = new FileReader("io-app2\\src\\io-app2.txt");
        ){
            //2、读取文本文件内容
//            int c;//记住每次读取字符的编号
//            while((c = fr.read()) != -1 ){
//                System.out.println((char) c);
//            }
            //3、每次读取多个字符
            char[] buffer = new char[3];
            int len;//记住每次读取了多少个字符
            while ((len = fr.read(buffer)) != -1){
                //取多少导出多少
                System.out.println(new String(buffer,0,len));
            }
            //这样性能不错
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

FileWriter(（文件字符输出流）

作用：以内存为基准，把内存中的数据以字符的形式写出到文件中去。

package com.itchinajie.d1_char_stream;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/*
* 目标：掌握文件字节输出流：写字符数据出去
* */
public class FileWriterTest2 {
    public static void main(String[] args) {

        try (
                //0、创建一个文件字符输出流管道与目标文件接通。
                //Writer fw = new FileWriter("io-app2\\src\\io-app3out.txt");
                //追加数据
                Writer fw = new FileWriter("io-app2\\src\\io-app3out.txt",true);
             ){
            //1、public void write(int  c):写一个字符出去
            fw.write('a');
            fw.write(97);
            fw.write('杰');
            fw.write("\r\n");
            //2、public void write(String c)写一个字符串出去
            fw.write("我爱你中国abc");
            fw.write("\r\n");
            //3、public void write(String c,int pos,int len):写字符串的一部分出去
            fw.write("我爱你中国abc",0,5);
            fw.write("\r\n");
            //4、public void write(char[] buffer):写一个字符数组出去
            char[] buffer = {'小','橙','a','b','c'};
            fw.write(buffer);
            fw.write("\r\n");
            //5、public void write(char[]buffer,int pos,int len):写字符数组的一部分出去
            fw.write(buffer,0,2);
            fw.write("\r\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意：字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效。

package com.itchinajie.d1_char_stream;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/*
* 目标：搞清楚字符输出流使用时的注意事项
* */
public class FileWriterTest3 {
    public static void main(String[] args) throws IOException {
        Writer fw = new FileWriter("io-app2\\src\\io-app4out.txt");

            fw.write('a');
            fw.write('b');
            fw.write('c');
            fw.write('d');
            fw.write("\r\n");

            fw.write("我爱你中国");
            fw.write("\r\n");
            fw.write("我爱你中国");

//            fw.flush();//刷新流
//            fw.write('e');
//            fw.flush();

            fw.close();//关闭流，包含刷新流

    }
}

字节流、字符流的使用场景小结：

字节流适合做一切文件数据的拷贝(音视频，文本)；字节流不适合读取中文内容输出。
字符流适合做文本文件的操作(读，写)。

缓冲流

一张图知全貌

字节缓冲流的原理

字节缓冲输入流自带了8KB缓冲池；字节缓冲输出流也自带了8KB缓冲池。

这样可以提高字节流读写数据的性能。

package com.itchinajie.d2_buffered_stream;

import java.io.*;
/*
* 目标：掌握字节缓冲流的作用
* */

public class BufferedInputStreamTest1 {
    public static void main(String[] args) {
        try (
                InputStream is = new FileInputStream("io-app2\\src\\io-app2.txt");
                //1、定义一个字节缓冲输入流包装原始的字节输入流
                InputStream bis = new BufferedInputStream(is);

                OutputStream os = new FileOutputStream("io-app2\\src\\io-app2_bak.txt");
                //2、定义一个字节缓冲输出流包装原始的字节输出流
                OutputStream bos = new BufferedOutputStream(os);
        ){
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1){
                os.write(buffer,0,len);
            }
            System.out.println("复制成功!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

BufferedReader（字符缓冲输入流）

作用：自带8K(8192)的字符缓冲池，可以提高字符输入流读取字符数据的性能。

字节换冲输入流新增功能：按照行读取字符

package com.itchinajie.d2_buffered_stream;

import java.io.*;
/*
* 目标：掌握字节缓冲输入流的作用
* */

public class BufferedReaderTest2 {
    public static void main(String[] args) {
        try (
                Reader fr = new FileReader("io-app2\\src\\io_app5.txt");
                //创建一个字节缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
        ){
//            char[] buffer = new char[3];
//            int len;
//            while ((len = br.read(buffer)) != -1){
//                System.out.print(new String(buffer,0,len));
//            }
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());

            String line;//每次记住读取的一行数据
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

BufferedWriter（字符缓冲输出流）

作用：自带8K的字符缓冲池，可以提高字符输出流写字符数据的性能。

字节缓冲输出流新增功能：换行

package com.itchinajie.d2_buffered_stream;

import java.io.*;
/*
* 目标：掌握字节缓冲输出流的用法
* */

public class BufferedWriterTest3 {
    public static void main(String[] args) {
        try (
                Writer fw = new FileWriter("io-app2\\src\\io_app6.txt");
                //创建一个字节缓冲输出流管道包装原始的字符缓冲输出流
                BufferedWriter bw = new BufferedWriter(fw)
        ){
            bw.write('b');
            bw.write('c');
            bw.write('d');
            bw.newLine();

            bw.write("我爱你中国");
            bw.newLine();
            bw.write("我爱你中国");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

原始流和缓冲流的性能分析

package com.itchinajie.d2_buffered_stream;

import java.io.*;

/*
* 目标：观察原始流和缓冲流的性能。
* */
public class TimeTest5 {
    private static final String SRC_FILE = "E:\\Java\\movies\\坠落的审判.mp4";
    private static final String DEST_FILE = "E:\\";
    public static void main(String[] args) {
        //copy01();//低级字节流一个一个字节的赋值，慢的简直让人无法忍受，直接淘汰！
        copy02();//低级的字节流流按照一个一个字节数组的形式复制，速度较慢！
        //copy03();//缓冲流按照一个一个字节的形式复制，速度较慢！直接淘汰！
        copy04();//缓冲流按照一个一个字节数组的形式复制，速度极快，推荐使用!
    }
    private static void copy01(){
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                OutputStream os = new FileOutputStream(DEST_FILE + "1.mp4");
                ){
            int b;
            while ((b = is.read()) != -1){
                os.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("低级字节流一个一个字节复制时耗时：" + (endTime - startTime)/1000.0 + "s");
    }
    private static void copy02(){
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                OutputStream os = new FileOutputStream(DEST_FILE + "2.mp4");
        ){
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1){
                os.write(buffer,0,len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("低级字节流使用字节数组复制时耗时：" + (endTime - startTime)/1000.0 + "s");
    }
    private static void copy03(){
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                BufferedInputStream bis = new BufferedInputStream(is);

                OutputStream os = new FileOutputStream(DEST_FILE + "3.mp4");
                BufferedOutputStream bos = new BufferedOutputStream(os);
        ){
            int b;
            while ((b = bis.read()) != -1){
                bos.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("缓冲流一个一个字节复制时耗时：" + (endTime - startTime)/1000.0 + "s");
    }
    private static void copy04(){
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                BufferedInputStream bis = new BufferedInputStream(is);

                OutputStream os = new FileOutputStream(DEST_FILE + "4.mp4");
                BufferedOutputStream bos = new BufferedOutputStream(os);
        ){
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("缓冲流使用字节数组复制时耗时：" + (endTime - startTime)/1000.0 + "s");
    }
}

转换流

不同编码读取出现乱码的问题

如果代码编码和被读取的文本文件的编码是一致的，使用字符流读取文本文件时不会出现乱码！
如果代码编码和被读取的文本文件的编码是不一致的，使用字符流读取文本文件时就会出现乱码！

InputStreamReader（字符输入转换流）

解决不同编码时，字符流读取文本内容乱码的问题。

解决思路：先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了。

package com.itchinajie.d3_transform_stream;

import java.io.*;

/*
* 目标：掌握字符输入转换流的作用。
* */
public class InputStreamReaderTest1 {
    public static void main(String[] args) {
        try (
                //1、得到文件的原始字节流（GBK的字节流形式）
                InputStream is = new FileInputStream("io-app2\\src\\io-app7.txt");
                //2、把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader isr = new InputStreamReader(is,"GBK");
                //3、把字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(isr);
                ){
            String line;
            while((line = br.readLine()) != null){
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

OutputStreamWriter（字符输出转换流）

作用：可以控制写出去的字符使用什么字符集编码。

解决思路：获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了。

package com.itchinajie.d3_transform_stream;

import java.io.*;

/*
* 目标：掌握字符输出转换流的作用。
* */
public class OutputStreamWriterTest2 {
    public static void main(String[] args) {
        //指定写出去的字符编码
        try (
                //1、创建一个文件字节输出流
                OutputStream os = new FileOutputStream("io-app2\\src\\io-app8.txt");
                //2、把原始的字节输出流按照指定的字符集编码转换成字符输出转换流
                Writer osw = new OutputStreamWriter(os,"GBK");
                //3、把字符输出流包装成缓冲字符输出流
                BufferedWriter bw = new BufferedWriter(osw);
                ){
            bw.write("我是中国人abc");
            bw.write("我是中国人123");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

打印流

PrintStream/PrintWriter（打印流）

作用：打印流可以实现更方便、更高效的打印数据出去，能实现打印啥出去就是啥出去。

PrintStream提供的打印数据的方案

PrintWriter提供的打印数据的方案

package com.itchinajie.d4_printstream;

import java.io.FileOutputStream;
import java.io.FilterOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.nio.charset.Charset;

/*
* 目标：掌握打印流：PrintStream/PrintWriter的用法
* */
public class PrintTest1 {
    public static void main(String[] args) {
        try (
                //1、创建一个打印流管道
//        PrintStream ps =
//                new PrintStream("io-app2/src/io-app9.txt", Charset.forName("GBK"));
//        PrintStream ps =
//                new PrintStream("io-app2/src/io-app9.txt");
                PrintWriter ps =
                        new PrintWriter(new FileOutputStream("io-app2/src/io-app9.txt",true));
                ){
            ps.println(97);
            ps.println('a');
            ps.println("我爱你中国abc");
            ps.println(true);
            ps.println(99.5);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

PrintStream和PrintWriter的区别

打印数据的功能上是一模一样的：都是使用方便，性能高效（核心优势）

PrintStream继承自字节输出流OutputStream,因此支持写字节数据的方法。

PrintWriter继承自字符输出流Writer,因此支持写字符数据出去。

打印流的一种应用：输出语句的重定向

package com.itchinajie.d4_printstream;

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class PrintTest2 {
    public static void main(String[] args) {
        System.out.println("老骥伏枥");
        System.out.println("志在千里");
        try (
                //把系统默认的打印流对象改成自己设置的打印流
                PrintStream ps = new PrintStream("io-app2/src/io-app10.txt");
                ){
            System.setOut(ps);
            System.out.println("烈士暮年");
            System.out.println("壮心不已");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

数据流

DataOutputStream（数据输出流）

允许把数据和其类型一并写出去。

package com.itchinajie.d5_data_stream;

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilterOutputStream;

/*
* 目标：数据输出流
* */
public class DataInputStreamTest2 {
    public static void main(String[] args) {
        try (
                //1、创建一个数据输出流包装低级的字节输出流
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("io-app2/src/io-app11.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("我爱中国abc");

        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

DatalnputStream（数据输入流）

用于读取数据输出流写出去的数据。

package com.itchinajie.d5_data_stream;

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

/*
* 目标：使用数据输入流读取特定类型的数据
* */
public class DataOutputStreamTest1 {
    public static void main(String[] args) {
        try (
                DataInputStream dis =
                        new DataInputStream(new FileInputStream("io-app2/src/io-app11.txt"));
        ){
            int i = dis.readInt();
            System.out.println(i);

            double d = dis.readDouble();
            System.out.println(d);

            boolean b = dis.readBoolean();
            System.out.println(b);

            String rs = dis.readUTF();
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

序列化流

ObjectOutputStream（对象字节输出流）

可以把Java对象进行序列化：把]ava对象存入到文件中去。

注意：对象如果要参与序列化，必须实现序列化接口(Gava.io.Serializable)

package com.itchinajie.d6_objectstream;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/*
* 目标：掌握对象字节输出流的使用：序列化对象
* */
public class ObjectOutputStreamTest1 {
    public static void main(String[] args) {
        try (
                //2、创建一个对象字节输出流包装原始的字节输出流
                ObjectOutputStream oos =
                        new ObjectOutputStream(new FileOutputStream("io-app2/src/io-app12.txt"));
                ){
            //1、创建一个Java对象
            User u = new User("admin","张三",32,"666888xyz");
            //3、序列化对象到文件中去
            oos.writeObject(u);
            System.out.println("序列化对象成功！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ObjectInputStream（对象字节输入流）

可以把Java对象进行反序列化：把存储在文件中的]ava对象读入到内存中来。

package com.itchinajie.d6_objectstream;

import java.io.*;

/*
*目标：掌握对象字节输入流的使用：反序列化对象
**/
public class ObjectInputStreamTest2 {
    public static void main(String[] args) {
        try (
                //1、创建一个对象字节输入流管道，包装 低级的字节输入流与源文件接通
                ObjectInputStream ois =
                        new ObjectInputStream(new FileInputStream("io-app2/src/io-app12.txt"));
                ){
            User u = (User)ois.readObject();
            System.out.println(u);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

如果需要多个序列化，只需用一个ArrayList集合存储多个对象，然后直接对集合进行序列化即可
注意：ArrayList集合已经实现了序列化接口！

package com.itchinajie.d6_objectstream;

import java.io.Serializable;
//注意：对象如果需要序列化，必须实现序列化接口
public class User implements Serializable {
    private String loginName;
    private String userName;
    private int age;
    //transient这个成员变量将不参与序列化
    private transient String passWord;

    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", passWord='" + passWord + '\'' +
                '}';
    }

    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public User() {
    }

    public User(String loginName, String userName, int age, String passWord) {
        this.loginName = loginName;
        this.userName = userName;
        this.age = age;
        this.passWord = passWord;
    }
}