IO流知识点总结

最新推荐文章于 2024-06-26 11:02:57 发布

外星喵

最新推荐文章于 2024-06-26 11:02:57 发布

阅读量1.4k

点赞数 5

分类专栏：深入java基础文章标签： io 序列号缓冲流

本文链接：https://blog.csdn.net/c15158032319/article/details/79628990

版权

深入java基础专栏收录该内容

32 篇文章 6 订阅

订阅专栏

IO 流介绍

什么是IO流

流是一种抽象概念，它代表了数据的无结构化传输，指一连串流动的符号,是以先进先出方式发送信息的通道。

IO 流对应的就是 Input 和 Output，也就是输入和输出。输入和输出这个概念是针对于应用程序而言，比如当前程序中需要读取文件中的内容，那么这就是输入，而如果需要将应用程序本身的数据发送到其他应用，就对应了输出。

发展过程

java1.0 版本中，I/O 库中与输入有关的所有类都将继承 InputStream，与输出有关的所有类继承 OutputStream，用以操作二进制数据。
java1.1 版本对 I/O 库进行了修改：在原先的库中新增了新类，如 ObjectInputStream 和 ObjectOutputStream。增加了 Reader 和 Writer，提供了兼容 Unicode 与面向字符的 I/O 功能。在 Reader 和 Writer 类层次结构中，提供了使字符与字节相互转化的类，OutputStreamWriter 和 InputStreamReader。
两个不同的继承层次结构拥有相似的行为，它们都提供了读（read)和写（write)的方法，针对不同的情况，提供的方法也是类似的。
java1.4 版本的 java.nio.*包中引入新的 I/O 类库，这部分以后再做学习。

lO流的分类

按流向分

输出流：OutputStream和Writer类
输入流：InputStream和Reader类

按处理数据单元划分：

字节流：InputStream和OutputStream类
字符流：Reader和Writer类

字节流是 8 位通用字节流，字符流是16位Unicode字符流。只要是处理纯文本数据，就优先考虑使用字符流（效率高），除此之外都使用字节流（无损传输）。

字节流

字节流读取的基本单位为字节，采用的是 ASCII 编码，通常用来处理二进制数据，其顶层抽象类为 InputStream 和 OutputStream。

Java 中的流家族非常庞大，提供了非常多的具有不同功能的流，在实际应用中我们可以选择不同的组合达到目的。比如当我们需要读取一个二进制文件，那么就需要使用 DataInputStream，而 DataInputStream 本身不具备直接读取文件内容的功能，所以需要结合 FileInputStream

字节输入流 InputStream

InputStream：字节输入流基类。

常用方法：

    // 从输入流中读取数据的下一个字节
    abstract int read()
    // 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
    int read(byte[] b)
    // 将输入流中最多 len 个数据字节读入 byte 数组
    int read(byte[] b, int off, int len)
    // 跳过和丢弃此输入流中数据的 n个字节
    long skip(long n)
    // 关闭此输入流并释放与该流关联的所有系统资源
    void close()

字节数组 char[] 作为输入源的 Input Stream 类是——ByteArrayInputStream
用文件作为输入源的 Input Stream 类——FileInputStream
用字符串作为输入源——StringBufferInputStream
用于多线程之间管道通信的输入源——PipeInputStream

FileInputStream

FileInputStream fin = new FileInputStream("E:\\test.txt");
DataInputStream din = new DataInputStream(fin);
System.out.println(din.readInt());

文件赋值：

public class TestCopy1 {
 
       public static void main(String[] args) throws IOException {
               //创建一个输入流和输出流
//                File file = new File("e:/readme.txt");
//                InputStream is = new FileInputStream(file);
               InputStream is = new FileInputStream(new File("e:/readme.txt"));
//                File file2 = new File("e:\readme2.txt");
//                OutputStream os = new FileOutputStream(file2);
               OutputStream os = new FileOutputStream(new File("e:\\readme2.txt"));
               
               //使用输入流和输出流完成文件复制
               int n;//中转站，比较小（水杯）
              
               //读一个字节
               n = is.read();//从输入流读取一个字节的内容赋给n
               while(n != -1){//没有到达末尾
                       //写一个字节
                       os.write(n);
                       //输出一个字节
                       //System.out.print((char)n);
                       
                       //读一个字节
                       n = is.read();
               }                      
               //关闭输入流和输出流
               is.close();
               os.close();
       }
}

BufferedInputStream

同时，如果我们想要使用缓冲机制，又可以进一步组装 BufferedInputStream：

FileInputStream fin = new FileInputStream("E:\\test.txt");
DataInputStream din = new DataInputStream(new BufferedInputStream(fin));
System.out.println(din.readInt());

PushbackInputStream

还有一种流比较有意思，那就是 PushbackInputStream，这个流可以将读出来的数据重新推回到流中：

public class Demo03 {
    public static void main(String[] args) throws IOException {
        FileInputStream fin = new FileInputStream("E:\\test.txt");//文档内存储 abcd
        PushbackInputStream pin = new PushbackInputStream(new BufferedInputStream(fin));
        int a = pin.read();//读取到a
        System.out.println(a);
        if (a != 'b'){
            pin.unread(a);//将 a 推回流中
        }
        System.out.println(pin.read());//再次读取到 a
        System.out.println(pin.read());//读取到 b
        System.out.println(pin.read());// 读取到 c
    }
}

FilterInputStream

用于装饰上面这些输入流的，可以叠加，每装饰一层就相当于增加了 1 个功能。

InputStream inputStream = new FilterInputStream(InputStream)

装饰后，不仅可读字符串，还可读取例如 int、long 等 java 基本类型的是————DataInputStream

DataInputStream 里面会支持 readInt、readLong 等方法。

装饰后，支持分批缓冲读取读取的是————BufferedInputStream

创建 BufferedInputStream 时，我们会通过它的构造函数指定某个输入流为参数。BufferedInputStream 会将该输入流数据分批读取，每次读取一部分到缓冲中；操作完缓冲中的这部分数据之后，再从输入流中读取下一部分的数据。

其他：

PushbackInputStream：具有 1 个能回退上一个字节的缓冲区

ObjectInputStream ：一般用于反序列化读入

LineNumberInputStream：可跟踪输入流中的行号

字节输出流 OutputStream

OutputStream：字节输出流基类。

OutputStream 包含 ByteArrayOutputStream 输出到缓冲区 FileOutputStream 写到文件 PipedOutputStream 写入管道 FilterOutputStream
而 FilterOutputStream 包含

DataOutputStream （可以 out.writexxx 各种类型的数据，writeDouble， writeUTF， reader 也一样，可以读想要的数据类型）、
PringtStream （输出到文件用这个，该类.println(str)即可写入文件）
BufferOutputString

    // 将 b.length 个字节从指定的 byte 数组写入此输出流
    void write(byte[] b)
    // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
    void write(byte[] b, int off, int len)
    // 将指定的字节写入此输出流
    abstract void write(int b)
    // 关闭此输出流并释放与此流有关的所有系统资源
    void close()
    // 刷新此输出流并强制写出所有缓冲的输出字节
    void flush()

字符流

Reader/Writer 提供兼容 Unicode、面向字符的 IO 功能，为了国际化，可以直接读/写char 数组或者 String

字符输入流Reader

Reader 是用于读取字符流的抽象类

BufferedReader

IO 操作是一个比较耗时的操作，而字节流的 read 方法一次只能返回一个字节，那么当我们需要读取多个字节时就会出现每次读取都要进行一次 IO 操作，而缓冲流内部定义了一个大小为 8192 的 byte 数组，当我们使用了缓冲流时，读取数据的时候则会一次性最多读取 8192 个字节放到内存，然后一个个依次返回，这样就大大减少了 IO 次数；同样的，写数据时，缓冲流会将数据先写到内存，当我们写完需要写的数据时再一次性刷新到指定位置，如磁盘等。

    public static void main(String[] args) throws Exception {
        //字节流
        FileInputStream fin = new FileInputStream("E:\\test.txt");
        System.out.println(fin.read());//372
        //字符流

        InputStreamReader ir = new InputStreamReader(new FileInputStream("E:\\test.txt"));
        System.out.println(ir.read());//21452
        char s = '双';
        System.out.println((int)s);//21452
    }

输出之后可以很明显看出区别，字节流一次读入一个字节，而字符流一次读入一个字符。

当然，我们也可以采用自由组合的方式来更灵活的进行字符读取，比如我们结合 BufferedReader 来读取一整行数据：

    public static void main(String[] args) throws Exception {
        InputStreamReader ir = new InputStreamReader(new FileInputStream("E:\\test.txt"));
        BufferedReader br = new BufferedReader(ir);
        String s;
        while (null != (s = br.readLine())){
            System.out.println(s);
        }
    }

字符输入流Writer

BufferedWriter

BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

PrintWriter

文本输出，我们用的最多的就是 PrintWriter，这个类我想绝大部分朋友都使用过：

public static void main(String[] args) throws Exception{
    PrintWriter printWriter = new PrintWriter("E:\\test3.txt");
    printWriter.write("1234");
    printWriter.flush();
}

这里和字节流的区别就是写完之后需要手动调用 flush 方法，否则数据就会丢失，并不会写到文件中。

为什么字符流需要 flush，而字节流不需要

字节流不需要 flush 操作是因为字节流直接操作的是字节，中途不需要做任何转换，所以直接就可以操作文件，而字符流，说到底，其底层还是字节流，但是字符流帮我们将字节转换成了字符，这个转换需要依赖字符表，所以就需要在字符和字节完成转换之后通过 flush 操作刷到磁盘中。【参考文献】

需要注意的是，字节输出流最顶层类 OutputStream 中也提供了 flush 方法，但是它是一个空的方法，如果有子类有需要，也可以实现 flush 方法。

RandomAccessFile

RandomAccessFile 是一个随机访问文件类，其可以在文件中的任意位置查找或者写入数据。

    public static void main(String[] args) throws Exception {
        //文档内容为 lonely wolf
        RandomAccessFile inOut = new RandomAccessFile(new File("E:\\test.txt"),"rw");
        System.out.println("当前指针在：" + inOut.getFilePointer());//默认在0
        System.out.println((char) inOut.read());//读到 l
        System.out.println("当前指针在：" + inOut.getFilePointer());
        inOut.seek(7L);//指针跳转到7的位置
        System.out.println((char) inOut.read());//读到 w
        inOut.seek(7);//跳回到 7
        inOut.write(new byte[]{'c','h','i','n','a'});//写入 china,此时 wolf被覆盖
        inOut.seek(7);//继续跳回到 7
        System.out.println((char) inOut.read());//此时因为 wolf 被 china覆盖，所以读到 c
    }

根据上面的示例中的输出结果，可以看到 RandomAccessFile 类可以随机指定指针，并随机进行读写，功能非常强大。

另外需要说明的是，构造 RandomAccessFile 时需要传入一个模式，模式主要有 4 种：

r：只读模式。此时调用任何 write 相关方法，会抛出 IOException。
rw：读写模式。支持读写，如果文件不存在，则会创建。
rws：读写模式。每当进行写操作，会将内容或者元数据同步刷新到磁盘。
rwd：读写模式。每当进行写操作时，会将变动的内容用同步刷新到磁盘。

标准/系统流

程序的所有输入都可以来自于标准输入，所有输出都可以发送到标准输出，所有错误信息都可以发送到标准错误。

针对设备交互，JDK提供了3个可以直接使用的流对象，分别是：

System.in（标准输入）
System.out（标准输出）
System.err（标准错误输出）

标准输入

import java.io.*;
 
public class Main {
    public static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in),32768));
    public static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 
    public static double nextDouble() throws IOException{ in.nextToken(); return in.nval; }
    public static float nextFloat() throws IOException{ in.nextToken(); return (float)in.nval; }
    public static int nextInt() throws IOException{ in.nextToken(); return (int)in.nval; }
    public static String next() throws IOException{ in.nextToken(); return in.sval;}
 
    public static void main(String[] args) throws IOException{
//        获取输入
        while(in.nextToken()!=StreamTokenizer.TT_EOF){
            break;
        }
        int x = (int)in.nextToken();  //第一个数据应当通过nextToken()获取
        
        int y = nextInt();
        float f = nextFloat();
        double d = nextDouble();
        String str = next();
 
//        输出
        out.println("abc");
        out.flush();
        out.close();
    }
}

标准输出

/**
*
* System.out 是PrintStream类的一个实例
*                public final static PrintStream out = null;
*                                                    Student  stu  = null；
*
* PrintStream 输出流  字节流  处理流
*                打印流只有输出流，没有输入流
*
*
* PrintStream类的方法println() 这个方法功能简直太强大了！！！
*        可以直接讲各种数据类型（基本数据类型、引用数据类型）直接写入到文件中，并且换行。太方便了，太强大了！！
*  不管什么类型，写入到文件中全部变成字符串
*  缺点1： 123#3.14#true#bjsxt  需要使用特殊的字符来区分各个内容，防止混淆
*  缺点2： 123#3.14#true======="123"  "3.14"  "true"  读出来之后都是字符串，还需要将字符串转换成真实类型
*  
*  DataInputStream和DataOutputStream
*
*/
public class TestPrintStream {
 
       public static void main(String[] args) throws FileNotFoundException {
               
               //PrintStream ps = System.out;
               PrintStream ps = new PrintStream(new FileOutputStream(new File("e:/bjsxt.txt")));
               ps.println(123);
               ps.println('A');
               ps.println(3.14);
               ps.println(true);
               ps.println("bjsxt");
               ps.println(new Date().toString());
             
               OutputStream os =new FileOutputStream(new File("e:/bjsxt.txt")); 
               
//                os.write(一个字节);
//                String datestr = new Date().toString();;
//                byte [] buf = datestr.getBytes();
//                os.write(buf);
//                BufferedWriter bw;
//                bw.newLine();
 
               ps.close();
       }
       
       public void method1(){
               PrintStream ps = System.out;
               ps.println(123);
               ps.println('A');
               ps.println(3.14);
               ps.println(true);
               ps.println("111");
               ps.println(new Date().toString());
               
       }
       
       public void method2(){
       			
               PrintWriter pw1 = new PrintWriter(new FileWriter("e:/bjsxt.txt"));
               
               PrintWriter pw2 = new PrintWriter(new FileOutputStream("e:/bjsxt.txt"));
               
               PrintWriter pw3 = new PrintWriter(new File("e:/bjsxt.txt"));
               
               PrintWriter pw = new PrintWriter("e:/bjsxt.txt");
               pw.println(123);
               pw.println('A');
               pw.println(3.14);
               pw.println(true);
               pw.println("1111t");
               pw.println(new Date().toString());
               pw.close();

       }
 
}

Scanner 读取

Scanner 实际上还是对 System.in 进行了封装，并提供了一系列方法来读取不同的字符类型，比如 nextInt，nextFloat，以及 next 等。

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    while (scanner.hasNextInt()){
        System.out.println(scanner.nextInt());
    }
}

IO流中的异常处理

注意上面的示例为了方便我都是直接抛出了异常。

无论流操作成功与否，关流操作都需要进行，所以需要将关流操作放到 finally 代码块中。
为了让流对象在 finally 中依然能够使用，所以需要将流对象放在 try 之外声明并且赋值为 null，然后在 try 之内进行实际的初始化过程。
在关流之前要判断流对象是否初始化成功，实际就是判断流对象是否为 null。writer!=null 时才执行关流操作。
关流可能会失败，此时流依然会占用文件，所以需要将流对象置为 null，标记为垃圾对象进行强制回收以释放文件。
如果流有缓冲区，为了防止关流失败导致没有进行自动冲刷，所以需要手动冲刷一次，以防止有数据死在缓冲区而产生数据的丢失。

    //将流对象放在try之外声明，并附为null，保证编译，可以调用close    
    FileWriter writer = null;    
    try {        //将流对象放在里面初始化        
    writer = new FileWriter("D:\\b.txt");        
    writer.write("abc");                //防止关流失败，没有自动冲刷，导致数据丢失        
    writer.flush();            
    } catch (IOException e) {        
    	e.printStackTrace();    
    } finally {        //判断writer对象是否成功初始化        
    if(writer!=null) {            //关流，无论成功与否            
    try {                
    writer.close();            
    } catch (IOException e) {                
    e.printStackTrace();            
    }finally {                //无论关流成功与否，都是有意义的：标为垃圾对象，强制回收                writer = null;            
    }        
    }    
  }

JDK1.7 提出了对流进行异常处理的新方式，任何 AutoClosable 类型的对象都可以用于 try-with-resourses 语法，实现自动关闭。

要求处理的对象的声明过程必须在 try 后跟的()中，在 try 代码块之外。

try(FileWriter writer = new FileWriter("D:\\c.txt")){   
	writer.write("abc");
}catch (IOException e){    
	e.printStackTrace();
}

IO流中使用的设计模式

装饰设计模式

缓冲流基于装饰设计模式，即利用同类对象构建本类对象，在本类中进行功能的改变或者增强。

例如，BufferedReader 本身就是 Reader 对象，它接收了一个 Reader 对象构建自身，自身提供缓冲区和其他新增方法，通过减少磁盘读写次数来提高输入和输出的速度。

适配器设计模式

缓冲流基于适配器设计模式，将某个类的接口转换另一个用户所希望的类的接口，让原本由于接口不兼容而不能在一起工作的类可以在一起进行工作。

以 OutputStreamWriter 为例，构建该转换流时需要传入一个字节流，而写入的数据最开始是由字符形式给定的，也就是说该转换流实现了从字符向字节的转换，让两个不同的类在一起共同办事。

序列化

对象序列化的目标是将对象保存在磁盘中，或允许在网络中直接传输对象。对象序列化机制允许把内存中的 Java 对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，通过网络将这种二进制流传输到另一个网络节点。其他程序一旦获得了这种流，都可以将这种二进制流恢复为原来的 Java 对象。

序列化/反序列化流

序列化：将对象转化为字节数组的过程。
反序列化：将字节数组还原回对象的过程。

自定义序列化

// 实现writeObject和readObject两个方法@Data@AllArgsConstructor@NoArgsConstructorpublic 
class Person implements Serializable {
    private String name;    
    private int age;
    // 将name的值反转后写入二进制流    
    private void writeObject(ObjectOutputStream out) throws IOException {        		 
    	out.writeObject(new StringBuffer(name).reverse());        
    	out.writeInt(age);    
    }
    // 将读取的字符串反转后赋给name    
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {        
    	this.name = ((StringBuffer) in.readObject()).reverse().toString();        
    	this.age = in.readInt();    
    }
 }

关于版本号

一个类如果允许被序列化，那么这个类中会产生一个版本号 serialVersonUID。如果没有手动指定版本号，那么在编译的时候自动根据当前类中的属性和方法计算一个版本号，也就意味着一旦类中的属性发生改变，就会重新计算新的，导致前后不一致。但是，手动指定版本号的好处就是，不需要再计算版本号。
版本号的意义在于防止类产生改动导致已经序列化出去的对象无法反序列化回来。版本号必须用 static final 修饰，本身必须是 long 类型。

序列化相关问题

Q：对某对象进行序列化时，如何让里面某个敏感成员不被序列化？

方法一：可使用 transient 关键字处理那个敏感成员
方法二：可以通过覆盖 Serializable 接口的 writeObject 和 readObject 来实现序列化，但是方法签名必须是 private void writeObject(ObjetOutputStream stream) throw IOException;
方法三：实现 Externalizable 接口，可自定义实现 writeExternal 以及 readExternal 方法

Q： Externalizable 和 Serializable 哪个快？A： Externalizable 更快。

Q： Externalizable 需要产生序列化 ID 吗？

A：采用 Externalizable 无需产生序列化 ID（serialVersionUID）~而 Serializable 接口则需要

外星喵

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
IO流知识点总结

流是一种抽象概念，它代表了数据的无结构化传输，指一连串流动的符号,是以先进先出方式发送信息的通道。IO 流对应的就是 Input 和 Output，也就是输入和输出。输入和输出这个概念是针对于应用程序而言，比如当前程序中需要读取文件中的内容，那么这就是输入，而如果需要将应用程序本身的数据发送到其他应用，就对应了输出。
复制链接

扫一扫

专栏目录