← 返回学习路线

SYSTEM

IOStream

Java基础IOStreamsystem
src/content/notes/system/IOStream.md

IOStream

概述

IO 输入输出流:输入/输出流

  • Input:输入
  • Output:输出

引入:File 类只能操作文件对象本身,不能读写文件对象的内容,读写数据内容,应该使用 IO 流

IO 流是一个水流模型:IO 理解成水管,把数据理解成水流

IO 流的分类:

  • 按照流的方向分为:输入流,输出流。
    • 输出流:以内存为基准,把内存中的数据写出到磁盘文件或者网络介质中去的流称为输出流
    • 输入流:以内存为基准,把磁盘文件中的数据或者网络中的数据读入到内存中的流称为输入流
  • 按照流的内容分为:字节流,字符流
    • 字节流:流中的数据的最小单位是一个一个的字节,这个流就是字节流
    • 字符流:流中的数据的最小单位是一个一个的字符,这个流就是字符流(针对于文本内容)

流大体分为四大类:字节输入流、字节输出流、字符输入流、字符输出流

IO 流的体系:
        字节流                                   字符流
  字节输入流              字节输出流            字符输入流         字符输出流
InputStream           OutputStream          Reader            Writer   (抽象类)
FileInputStream       FileOutputStream      FileReader        FileWriter(实现类)
BufferedInputStream  BufferedOutputStream  BufferedReader   BufferedWriter(实现类缓冲流)
                                           InputStreamReader OutputStreamWriter
ObjectInputStream     ObjectOutputStream

字节流

字节输入

FileInputStream 文件字节输入流:以内存为基准,把磁盘文件中的数据按照字节的形式读入到内存中的流

构造方法:

  • public FileInputStream(File path):创建一个字节输入流管道与源文件对象接通
  • public FileInputStream(String pathName):创建一个字节输入流管道与文件路径对接,底层实质上创建 File 对象

方法:

  • public int read():每次读取一个字节返回,读取完毕会返回 -1
  • public int read(byte[] buffer):从字节输入流中读取字节到字节数组中去,返回读取的字节数量,没有字节可读返回 -1,byte 中新读取的数据默认是覆盖原数据,构造 String 需要设定长度
  • public String(byte[] bytes,int offset,int length):构造新的 String
  • public long transferTo(OutputStream out) :从输入流中读取所有字节,并按读取的顺序,将字节写入给定的输出流
public class FileInputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        // 1.创建文件对象定位dlei01.txt
        File file = new File("Demo/src/dlei01.txt");
        // 2.创建一个字节输入流管道与源文件接通
        InputStream is = new FileInputStream(file);
        // 3.读取一个字节的编号返回,读取完毕返回-1
		//int code1 = is.read(); // 读取一滴水,一个字节
		//System.out.println((char)code1);

        // 4.使用while读取字节数
        // 定义一个整数变量存储字节
        int ch = 0 ;
        while((ch = is.read())!= -1){
            System.out.print((char) ch);
        }
    }
}

一个一个字节读取英文和数字没有问题,但是读取中文输出无法避免乱码,因为会截断中文的字节。一个一个字节的读取数据,性能也较差,所以禁止使用上面的方案

采取下面的方案:

public static void main(String[] args) throws Exception {
    //简化写法,底层实质上创建了File对象
    InputStream is = new FileInputStream("Demo/src/test.txt");
    byte[] buffer = new byte[3];//开发中使用byte[1024]
    int len;
    while((len = is.read(buffer)) !=-1){
        // 读取了多少就倒出多少!
        String rs = new String(buffer, 0, len);
        System.out.print(rs);
    }
}
File f = new File("Demo/src/test.txt");
InputStream is = new FileInputStream(f);
// 读取全部的
byte[] buffer = is.readAllBytes();
String rs = new String(buffer);
System.out.println(rs);

字节输出

FileOutputStream 文件字节输出流:以内存为基准,把内存中的数据,按照字节的形式写出到磁盘文件中去

构造方法:

  • public FileOutputStream(File file):创建一个字节输出流管道通向目标文件对象
  • public FileOutputStream(String file) :创建一个字节输出流管道通向目标文件路径
  • public FileOutputStream(File file, boolean append) : 创建一个追加数据的字节输出流管道到目标文件对象
  • public FileOutputStream(String file, boolean append) : 创建一个追加数据的字节输出流管道通向目标文件路径

API:

  • public void write(int a):写一个字节出去

  • public void write(byte[] buffer):写一个字节数组出去

  • public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去,从 pos 位置,写出 len 长度

  • FileOutputStream 字节输出流每次启动写数据的时候都会先清空之前的全部数据,重新写入:

    • OutputStream os = new FileOutputStream("Demo/out05"):覆盖数据管道
    • OutputStream os = new FileOutputStream("Demo/out05" , true):追加数据的管道

说明:

  • 字节输出流只能写字节出去,字节输出流默认是覆盖数据管道
  • 换行用:os.write(“\r\n”.getBytes())
  • 关闭和刷新:刷新流可以继续使用,关闭包含刷新数据但是流就不能使用了
OutputStream os = new FileOutputStream("Demo/out05");
os.write(97);//a
os.write('b');
os.write("\r\n".getBytes());
os.write("我爱Java".getBytes());
os.close();
文件复制

字节是计算机中一切文件的组成,所以字节流适合做一切文件的复制

public class CopyDemo01 {
    public static void main(String[] args) {
        InputStream is = null ;
        OutputStream os = null ;
        try{
            //(1)创建一个字节输入流管道与源文件接通。
            is = new FileInputStream("D:\\seazean\\图片资源\\test.jpg");
            //(2)创建一个字节输出流与目标文件接通。
            os = new FileOutputStream("D:\\seazean\\test.jpg");
            //(3)创建一个字节数组作为桶
            byte buffer = new byte[1024];
            //(4)从字节输入流管道中读取数据,写出到字节输出流管道即可
            int len = 0;
            while((len = is.read(buffer)) != -1){
                os.write(buffer,0,len);
            }
            System.out.println("复制完成!");
        }catch (Exception e){
            e.printStackTrace();
        } finally {
            /**(5)关闭资源! */
            try{
                if(os!=null)os.close();
                if(is!=null)is.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

字符流

字符输入

FileReader:文件字符输入流,以内存为基准,把磁盘文件的数据以字符的形式读入到内存,读取文本文件内容到内存中去

构造器:

  • public FileReader(File file):创建一个字符输入流与源文件对象接通。
  • public FileReader(String filePath):创建一个字符输入流与源文件路径接通。

方法:

  • public int read():读取一个字符的编号返回,读取完毕返回 -1
  • public int read(char[] buffer):读取一个字符数组,读取多少个就返回多少个,读取完毕返回 -1

结论:

  • 字符流一个一个字符的读取文本内容输出,可以解决中文读取输出乱码的问题,适合操作文本文件,但是一个一个字符的读取文本内容性能较差
  • 字符流按照字符数组循环读取数据,可以解决中文读取输出乱码的问题,而且性能也较好

字符流不能复制图片,视频等类型的文件。字符流在读取完了字节数据后并没有直接往目的地写,而是先查编码表,查到对应的数据就将该数据写入目的地。如果查不到,则码表会将一些未知区域中的数据去 map 这些字节数据,然后写到目的地,这样的话就造成了源数据和目的数据的不一致。

public class FileReaderDemo01{//字符
    public static void main(String[] args) throws Exception {
        // 创建一个字符输入流管道与源文件路径接通
        Reader fr = new FileReader("Demo/src/test.txt");
        int ch;
        while((ch = fr.read()) != -1){
            System.out.print((char)ch);
        }
    }
}
public class FileReaderDemo02 {//字符数组
    public static void main(String[] args) throws Exception {
        Reader fr = new FileReader("Demo/src/test.txt");
        
        char[] buffer = new char[1024];
        int len;
        while((len = fr.read(buffer)) != -1) {
            System.out.print(new String(buffer, 0 , len));
        }
    }
}

字符输出

FileWriter:文件字符输出流,以内存为基准,把内存中的数据按照字符的形式写出到磁盘文件中去

构造器:

  • public FileWriter(File file):创建一个字符输出流管道通向目标文件对象(覆盖数据管道)
  • public FileWriter(String filePath):创建一个字符输出流管道通向目标文件路径
  • public FileWriter(File file, boolean append):创建一个追加数据的字符输出流管道通向文件对象(追加数据管道)
  • public FileWriter(String filePath, boolean append):创建一个追加数据的字符输出流管道通向目标文件路径

方法:

  • public void write(int c):写一个字符出去
  • public void write(char[] buffer):写一个字符数组出去
  • public void write(String c, int pos, int len):写字符串的一部分出去
  • public void write(char[] buffer, int pos, int len):写字符数组的一部分出去
  • fw.write("\r\n"):换行

读写字符文件数据建议使用字符流

Writer fw = new FileWriter("Demo/src/test.txt");
fw.write(97);   // 字符a
fw.write('b');  // 字符b
fw.write("Java是最优美的语言!");
fw.write("\r\n");
fw.close;

缓冲流

基本介绍

缓冲流可以提高字节流和字符流的读写数据的性能

缓冲流分为四类:

  • BufferedInputStream:字节缓冲输入流,可以提高字节输入流读数据的性能
  • BufferedOutStream:字节缓冲输出流,可以提高字节输出流写数据的性能
  • BufferedReader:字符缓冲输入流,可以提高字符输入流读数据的性能
  • BufferedWriter:字符缓冲输出流,可以提高字符输出流写数据的性能

字节缓冲输入

字节缓冲输入流:BufferedInputStream

作用:可以把低级的字节输入流包装成一个高级的缓冲字节输入流管道,提高字节输入流读数据的性能

构造器:public BufferedInputStream(InputStream in)

原理:缓冲字节输入流管道自带了一个 8KB 的缓冲池,每次可以直接借用操作系统的功能最多提取 8KB 的数据到缓冲池中去,以后我们直接从缓冲池读取数据,所以性能较好

public class BufferedInputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        // 1.定义一个低级的字节输入流与源文件接通
        InputStream is = new FileInputStream("Demo/src/test.txt");
        // 2.把低级的字节输入流包装成一个高级的缓冲字节输入流。
        BufferInputStream bis = new BufferInputStream(is);
        // 3.定义一个字节数组按照循环读取。
        byte[] buffer = new byte[1024];
        int len;
        while((len = bis.read(buffer)) != -1){
            String rs = new String(buffer, 0 , len);
            System.out.print(rs);
        }
    }
}

字节缓冲输出

字节缓冲输出流:BufferedOutputStream

作用:可以把低级的字节输出流包装成一个高级的缓冲字节输出流,从而提高写数据的性能

构造器:public BufferedOutputStream(OutputStream os)

原理:缓冲字节输出流自带了 8KB 缓冲池,数据就直接写入到缓冲池中去,性能提高了

public class BufferedOutputStreamDemo02 {
    public static void main(String[] args) throws Exception {
        // 1.写一个原始的字节输出流
        OutputStream os = new FileOutputStream("Demo/src/test.txt");
        // 2.把低级的字节输出流包装成一个高级的缓冲字节输出流
        BufferedOutputStream bos =  new BufferedOutputStream(os);
        // 3.写数据出去
        bos.write('a');
        bos.write(100);
        bos.write("我爱中国".getBytes());
        bos.close();
    }
}
字节流性能

利用字节流的复制统计各种写法形式下缓冲流的性能执行情况

复制流:

  • 使用低级的字节流按照一个一个字节的形式复制文件
  • 使用低级的字节流按照一个一个字节数组的形式复制文件
  • 使用高级的缓冲字节流按照一个一个字节的形式复制文件
  • 使用高级的缓冲字节流按照一个一个字节数组的形式复制文件

高级的缓冲字节流按照一个一个字节数组的形式复制文件,性能最高,建议使用


字符缓冲输入

字符缓冲输入流:BufferedReader

作用:字符缓冲输入流把字符输入流包装成高级的缓冲字符输入流,可以提高字符输入流读数据的性能。

构造器:public BufferedReader(Reader reader)

原理:缓冲字符输入流默认会有一个 8K 的字符缓冲池,可以提高读字符的性能

按照行读取数据的功能:public String readLine() 读取一行数据返回,读取完毕返回 null

public static void main(String[] args) throws Exception {
    // 1.定义一个原始的字符输入流读取源文件
    Reader fr = new FileReader("Demo/src/test.txt");
    // 2.把低级的字符输入流管道包装成一个高级的缓冲字符输入流管道
    BufferedReader br = new BufferedReader(fr);
    // 定义一个字符串变量存储每行数据
    String line;
    while((line = br.readLine()) != null){
        System.out.println(line);
    }
    br.close();
    //淘汰数组循环读取
    //char[] buffer = new char[1024];
    //int len;
    //while((len = br.read(buffer)) != -1){
    //System.out.println(new String(buffer , 0 , len));
}

字符缓冲输出

符缓冲输出流:BufferedWriter

作用:把低级的字符输出流包装成一个高级的缓冲字符输出流,提高写字符数据的性能。

构造器:public BufferedWriter(Writer writer)

原理:高级的字符缓冲输出流多了一个 8K 的字符缓冲池,写数据性能极大提高了

字符缓冲输出流多了一个换行的特有功能:public void newLine() 新建一行

public static void main(String[] args) throws Exception {
    Writer fw = new FileWriter("Demo/src/test.txt",true);//追加
    BufferedWriter bw = new BufferedWriter(fw);
    
    bw.write("我爱学习Java");
    bw.newLine();//换行
    bw.close();
}

高效原因

字符型缓冲流高效的原因:(空间换时间)

  • BufferedReader:每次调用 read 方法,只有第一次从磁盘中读取了 8192(8k)个字符,存储到该类型对象的缓冲区数组中,将其中一个返回给调用者,再次调用 read 方法时,就不需要访问磁盘,直接从缓冲区中拿出一个数据即可,提升了效率
  • BufferedWriter:每次调用 write 方法,不会直接将字符刷新到文件中,而是存储到字符数组中,等字符数组写满了,才一次性刷新到文件中,减少了和磁盘交互的次数,提升了效率

字节型缓冲流高效的原因:

  • BufferedInputStream:在该类型中准备了一个数组,存储字节信息,当外界调用 read() 方法想获取一个字节的时候,该对象从文件中一次性读取了 8192 个字节到数组中,只返回了第一个字节给调用者。将来调用者再次调用 read 方法时,当前对象就不需要再次访问磁盘,只需要从数组中取出一个字节返回给调用者即可,由于读取的是数组,所以速度非常快。当 8192 个字节全都读取完成之后,再需要读取一个字节,就得让该对象到文件中读取下一个 8192 个字节
  • BufferedOutputStream:在该类型中准备了一个数组,存储字节信息,当外界调用 write 方法想写出一个字节的时候,该对象直接将这个字节存储到了自己的数组中,而不刷新到文件中。一直到该数组所有 8192 个位置全都占满,该对象才把这个数组中的所有数据一次性写出到目标文件中。如果最后一次循环没有将数组写满,最终在关闭流对象的时候,也会将该数组中的数据刷新到文件中。

注意:字节流和字符流,都是装满时自动写出,或者没满时手动 flush 写出,或 close 时刷新写出


转换流

乱码问题

字符流读取:

代码编码            文件编码         中文情况。
UTF-8              UTF-8           不乱码!
GBK                GBK             不乱码!
UTF-8              GBK             乱码!
  • 如果代码编码和读取的文件编码一致,字符流读取的时候不会乱码
  • 如果代码编码和读取的文件编码不一致,字符流读取的时候会乱码

字符输入

字符输入转换流:InputStreamReader

作用:解决字符流读取不同编码的乱码问题,把原始的字节流按照默认的编码或指定的编码转换成字符输入流

构造器:

  • public InputStreamReader(InputStream is):使用当前代码默认编码 UTF-8 转换成字符流
  • public InputStreamReader(InputStream is, String charset):指定编码把字节流转换成字符流
public class InputStreamReaderDemo{
    public static void main(String[] args) throws Exception {
        // 1.提取GBK文件的原始字节流
        InputStream is = new FileInputStream("D:\\seazean\\Netty.txt");
        // 2.把原始字节输入流通过转换流,转换成 字符输入转换流InputStreamReader
        InputStreamReader isr = new InputStreamReader(is, "GBK"); 
        // 3.包装成缓冲流
        BufferedReader br = new BufferedReader(isr);
        //循环读取
        String line;
        while((line = br.readLine()) != null){
            System.out.println(line);
        }
    }
}

字符输出

字符输出转换流:OutputStreamWriter

作用:可以指定编码把字节输出流转换成字符输出流,可以指定写出去的字符的编码

构造器:

  • public OutputStreamWriter(OutputStream os):用默认编码 UTF-8 把字节输出流转换成字符输出流
  • public OutputStreamWriter(OutputStream os, String charset):指定编码把字节输出流转换成
OutputStream os = new FileOutputStream("Demo/src/test.txt");
OutputStreamWriter osw = new OutputStreamWriter(os,"GBK");
osw.write("我在学习Java");   
osw.close();

序列化

基本介绍

对象序列化:把 Java 对象转换成字节序列的过程,将对象写入到 IO 流中,对象 => 文件中

对象反序列化:把字节序列恢复为 Java 对象的过程,从 IO 流中恢复对象,文件中 => 对象

transient 关键字修饰的成员变量,将不参与序列化


序列化

对象序列化流(对象字节输出流):ObjectOutputStream

作用:把内存中的 Java 对象数据保存到文件中去

构造器:public ObjectOutputStream(OutputStream out)

序列化方法:public final void writeObject(Object obj)

注意:对象如果想参与序列化,对象必须实现序列化接口 implements Serializable ,否则序列化失败

public class SerializeDemo01 {
    public static void main(String[] args) throws Exception {
        // 1.创建User用户对象
        User user = new User("seazean","980823","七十一");
        // 2.创建低级的字节输出流通向目标文件
        OutputStream os = new FileOutputStream("Demo/src/obj.dat");
        // 3.把低级的字节输出流包装成高级的对象字节输出流 ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(os);
        // 4.通过对象字节输出流序列化对象:
        oos.writeObject(user);
        // 5.释放资源
        oos.close();
        System.out.println("序列化对象成功~~~~");
    }
}

class User implements Serializable {
    // 加入序列版本号
    private static final long serialVersionUID = 1L;

    private String loginName;
    private transient String passWord;
    private String userName;
    // get+set
}
// 序列化为二进制数据
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(obj);	// 将该对象序列化为二进制数据
oos.flush();
byte[] bytes = bos.toByteArray();

反序列

对象反序列化(对象字节输入流):ObjectInputStream

作用:读取序列化的对象文件恢复到 Java 对象中

构造器:public ObjectInputStream(InputStream is)

方法:public final Object readObject()

序列化版本号:private static final long serialVersionUID = 2L

注意:序列化使用的版本号和反序列化使用的版本号一致才可以正常反序列化,否则报错

public class SerializeDemo02 {
    public static void main(String[] args) throws Exception {
        InputStream is = new FileInputStream("Demo/src/obj.dat");
        ObjectInputStream ois = new ObjectInputStream(is);
        User user = (User)ois.readObject();//反序列化
        System.out.println(user);
        System.out.println("反序列化完成!");
    }
}
class User implements Serializable {
    // 加入序列版本号
    private static final long serialVersionUID = 1L;
    //........
}

打印流

打印流 PrintStream / PrintWriter

打印流的作用:

  • 可以方便,快速的写数据出去,可以实现打印什么类型,就是什么类型
  • PrintStream/PrintWriter 不光可以打印数据,还可以写字节数据和字符数据出去
  • System.out.print() 底层基于打印流实现的

构造器:

  • public PrintStream(OutputStream os)
  • public PrintStream(String filepath)

System 类:

  • public static void setOut(PrintStream out):让系统的输出流向打印流
public class PrintStreamDemo01 {
    public static void main(String[] args) throws Exception {
        PrintStream ps = new  PrintStream("Demo/src/test.txt");
        ps.println(任何类型的数据);
        ps.print(不换行);
        ps.write("我爱你".getBytes());
        ps.close();
    }
}
public class PrintStreamDemo02 {
    public static void main(String[] args) throws Exception {
        System.out.println("==seazean0==");
        PrintStream ps = new PrintStream("Demo/src/log.txt");
        System.setOut(ps); // 让系统的输出流向打印流
		//不输出在控制台,输出到文件里
        System.out.println("==seazean1==");
        System.out.println("==seazean2==");
    }
}

Close

try-with-resources:

try(
    // 这里只能放置资源对象,用完会自动调用close()关闭
){

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

资源类一定是实现了 Closeable 接口,实现这个接口的类就是资源

有 close() 方法,try-with-resources 会自动调用它的 close() 关闭资源

try(
	/** (1)创建一个字节输入流管道与源文件接通。 */
	InputStream is  = new FileInputStream("D:\\seazean\\图片资源\\meinv.jpg");
	/** (2)创建一个字节输出流与目标文件接通。*/
	OutputStream os = new FileOutputStream("D:\\seazean\\meimei.jpg");
	/** (5)关闭资源!是自动进行的 */
){
	byte[] buffer = new byte[1024];
	int len = 0;
	while((len = is.read(buffer)) != -1){
		os.write(buffer, 0 , len);
	}
	System.out.println("复制完成!");
}catch (Exception e){
	e.printStackTrace();
}