1.4.2 IO流

于 2021-07-30 22:06:37 发布
阅读量70 收藏
点赞数
分类专栏： java笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyuluo69582/article/details/117970209
版权
本文详细介绍了Java IO流的概念、分类、核心类如FileWriter、FileReader、FileOutputStream、FileInputStream等，重点讲解了对象流(ObjectOutputStream和ObjectInputStream)、字符编码、随机访问文件以及案例演示。
摘要由CSDN通过智能技术生成

IO流

一、IO流的概念

  • IO就是Input和Output的简写，也就是输入和输出的含义。
  • IO流就是指读写数据时像流水一样从一端流到另外一端，因此得名为“流"。

二、基本分类

  • 按照读写数据的基本单位不同，分为 字节流 和 字符流。
    其中字节流主要指以字节为单位进行数据读写的流，可以读写任意类型的文件。
    其中字符流主要指以字符(2个字节)为单位进行数据读写的流，只能读写文本文件。
  • 按照读写数据的方向不同，分为 输入流 和 输出流（站在程序的角度）。
    其中输入流主要指从文件中读取数据内容输入到程序中，也就是读文件。
    其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。
  • 按照流的角色不同分为节点流和处理流。
    其中节点流主要指直接和输入输出源对接的流。
    其中处理流主要指需要建立在节点流的基础之上的流。

三、体系结构

分类字节输入流字节输出流字符输入流字符输出流
抽象基类InputStreamOutputStreamReaderWriter
访问文件FileStreamFileOutputStreamFileReaderFileWriter
访问数组ByteArrayInputStreamByteArrayOutputStreamCharArrayReaderCharArrayWriter
访问管道PipeInputStreamPipeOutputStreamPipeReaderPipeWriter
访问字符串––StringReaderStringWriter
缓冲流BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWriter
转换流––InputStreamReaderOutputStreamWriter
对象流ObjectInputStreamObjectOutputStream––
FilterInputStreamFilterOutputStreamFilterReaderFilterWriter
打印流–PrintStream–PrintWriter
推回输入流PushbackInputStream–PushbackReader–
特殊流DataInputStreamDataOutputStream

在这里插入图片描述

四、相关流的详解

1.FileWriter类

（1）基本概念

  • java.io.FileWriter类主要用于将文本内容写入到文本文件。

（2）常用的方法

方法声明功能介绍
FileWriter(String fileName)根据参数指定的文件名构造对象
FileWriter(String fileName, boolean append)以追加的方式根据参数指定的文件名来构造对象
void write(int c)写入单个字符
void write(char[] cbuf, int off, int len)将指定字符数组中从偏移量off开始的len个字符写入此文件输出流
void write(char[] cbuf)将cbuf.length个字符从指定字符数组写入此文件输出流中
void flush()刷新流
void close()关闭流对象并释放有关的资源

2.FileReader类

（1）基本概念

  • java.io.FileReader类主要用于从文本文件读取文本数据内容。

（2）常用的方法

方法声明功能介绍
FileReader(String fileName)根据参数指定的文件名构造对象
int read()读取单个字符的数据并返回，返回-1表示读取到末尾
int read(char[] cbuf, int offset, int length)从输入流中将最多len个字符的数据读入一个字符数组中，返回读取到的字符个数，返回-1表示读取到末尾
int read(char[] cbuf)从此输入流中将最多 cbuf.length 个字符的数据读入字符数组中，返回读取到的字符个数，返回-1表示读取到末尾
void close()关闭流对象并释放有关的资源
import java.io.FileReader;
import java.io.IOException;

public class FileReaderTest {

    public static void main(String[] args) {
        FileReader fr = null;

        try {
            //1.构造FileReader类型的对象与d:/a.txt文件关联
            fr = new FileReader("d:/a.txt");
            //2.读取数据内容并打印
            /*int res = fr.read();
            System.out.println("读取到的单个字符是：" + (char)res);*/
            /*int res = 0;
            while ((res = fr.read()) != -1){
                System.out.println("读取到的单个字符是：" + (char)res);
            }*/

            //准备一个字符数组来保存读取到的数据内容
            char[] cArr = new char[5];
            //期望杜曼字符数组中的一部分空间  也就是读取3个字符放入数组cArr中下标从1开始的位置上
            /*int res = fr.read(cArr,1,3);
            System.out.println("实际读取到的字符个数是：" + res);//3
            for (char cv : cArr){
                System.out.println("读取到的单个字符是：" + (char)cv);//啥也没有 a e l 啥也没有
            }*/
            //期望读满整个字符数组
            int res = fr.read(cArr);
            System.out.println("实际读取到的字符个数是：" + res);//5
            for (char cv : cArr){
                System.out.println("读取到的单个字符是：" + (char)cv);// a e l l h
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //3.关闭流对象并释放有关的资源
            if (null != fr) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件的拷贝

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileCharCopyTest {

    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;

        try {
            //1.创建FileReader类型的对象与d:/a.txt文件关联
            fr = new FileReader("d:/a.txt");
            //fr = new FileReader("d:/IO流.png");
            //2.创建FileWriter类型的对象与d:/a.txt文件关联
            fw = new FileWriter("d:/b.txt");
            //fw = new FileWriter("d:/IO流1.png");   拷贝图片文件失败！！！
            //3.不断地从输入流中读取数据内容并写入到输出流中
            System.out.println("正在玩命地拷贝。。。");
            int res = 0;
            while((res = fr.read()) != -1){
                fw.write(res);
            }
            System.out.println("拷贝文件成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4.关闭流对象并释放有关的资源
        if (null != fw) {
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (null != fr){
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        }
    }
}

3.FileOutputStream类（重点）

（1）基本概念

  • java.io.FileOutputStream类主要用于将图像数据之类的原始字节流写入到输出流中。

（2）常用的方法

方法声明功能介绍
FileOutputStream(String name)根据参数指定的文件名来构造对象
FileOutputStream(String name,boolean append)以追加的方式根据参数指定的文件名来构造对象
void write(int b)将指定字节写入此文件输出流
void write(byte[] b, int off, int len)将指定字节数组中从偏移量off开始的len个字节写入此文件输出流
void write(byte[] b)将 b.length 个字节从指定字节数组写入此文件输出流中
void flush()刷新此输出流并强制写出任何缓冲的输出字节
void close()关闭流对象并释放有关的资源

4.FileInputStream类（重点）

（1）基本概念

java.io.FileInputStream类主要用于从输入流中以字节流的方式读取图像数据等。

（2）常用的方法

方法声明功能介绍
FileInputStream(String name)根据参数指定的文件路径名来构造对象
int read()从输入流中读取单个字节的数据并返回，返回-1表示读取到末尾
int read(byte[] b, int off, int len)从此输入流中将最多len个字节的数据读入字节数组中，返回读取到的字节个数，返回-1表示读取到末尾
int read(byte[] b)从此输入流中将最多 b.length 个字节的数据读入字节数组中，返回读取到的字节个数，返回-1表示读取到末尾
void close()关闭流对象并释放有关的资源
int available()获取输入流所关联文件的大小

案例题目

编程实现两个文件之间的拷贝功能

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileByteCopyTest {

    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            //1.创建FileInputStream类型的对象与d:/IO流.png文件关联
            fis = new FileInputStream("d:/IO流.png");
            //2.创建FileOutputStream类型的对象与d:/IO流1.png关联
            fos = new FileOutputStream("d:/IO流1.png");
            //3.不断地从输入流中读取数据内容并写入到输出流中
            System.out.println("正在玩命地拷贝。。。");
            //方式一：以单个字节为单位进行拷贝，也就是每次读取一个字节后再写入一个字节
            //缺点：文件稍大时，拷贝的效率很低
            /*int res = 0;
            while ((res = fis.read()) != -1){
                fos.write(res);
            }*/
            //方式二：准备一个和文件大小一样的缓冲区，一次性将文件中的所有内容取到缓冲区然后一次性写入进去
            //缺点：若文件过大时：无法申请和文件大小一样的缓冲区，真实物理内存不足
            /*int len = fis.available();
            System.out.println("获取到的文件大小是：" + len);
            byte[] bArr = new byte[len];
            int res = fis.read(bArr);
            System.out.println("实际读取到的文件大小是：" + res);
            fos.write(bArr);*/
            //方式三：准备一个相对适当的缓冲区，分多次将文件拷贝完成
            byte[] bArr = new byte[1024];//一般用1024整数倍
            int res = 0;
            while ((res = fis.read(bArr)) != -1){
                fos.write(bArr,0,res);
            }

            System.out.println("拷贝文件成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4.关闭流对象并释放有关的资源
        if (null != fis){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (null != fos){
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        }
    }
}

5.BufferedOutputStream类

（1）基本概念

java.io.BufferedOutputStream类主要用于描述缓冲输出流，此时不用为写入的每个字节调用底层系统。

（2）常用的方法

方法声明功能介绍
BufferedOutputStream(OutputStream out)根据参数指定的引用来构造对象
BufferedOutputStream(OutputStream out, int size)根据参数指定的引用和缓冲区大小来构造对象
void write(int b)写入单个字节
void write(byte[] b, int off, int len)写入字节数组中的一部分数据
void write(byte[] b)写入参数指定的整个字节数组
void flush()刷新流
void close()关闭流对象并释放有关的资源

6.BufferedInputStream类

（1）基本概念

java.io.BufferedInputStream类主要用于描述缓冲输入流。

（2）常用的方法

方法声明功能介绍
BufferedInputStream(InputStream in)根据参数指定的引用构造对象
BufferedInputStream(InputStream in, int size)根据参数指定的引用和缓冲区大小构造对象
int read()读取单个字节
int read(byte[] b, int off, int len)读取len个字节
int read(byte[] b)读取b.length个字节
void close()关闭流对象并释放有关的资源
import java.io.*;

public class BufferedByteCopyTest {

    public static void main(String[] args) {
        
        //获取当前时间距离1970年0时0分0秒的毫秒数
        long g1 = System.currentTimeMillis();
        
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            //1.创建BufferedInputStream类型的对象与d:/02_IO流的框架结构.mp4文件关联
            bis = new BufferedInputStream(new FileInputStream("d:/02_IO流的框架结构.mp4"));
            //2.创建BufferedOutputStream类型的对象与d:/IO流的框架结构.mp4文件关联
            bos = new BufferedOutputStream(new FileOutputStream("d:/IO流的框架结构.mp4"));
            //3.不断地从输入流中读取数据并写入到输出流中
            System.out.println("正在玩命地拷贝。。。");

            byte[] bArr = new byte[1024];//一般用1024整数倍
            int res = 0;
            while ((res = bis.read(bArr)) != -1){
                bos.write(bArr,0,res);
            }
            System.out.println("拷贝文件成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4.关闭流对象并释放有关的内容
        if (null != bos) {
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (null != bis) {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        }
        long g2 = System.currentTimeMillis();
        System.out.println("使用缓冲区拷贝视频文件消耗的时间为：" + (g2 - g1));
      
    }
}

使用以下代码测试缓冲字节流和文件字节流的效率

//获取当前时间距离1970年0时0分0秒的毫秒数
        long g1 = System.currentTimeMillis();

		//代码尾部
 		long g2 = System.currentTimeMillis();
        System.out.println("使用缓冲区拷贝视频文件消耗的时间为：" + (g2 - g1));

经过测试发现缓冲字节流比文件字节流快很多。

7.BufferedWriter类

（1）基本概念

java.io.BufferedWriter类主要用于写入单个字符、字符数组以及字符串到输出流中。

（2）常用的方法

方法声明功能介绍
BufferedWriter(Writer out)根据参数指定的引用来构造对象
BufferedWriter(Writer out, int sz)根据参数指定的引用和缓冲区大小来构造对象
void write(int c)写入单个字符到输出流中
void write(char[] cbuf, int off, int len)将字符数组cbuf中从下标off开始的len个字符写入输出流中
void write(char[] cbuf)将字符串数组cbuf中所有内容写入输出流中
void write(String s, int off, int len)将参数s中下标从off开始的len个字符写入输出流中
void write(String str)将参数指定的字符串内容写入输出流中
void newLine()用于写入行分隔符到输出流中
void flush()刷新流
void close()关闭流对象并释放有关的资源

8. BufferedReader类

（1）基本概念

java.io.BufferedReader类用于从输入流中读取单个字符、字符数组以及字符串。

（2）常用的方法

方法声明功能介绍
BufferedReader(Reader in)根据参数指定的引用来构造对象
BufferedReader(Reader in, int sz)根据参数指定的引用和缓冲区大小来构造对象
int read()从输入流读取单个字符，读取到末尾则返回-1，否则返回实际读取到的字符内容
int read(char[] cbuf, int off, int len)从输入流中读取len个字符放入数组cbuf中下标从off开始的位置上，若读取到末尾则返回-1，否则返回实际读取到的字符个数
int read(char[] cbuf)从输入流中读满整个数组cbuf
String readLine()读取一行字符串并返回，返回null表示读取到末尾
void close()关闭流对象并释放有关的资源
import java.io.*;

public class BufferedCharCopyTest {

    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;

        try {
            //1.创建BufferedReader类型的对象与d:/a.txt文件关联
            br = new BufferedReader(new FileReader("d:/a.txt"));
            //2.创建BufferedWriter类型的对象与d:/b.txt文件关联
            bw = new BufferedWriter(new FileWriter("d:/b.txt"));
            //3.不断地从输入流中读取一行字符串并写入到输出流中
            System.out.println("正在玩命地拷贝。。。");
            String str = null;
            while ((str = br.readLine()) != null){
                bw.write(str);
                bw.newLine();//当前系统中的行分割符是：\r\n
            }
            System.out.println("拷贝文件成功1");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流对象并释放有关的资源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != bw) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

9. PrintStream类

（1）基本概念

java.io.PrintStream类主要用于更加方便地打印各种数据内容。

（2）常用的方法

方法声明功能介绍
PrintStream(OutputStream out)根据参数指定的引用来构造对象
void print(String s)用于将参数指定的字符串内容打印出来
void println(String x)用于打印字符串后并终止该行
void flush()刷新流
void close()用于关闭输出流并释放有关的资源

10. PrintWriter类

（1）基本概念

java.io.PrintWriter类主要用于将对象的格式化形式打印到文本输出流。

（2）常用的方法

方法声明功能介绍
PrintWriter(Writer out)根据参数指定的引用来构造对象
void print(String s)将参数指定的字符串内容打印出来
void println(String x)打印字符串后并终止该行
void flush()刷新流
void close()关闭流对象并释放有关的资源

案例题目

不断地提示用户输入要发送的内容，若发送的内容是"bye"则聊天结束，否则将用户输入的内容写入到文件d:/a.txt中。
要求使用BufferedReader类来读取键盘的输入 System.in代表键盘输入
要求使用PrintStream类负责将数据写入文件

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;

public class PrintStreamChatTest {

    public static void main(String[] args) {

        //由手册可知：构造方法需要的是Reader类型的引用，但Reader类是个抽象类，实参只能传递子类的对象  字符流
        //有手册可知：System.in代表键盘输入，而且是InputStream类型的
        BufferedReader br = null;
        PrintStream ps = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            ps = new PrintStream(new FileOutputStream("d:/a.txt",true));

            //声明一个boolean类型的变量作为发送方的代表
            boolean flag = true;

            while (true) {
                //1.提示用户输入要发送的聊天内容并使用变量记录
                System.out.println("请" + (flag?"张三":"李四") + "输入要发送的聊天内容：");
                String str = br.readLine();
                //2.判断用户输入的内容是否为“bye”，若是则聊天结束
                if ("bye".equals(str)) {
                    System.out.println("聊天结束!");
                    break;
                }
                //3.若不是则将用户输入的内容写入到文件d:/a.txt中
                //else {
                //获取当前系统时间并调整格式
                Date d1 = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

                ps.println(sdf.format(d1) + (flag?" 张三说：":" 李四说：") + str);
                //}
                flag = !flag;
            }
            ps.println();//写入空行  与之前的聊天记录隔开
            ps.println();
            ps.println();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流对象并释放有关的资源
            if (null != ps) {
                ps.close();
            }
            if(null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

11. OutputStreamWriter类

（1）基本概念

java.io.OutputStreamWriter类主要用于实现从字符流到字节流的转换。

（2）常用的方法

方法声明功能介绍
OutputStreamWriter(OutputStream out)根据参数指定的引用来构造对象
OutputStreamWriter(OutputStream out, String charsetName)根据参数指定的引用和编码构造对象
void write(String str)将参数指定的字符串写入
void flush()刷新流
void close()用于关闭输出流并释放有关的资源

12. InputStreamReader类

（1）基本概念

java.io.InputStreamReader类主要用于实现从字节流到字符流的转换。

（2）常用的方法

方法声明功能介绍
InputStreamReader(InputStream in)根据参数指定的引用来构造对象
InputStreamReader(InputStream in, String charsetName)根据参数指定的引用和编码来构造对象
int read(char[] cbuf)读取字符数据到参数指定的数组
void close()用于关闭输出流并释放有关的资源

13. 字符编码

（1）编码表的由来

  • 计算机只能识别二进制数据，早期就是电信号。为了方便计算机可以识别各个国家的文字，就需要将各个国家的文字采用数字编号的方式进行描述并建立对应的关系表，该表就叫做编码表。

（2）常见的编码表

  • ASCII：美国标准信息交换码， 使用一个字节的低7位二位进制进行表示。
  • ISO8859-1：拉丁码表，欧洲码表，使用一个字节的8位二进制进行表示。
  • GB2312：中国的中文编码表，最多使用两个字节16位二进制为进行表示。
  • GBK：中国的中文编码表升级，融合了更多的中文文字符号，最多使用两个字节16位二进制位表示。
  • Unicode：国际标准码，融合了目前人类使用的所有字符，为每个字符分配唯一的字符码。所有的文字都用两个字节16位二进制位来表示。

（3）编码的发展

  • 面向传输的众多 UTF（UCS Transfer Format）标准出现了，UTF-8就是每次8个位传输数据，而UTF-16就是每次16个位。这是为传输而设计的编码并使编码无国界，这样就可以显示全世界上所有文化的字符了。
  • Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的Unicode编码是UTF-8和UTF-16。
  • UTF-8：变长的编码方式，可用1-4个字节来表示一个字符

14. DataOutputStream类（了解）

（1）基本概念

java.io.DataOutputStream类主要用于以适当的方式将基本数据类型写入输出流中。

（2）常用的方法

方法声明功能介绍
DataOutputStream(OutputStream out)根据参数指定的引用构造对象 OutputStream类是个抽象类，实参需要传递子类对象
void writeInt(int v)用于将参数指定的整数一次性写入输出流，优先写入高字节
void close()用于关闭文件输出流并释放有关的资源
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamTest {

    public static void main(String[] args) {
        DataOutputStream dos = null;

        try {
            //1.创建DataOutputStream类型的对象与d:/a.txt文件关联
            dos = new DataOutputStream(new FileOutputStream("d:/a.txt"));
            //2.准备一个整数数据66并写入输出流
            //66:0000 0000 ...0100 0010   =>   B
            int num = 66;
            dos.writeInt(num);
            System.out.println("写入数据成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //3.关闭流对象并释放资源
            if (null != dos) {
                try {
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

15. DataInputStream类（了解）

（1）基本概念

java.io.DataInputStream类主要用于从输入流中读取基本数据类型的数据。

（2）常用的方法

方法声明功能介绍
DataInputStream(InputStream in)根据参数指定的引用来构造对象 InputStream类是抽象类，实参需要传递子类对象
int readInt()用于从输入流中一次性读取一个整数数据并返回
void close()用于关闭文件输出流并释放有关的资源
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataInputStreamTest {

    public static void main(String[] args) {
        DataInputStream dis = null;
        try {
            //1.创建DataInputStream类型的对象与d:/a.txt关联
            dis = new DataInputStream(new FileInputStream("d:/a.txt"));
            //2.从输入流中读取一个整数并打印
            int res = dis.readInt();
            System.out.println("读取到的整数数据是：" + res);//66
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //3.关闭流对象并释放资源
            if (null != dis) {
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

16. ObjectOutputStream类（重点）

（1）基本概念

java.io.ObjectOutputStream类主要用于将一个对象的所有内容整体写入到输出流中。
只能将支持 java.io.Serializable 接口的对象写入流中。
类通过实现 java.io.Serializable 接口以启用其序列化功能。
所谓序列化主要指将一个对象需要存储的相关信息有效组织成字节序列的转化过程。

（2）常用的方法

方法声明功能介绍
ObjectOutputStream(OutputStream out)根据参数指定的引用来构造对象
void writeObject(Object obj)用于将参数指定的对象整体写入到输出流中
void close()用于关闭输出流并释放有关的资源

User类：

public class User implements java.io.Serializable {
    private static final long serialVersionUID = -8068638056766695868L;

    private String userName;//用户名
    private String password;//密码
    private transient String phoneNum;//手机号    表示该成员变量不参与序列化操作

    public User() {
    }

    public User(String userName, String password, String phoneNum) {
        this.userName = userName;
        this.password = password;
        this.phoneNum = phoneNum;
    }

    public String getUserName() {
        return userName;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPhoneNum() {
        return phoneNum;
    }

    public void setPhoneNum(String phoneNum) {
        this.phoneNum = phoneNum;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", phoneNum='" + phoneNum + '\'' +
                '}';
    }
}

ObjectOutputStreamTest类

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

public class ObjectOutputStreamTest {

    public static void main(String[] args) {
        ObjectOutputStream oos = null;

        try {
            //1.创建ObjectOutputStream类型的对象与d:/a.txt文件关联
            oos = new ObjectOutputStream(new FileOutputStream("d:/a.txt"));
            //2.准备一个User类型的对象并初始化
            User user = new User("cy","123456","1376543221");
            //3.将整个User类型的对象写入输出流
            oos.writeObject(user);
            System.out.println("写入对象成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4.关闭流对象并释放有关的资源
            if (null != oos){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

17. ObjectInputStream类（重点）

（1）基本概念

java.io.ObjectInputStream类主要用于从输入流中一次性将对象整体读取出来。
所谓反序列化主要指将有效组织的字节序列恢复为一个对象及相关信息的转化过程。

（2）常用的方法

方法声明功能介绍
ObjectInputStream(InputStream in)根据参数指定的引用来构造对象
Object readObject()主要用于从输入流中读取一个对象并返回 无法通过返回值来判断是否读取到文件的末尾
void close()用于关闭输入流并释放有关的资源

（3）序列化版本号

序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常
(InvalidCastException)。

（4）transient关键字

transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputStreamTest {

    public static void main(String[] args) {
        ObjectInputStream ois = null;

        try {
            //1.创建ObjectInputStream类型的对象与d:/a.txt文件关联
            ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
            //2.从输入流中读取一个对象并打印
            Object obj = ois.readObject();
            System.out.println("读取到的对象是；" + obj);//cy 123456  1376543221  null
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
        //3.关闭流对象并释放资源
            if (null != ois) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

（5）老师经验的分享

当希望将多个对象写入文件时，通常建议将多个对象放入一个集合中，然后将集合这个整体看做一个对象写入输出流中，此时只需要调用一readObject方法就可以将整个集合的数据读取出来，从而避免了通过返回值进行是否达到文件末尾的判断。

18. RandomAccessFile类

（1）基本概念

java.io.RandomAccessFile类主要支持对随机访问文件的读写操作。

（2）常用的方法

方法声明功能介绍
RandomAccessFile(String name, String mode)根据参数指定的名称和模式构造对象 ， r: 以只读方式打开，rw：打开以便读取和写入，rwd:打开以便读取和写入，同步文件内容的更新，rws:打开以便读取和写入，同步文件内容和元数据的更新
int read()读取单个字节的数据
void seek(long pos)用于设置从此文件的开头开始测量的文件指针偏移量
void write(int b)将参数指定的单个字节写入
void close()用于关闭流并释放有关的资源
 import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileTest {

    public static void main(String[] args) {
        RandomAccessFile raf = null;

        try {
            //1.创建RandomAccessFile类型的对象与d:/a.txt文件关联
            raf = new RandomAccessFile("d:a.txt","rw");
            //2.对文件内容进行随机读写操作
            //设置距离文件开头位置的偏移量,从文件开头位置向后偏移3个字节  aellhello
            raf.seek(3);
            int res = raf.read();
            System.out.println("读取到的单个字符是：" + (char)res);//a   l
            res = raf.read();
            System.out.println("读取到的单个字符是：" + (char)res);//h    指向了e

            raf.write('2');//执行该行代码后覆盖了字符'e'
            System.out.println("写入数据成功！");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //3.关闭流对象并释放有关的资源
            if (null != raf) {
                try {
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

总结

1.IO流（重点）
概念、分类、体系结构、相关类的详解
2.

cyuluo69582
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值