Java SE day 19 IO流（二）

在下张仙人

已于 2022-07-12 04:02:34 修改

阅读量116

点赞数

分类专栏：笔记文章标签： java 开发语言

于 2022-07-11 14:49:53 首次发布

本文链接：https://blog.csdn.net/Zhangxiangyiyi/article/details/125721255

版权

笔记专栏收录该内容

40 篇文章 0 订阅

订阅专栏

IO流(二)

1. 内存流

1.1 什么是内存流

当输出流的目的，和输入流的源是内存时，这样的流称之为内存流。

ByteArrayOutputStream:内存流的输出流

ByteArrayInputStream：内存流的输入流,它是唯一一种能够直接从网络上获取二进制数据的流

CharArrayReader:内存流中的输入流

CharArrayWriter:内存流中的输出流

ByteArrayInputStream主要完成将内容从内存读入程序之中，而ByteArrayOutputStream的功能主要是将数据写入到内存中。

1.2 内存流构造方法

ByteArrayInputStream是输入流的一种实现，它有两个构造函数，每个构造函数都需要一个字节数组来作为其数据源：

ByteArrayInputStream(byte[] buf)

ByteArrayInputStream(byte[] buf,int offse , int length)

ByteArrayOutputStream是输出流的一种实现，它有两个构造函数：

ByteArrayOutputStream()：内存中分配了一个字节数组。

BuyteArrayoutputStream(int)：创建一个新的 byte 数组输出流，它具有指定大小的缓冲区容量（以字节为单位）

1.3 写数据到内存流和从内存流读数据

如果程序在运行过程中要产生一些临时文件，可以采用虚拟文件方式实现（其实是一段内存），JDK中提供了ByteArrayInputStream和ByteArrayOutputStream两个类可实现类似于内存虚拟文件的功能。

通过内存流写数据：

package cn.sz.gl.test05;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class Test {

    public static void writeByteArray(String msg) {
        ByteArrayOutputStream baos = null;

        try {
            baos = new ByteArrayOutputStream();
            baos.write(msg.getBytes());
            baos.flush();

            // 1.通过toString()得到缓冲区数据
            // System.out.println(baos.toString());

            // 2.通过toByteArray()方法得到一个byte数组
            byte[] b = baos.toByteArray();
            String str = new String(b);
            System.out.println("str:" + str);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    public static void main(String[] args) {
        String msg = "hello world";
        Test.writeByteArray(msg);
    }
}

通过内存流读取数据：

package cn.sz.gl.test05;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class Test {

    public static void readByteArray(String msg) {
        ByteArrayOutputStream baos = null;
        ByteArrayInputStream bais = null;

        try {
            baos = new ByteArrayOutputStream();
            baos.write(msg.getBytes());
            baos.flush();

            bais = new ByteArrayInputStream(baos.toByteArray());
            byte [] b = new byte[1024];
            int len = bais.read(b);
            System.out.println("len:"+len);
            String str = new String(b,0,len);
            System.out.println("str:"+str);


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        String msg = "hello world";
        readByteArray(msg);
    }
}

2.缓冲流(处理流)

缓冲流是建立在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，还增加了一些新的方法。

JDK提供四种缓冲流：

BufferedInputStream 可以对任何的InputStream流进行包装

BufferedOutputStream 可以对任何的OutputStream流进行包装

BufferedReader 可以对任何的Reader流进行包装

BufferedWriter 可以对任何的Writer流进行包装

注意：

对于缓冲输出流，写出的数据会先缓存在内存缓冲区中，关闭此流前要用flush()方法将缓存区的数据立刻写出。

关闭过滤流时，会自动关闭缓冲流包装的所有底层流。

2.1 字节缓冲流

字节缓冲分输入缓冲和输出缓冲。

1、缓冲字节输入流：BufferedInputStream。BufferedInputStream为另一个输入流添加一些功能，即缓冲输入以及支持mark 和reset 方法的能力。

2、缓冲字节输出流：BufferedOutputStream。输出字节时，先把要输出的字节输出到缓冲区，当手动调用flush()方法或者缓冲区满或者流关闭时才会把数据输出到结点流。

3、字节缓冲输入流的缓冲区默认大写为8k字节。也可以指定缓冲区大小

2.2 字符缓冲流

字符缓冲分输入缓冲和输出缓冲。

1、 BufferedReader 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 mark和 reset方法。新增了readLine()方法用于一次读取一行字符串(以‘\r’或‘\n’认为一行结束)。

2、 BufferedWriter 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

3、字符缓冲输入流的缓冲区默认大写为8k个字符。也可以指定缓冲区大小。

3. 转换流

前面已经讲过，Java支持字节流和字符流，但有时需要字节流和字符流之间的转换。

InputStreamReader 和OutputStreamWriter，这两个类是将字节流转换为字符流的类，InputStreamReader 可以将一个InputStream转换为Reader，OutputStreamWriter可以将一个OutputStream转换为Writer。

InputStreamReader有两个主要的构造函数：

InputStreamReader(InputStream in)

// 用默认字符集创建一个InputStreamReader对象

InputStreamReader(InputStream in,String CharsetName)

// 接受已指定字符集名的字符串，并用该字符集创建对象

OutputStreamWriter也有对应的两个主要的构造函数：

OutputStreamWriter(OutputStream in)

// 用默认字符集创建一个OutputStreamWriter对象

OutputStreamWriter(OutputStream in,String CharsetNarme)

// 接受已指定字符集名的字符串，并用该字符集创建OutputStreamWriter对象

为了达到最高的效率，避免频繁地进行字符与字节间的相互转换，最好不要直接使用这两个类来进行读写，应尽量使用BufferedWriter类包装OutputStreamWriter类，用BufferedReader类包装InputStreamReader类。例如：

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

BufferedReaderin = new BufferedReader(new InputStreamReader(System.in));

接着从一个实际的应用中来了解InputStreamReader的作用，用一种简单的方式读取键盘上输入的一行字符：

BufferedReader in = newBufferedReader(new InputStreamReader(System.in));

String strLine =in.readLine();

可见，构建BufferedReader对象时，必须传递一个Reader类型的对象作为参数，而键盘对应的System.in是一个InputStream 类型的对象，所以这里需要用到一个InputStreamReader的转换类，将System.in转换成字符流之后，放入到字符流缓冲区之中，之后从缓冲区中每次读入一行数据

例如：
package cn.sz.gl.test05;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test {

    public static void main(String args[]) {
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        while (true) {
            System.out.print("请输入数字：");
            try {
                str = buf.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            int i = -1;
            try {
                i = Integer.parseInt(str);
                i++;
                System.out.println("输入的数字修改后为：" + i);
                break;
            } catch (Exception e) {
                System.out.println("输入的内容不正确，请重新输入！");
            }
        }
    }
}

4. 打印流

4.1 打印流构造方法

在整个IO包中，打印流是输出信息最方便的类，主要包括字节打印流(PrintStream)和字符打印流(PrintWriter)。打印流提供了非常方便的打印功能，可以打印任何的数据类型。如：小数、整数、字符串等。

PrintStream和PrintWriter都属于输出流，分别针对输出字节和字符。

PrintStream和PrintWriter提供了重载的print()、println()方法用于多种数据类型的输出。

PrintStream和PrintWriter不会抛出异常，用户通过检测错误状态获取错误信息。

PrintStream和PrintWriter有自动flush 功能。

·PrintStream类有下面几个构造方法：

PrintStream(OutputStream out)

PrintStream(OutputStream out, boolean auotflush)

PrintStream(OutputStream out, boolean auotflush, String encoding)

·PrintWriter类有下面几个构造方法：

PrintWriter(OutputStream out)

PrintWriter(OutputStream out, boolean autoflush)

PrintWriter(Writer out)

PrintWriter(Writerout, boolean autoflush)

其中autoflush控制在Java中遇到换行符(\n)时是否自动清空缓冲区，encoding是指定编码方式。

4.2 打印流常用方法

PrintWriter即使遇到换行符(\n)也不会自动清空缓冲区，只在设置了autoflush模式下使用了println方法后才自动清空缓冲区。PrintWriter相对PrintStream最有利的一个地方就是println方法的行为，在Windows的文本换行是"\r\n"，而Linux下的文本换行是"\n"，如果希望程序能够生成平台相关的文本换行，而不是在各种平台下都用"\n"作为文本换行，那么就应该使用PrintWriter的println方法时，PrintWriter的println方法能根据不同的操作系统而生成相应的换行符。

控制台打印：
package cn.sz.gl.test05;

import java.io.PrintWriter;

public class Test {

    public static void main(String args[]){
        // 通过System.out为PrintWriter实例化
        PrintWriter out = new PrintWriter(System.out);
        // 向屏幕上输出
        out. println("Hello World!");
        out.close();    //如果此句不写，则没有内容，跟PrintStream有区别
        }
}
在文件中打印：
package cn.sz.gl.test05;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class Test {

    public static void main(String args[]) {
        PrintWriter out = null;
        File f = new File("c:\\temp.txt");
        try {
            // 由FileWriter实例化，则向文件中输出
            out = new PrintWriter(new FileWriter(f));
        } catch (IOException e) {
            e.printStackTrace();
        }
        out.print("Hello World!" + "\r\n");
        out.close();
    }
}

5. 对象流

5.1 对象的序列化

Java序列化是指把Java对象转换为字节序列的过程;而Java反序列化是指把字节序列恢复为Java对象的过程。通过将对象序列化，可以方便的实现对象的传输及保存。

Java序列化是指把Java对象转换为字节序列的过程;而Java反序列化是指把字节序列恢复为Java对象的过程。当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等，而这些数据都会以二进制序列的形式在网络上传送。那么当两个Java进程进行通信时，实现进程间的对象传送，就需要Java序列化与反序列化了。换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送;另一方面，接收方需要从字节序列中恢复出Java对象。

5.2 对象输入流和输出流

在Java中提供了ObjectlnputStream与ObjectOutputStream这两个类用于序列化对象的操作。使用对象输出流输出序列化对象的步骤，有时也称为序列化。使用对象输入流读入对象的过程，有时也称为反序列化。

这两个类是用于存储和读取对象的输入输出流类，不难想象，只要把对象中的所有成员变量都存储起来，就等于保存了这个对象，之后从保存的对象之中再将对象读取进来就可以继续使用此对象。ObjectInputStream与ObjectOutputStream类，可以帮开发者完成保存和读取对象成员变量取值的过程，但要求读写或存储的对象必须实现了java.io.Serializable接口，但Serializable接口中没有定义任何方法，仅仅被用作一种标记，以被编译器作特殊处理。

如下范例所示：
import java.io.*;
public class Person implements Serializable{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return " 姓名："+this.name+"，年龄："+this.age;
    }
}
第2行所中，类Person实现了Serializable接口，所以此类的对象可序列化。下面的范例使用ObjectOutputStream与ObjectInputStream将Person类的对象保存在文件之中
package cn.sz.gl.test05;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class Test {

    // 以下方法为序列化对象方法，将对象保存在文件之中
    public static void serialize(File f) throws Exception{
        OutputStream outputFile = new FileOutputStream(f);
        ObjectOutputStream cout = new ObjectOutputStream(outputFile)
        cout.writeObject(new Person("张三",25));
        cout.close();
    }

    // 以下方法为反序列化对象方法，从文件中读取已经保存的对象
    public static void deserialize(File f) throws Exception {
        InputStream inputFile = new FileInputStream(f);
        ObjectInputStream cin = new ObjectInputStream(inputFile);
        Person p = (Person) cin.readObject();
        System.out.println(p);
    }

    public static void main(String args[]) {
        File f = new File("SerializedPerson");
        serialize(f);
        deserialize(f);
    }
}

5.2.1 serialVersionUID 常量

在对象进行序列化或反序列化操作的时候，要考虑 JDK 版本的问题。如果序列化的 JDK 版本和反序列化的 JDK 版本不统一，则可能造成异常。因此在序列化操作中引入了一个serialVersionUID 的常量来验证版本的一致性。在进行反序列化时，JVM 会把传来的字节流中的 serialVersionUID 与本地相应实体(类)的serialVersionUID 进行比较。如果相同就认为是一致的，可以进行反序列化，否则就会出现反序列化版本不一致的异常

Idea 配置自动生成序列号:

在需要生成序列化id类上: alt + enter

5.2.2 transient关键字

如果不希望类中的属性被序列化，可以在声明属性之前加上transient关键字。如下所示，下面的代码修改自前面所用到的Person.java程序，在声明属性时，前面多加了一个transient关键字

private transient String name;

private transient int age;

注意:

序列化细节:

1) 被序列化的类的内部的所有属性,必须是可序列化的

2) static,transient修饰的属性,不可以被序列化

在下张仙人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java SE day 19 IO流（二）

1.1 什么是内存流1.2 内存流构造方法1.3 写数据到内存流和从内存流读数据2.1 字节缓冲流2.2 字符缓冲流4.1 打印流构造方法4.2 打印流常用方法5.1 对象的序列化5.2 对象输入流和输出流5.2.1 serialVersionUID 常量Idea 配置自动生成序列号: 在需要生成序列化id类上: alt + enter 5.2.2 transient关键字......
复制链接

扫一扫