小白学Java:I/O流

目录

  • 小白学Java:I/O流

    • 基本分类
    • 发展史
    • 文件字符流
      • 输出的基本结构
      • 流中的异常处理
      • 异常处理新方式
      • 读取的基本结构
      • 运用输入与输出
    • 文件字节流
    • 缓冲流
      • 字符缓冲流
      • 装饰设计模式
    • 转换流(适配器)
      • 适配器设计模式
    • 标准流/系统流
      • 标准流分类
    • 打印流
    • 合并流
    • 序列化/反序列化流
      • 序列化对象

小白学Java:I/O流

流,表示任何有能力产生数据的数据源对象或者是有能力接收数据的接收端对象,它屏蔽了实际的I/O设备中处理数据的细节。

基本分类

  • 根据方向

    • 输入流:数据从外部流向程序,例如从文件中读取数据
    • 输出流:数据从程序流向外部,例如向文件中写数据
  • 根据形式
    • 字符流:字符类文件,如 txt、 java、 html。
    • 字节流:图片、视频、音频 。
  • 根据功能
    • 节点流:直接从数据源进行数据读写
    • 处理流:封装其他的流,来提供增强流的功能。
输入流 输出流
字符流 Reader Writer
字节流 InputStream OutputStream
  • 上面四大基本流都是抽象类,都不能直接创捷对象。
  • 数据的来源/目的地:磁盘、网络、内存、外部设备。

发展史

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

文件字符流

  • 文件字符输出流 FileWriter自带缓冲区,数据先写到到缓冲区上,然后从缓冲区写入文件。
  • 文件字符输入流 FileReader:没有缓冲区,可以单个字符的读取,也可以自定义数组缓冲区。

输出的基本结构

在实际应用中,异常处理的方式都需要按照下面的结构进行,本篇为了节约篇幅,之后都将采用向上抛出的方式处理异常。

    //将流对象放在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;
            }
        }
    }
  • 并不会直接将数据写入文件中,而是先写入缓冲区,待缓冲区满了之后才将缓冲区的数据写入文件。
  • 假设数据写入缓冲区时且缓冲区还没满,数据还没能够写入文件时,程序就已经结束,会导致数据惨死缓冲区,这时需要手动冲刷缓冲区,将缓冲区内的数据冲刷进文件中。writer.flush();
  • 数据写入完毕,释放文件以允许别的流来操作该文件。关闭流可以调用close()方法,值得注意的是,在close执行之前,流会自动进行一次flush的操作以避免数据还残存在缓冲区中,但这并不意味着flush操作是多余的。

流中的异常处理

  • 无论流操作成功与否,关流操作都需要进行,所以需要将关流操作放到finally代码块中
  • 为了让流对象再finally中以然能够使用,所以需要将流对象放在try之外声明并且赋值为null,然后在try之内进行实际的初始化过程。
  • 在关流之前要判断流对象是否初始化成功,实际就是判断流对象是否为nullwriter!=null时才执行关流操作。
  • 关流可能会失败,此时流依然会占用文件,所以需要将流对象置为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();
}

读取的基本结构

处理异常的正确方式在输入的结构中已说明,这边就不进行繁杂的异常处理,执行直接向上抛出的不负责任的操作。

    public static void main(String[] args) throws IOException {
        FileReader reader = new FileReader("D:\\b.txt");
        //定义一个变量记录每次读取的字符
        int m;
        //读取到末尾为-1
        while((m = reader.read())!=-1){
           System.out.print(m);
        }

        reader.close();
    }
  • 文件字符输入流没有缓冲区。
  • read方法用来从文件中读取字符,每次只读取一个。
  • 定义变量m记录读取的字符,以达到末尾为终止条件。m!=-1时,终止循环。
  • 读取结束,执行关流操作。

当然,每次读取一个字符,怪麻烦的,我们可以改进一下:

    //定义数组作为缓冲区
    char[] cs = new char[5];
    //定义变量记录读取字符的个数
    int len;
    while ((len = reader.read(cs)) != -1) {
        System.out.println(new String(cs, 0, len));
    }
    reader.close();

运用输入与输出

运用文件字符输入与输出的小小案例:

public static void copyFile(FileReader reader, FileWriter writer) throws IOException {
    //利用字符数组作为缓冲区
    char[] cs = new char[5];
    //定义变量记录读取到的字符个数
    int m;
    while((m = reader.read(cs))!=-1){
        //将读取到的内容写入新的文件中
        writer.write(cs,0,m);

    }
    reader.close();
    writer.close();
}

文件字节流

  • 文件字节输出流 FileOutputStream 在输出的时候没有缓冲区,所以不需要进行flush操作。
    public static void main(String[] args) throws Exception {
        FileOutputStream out = new FileOutputStream("D:\\b.txt");
        //写入数据
        //字节输出流没有缓冲区
        out.write("天乔巴夏".getBytes());
        //关流是为了释放文件
        out.close();
    }
  • 文件字节输入流 FileInputStream,可以定义字节数组作为缓冲区。
    public static void main(String[] args) throws Exception{
        FileInputStream in = new FileInputStream("E:\\1myblog\\Node.png");

       //1.读取字节
       int i = in.read();
       int i;
       while((i=in.read())!=-1)
           System.out.println(i);
       //2.定义字节数组作为缓冲区
       byte[] bs = new byte[10];
       //定义变量记录每次实际读取的字节个数
       int len;
       while((len = in.read(bs))!=-1){
           System.out.println(new String(bs,0,len));
       }
       in.close();

    }

缓冲流

字符缓冲流

  • BufferedReader:在构建的时候需要传入一个Reader对象,真正读取数据依靠的是传入的这个Reader对象BufferedReadReader对象中获取数据提供缓冲区
    public static void main(String[] args) throws IOException {
        //真正读取文件的流是FileReader,它本身并没有缓冲区
        FileReader reader = new FileReader("D:\\b.txt");
        BufferedReader br = new BufferedReader(reader);
        //读取一行
        //String str = br.readLine();
        //System.out.println(str);

        //定义一个变量来记录读取的每一行的数据(回车)
        String str;
        //读取到末尾返回null
        while((str = br.readLine())!=null){
            System.out.println(str);
        }
        //关外层流即可
        br.close();
    }
  • BufferedWriter:提供了一个更大的缓冲区,提供了一个newLine的方法用于换行,以屏蔽不同操作系统的差异性
    public static void main(String[] args) throws Exception {
        //真正向文件中写数据的流是FileWriter,本身具有缓冲区
        //BufferedWriter 提供了更大的缓冲区
        BufferedWriter writer = new BufferedWriter(new FileWriter("E:\\b.txt"));
        writer.write("天乔");
        //换行: Windows中换行是 \r\n   linux中只有\n
        //提供newLine() 统一换行
        writer.newLine();
        writer.write("巴夏");
        writer.close();
    }

装饰设计模式

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

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

除此之外,字节流同样也存在缓冲流,分别是BufferedInputStreamBufferedOutputStream

转换流(适配器)

利用转换流可以实现字符流和字节流之间的转换

  • OutputStreamWriter
    public static void main(String[] args) throws Exception {
        //在构建转换流时需要传入一个OutputStream  字节流
        OutputStreamWriter ow =
                new OutputStreamWriter(
                        new FileOutputStream("D:\\b.txt"),"utf-8");
        //给定字符--> OutputStreamWriter转化为字节-->以字节流形式传入文件FileOutputStream
        //如果没有指定编码,默认使用当前工程的编码
        ow.write("天乔巴夏");
        ow.close();
    }

最终与文件接触的是字节流,意味着将传入的字符转换为字节


  • InputStreamReader
    public static void main(String[] args) throws IOException {
        //以字节形式FileInputStream读取,经过转换InputStreamReader -->字符
        //如果没有指定编码。使用的是默认的工程的编码
        InputStreamReader ir =
                new InputStreamReader(
                        new FileInputStream("D:\\b.txt"));
        char[] cs = new char[5];
        int len;
        while((len=ir.read(cs))!=-1){
            System.out.println(new String(cs,0,len));
        }
        ir.close();
    }

最初与文件接触的是字节流,意味着将读取的字节转化为字符

适配器设计模式

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

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

标准流/系统流

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

标准流分类

对象 解释 封装类型
System.in 标准输入流 InputStream
System.out 标准输出流 PrintStream
System.err 标准错误流 PrintStream

可以直接使用System.outSystem.err,但是在读取System.in之前必须对其进行封装,例如我们之前经常会使用的读取输入:Scanner sc = new Scanner(System.in);实际上就封装了System.in对象。

  • 标准流都是字节流
  • 标准流对应的不是类而是对象。
  • 标准流在使用的时候不用关闭。
    /**
     * 从控制台获取一行数据
     * @throws IOException  readLine 可能会抛出异常
     */
    public static void getLine() throws IOException {
        //获取一行字符数据 -- BufferedReader
        //从控制台获取数据 -- System.in
        //System是字节流,BufferedReader在构建的时候需要传入字符流
        //将字节流转换为字符流
        BufferedReader br =
                new BufferedReader(
                        new InputStreamReader(System.in));
        //接收标准输入并转换为大写
        String str = br.readLine().toUpperCase();
        //发送到标准输出
        System.out.println(str);
    }

通过转换流,将System.in读取的标准输入字节流转化为字符流,发送到标准输出,打印显示。

打印流

打印流只有输出流没有输入流

  • PrintStream: 打印字节流
    public static void main(String[] args) throws IOException {
        //创建PrintStream对象
        PrintStream p = new PrintStream("D:\\b.txt");
        p.write("abc".getBytes());
        p.write("def".getBytes());
        p.println("abc");
        p.println("def");
        //如果打印对象,默认调用对象身上的toString方法
        p.println(new Object());
        p.close();
    }
  • PrintWriter:打印字符流
    //将System.out转换为PrintStream
    public static void main(String[] args) {
        //第二个参数autoFlash设置为true,否则看不到结果
        PrintWriter p = new PrintWriter(System.out,true);
        p.println("hello,world!");
    }

合并流

  • SequenceInputStream用于将多个字节流合并为一个字节流的流。
  • 有两种构建方式:
    • 将多个合并的字节流放入一个Enumeration中来进行。
    • 传入两个InputStream对象。
  • 合并流只有输入流没有输出流。

以第一种构建方式为例,我们之前说过,Enumeration可以通过Vector容器的elements方法创建。

    public static void main(String[] args) throws IOException {
        FileInputStream in1 = new FileInputStream("D:\\1.txt");
        FileInputStream in2 = new FileInputStream("D:\\a.txt");
        FileInputStream in3 = new FileInputStream("D:\\b.txt");
        FileInputStream in4 = new FileInputStream("D:\\m.txt");

        FileOutputStream out = new FileOutputStream("D:\\union.txt");
        //准备一个Vector存储输入流
        Vector<InputStream> v = new Vector<>();
        v.add(in1);
        v.add(in2);
        v.add(in3);
        v.add(in4);

        //利用Vector产生Enumeration对象
        Enumeration<InputStream> e = v.elements();
        //利用迭代器构建合并流
        SequenceInputStream s = new SequenceInputStream(e);

        //读取
        byte[] bs = new byte[10];
        int len;
        while((len = s.read(bs))!=-1){
            out.write(bs,0,len);
        }
        out.close();
        s.close();
    }

序列化/反序列化流

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

序列化对象

创建一个Person类。

//必须实现Serializable接口
class Person implements Serializable {
    //序列化ID serialVersionUID
    private static final long serialVersionUID = 6402392549803169300L;
    private String name;
    private int age;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

创建序列化流,将对象转化为字节,并写入"D:\1.data"。

public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        Person p = new Person();
        p.setAge(18);
        p.setName("Niu");
        //创建序列化流
        //真正将数据写出的流是FileOutputStream
        //ObjectOutputStream将对象转化为字节
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:\\1.data"));
        out.writeObject(p);
        out.close();
    }
}

创建反序列化流,将从"D:\1.data"中读取的字节转化为对象。

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建反序列化流
        //真正读取文件的是FileInputStream
        //ObjectInputStream将读取的字节转化为对象
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:\\1.data"));
        //读取数据必须进行数据类型的强制转换
        Person p = (Person)in.readObject();
        in.close();
        System.out.println(p.getName());//Niu
        System.out.println(p.getAge());//18

    }

需要注意的是:

  • 如果一个对象要想被序列化,那么对应的类必须实现接口serializable,该接口没有任何方法,仅仅作为标记使用。
  • statictransient修饰的属性不会进行序列化。如果属性的类型没有实现serializable接口但是也没有用这两者修饰,会抛出NotSerializableException
  • 在对象序列化的时候,版本号会随着对象一起序列化出去,在反序列化的时候,对象中的版本号和类中的版本号进行比较,如果版本号一致,则允许反序列化。如果不一致,则抛出InvalidClassException
  • 集合允许被整体序列化 集合及其中元素会一起序列化出去。

关于版本号

  • 一个类如果允许被序列化,那么这个类中会产生一个版本号 serialVersionUID

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


写在最后:如果本文有叙述错误之处,还望评论区批评指正,共同进步。

参考资料:《Java 编程思想》、《Java语言程序设计》、《大话设计模式》

原文地址:https://www.cnblogs.com/summerday152/p/12256547.html

时间: 2024-10-03 09:05:19

小白学Java:I/O流的相关文章

小白学Java:迭代器原来是这么回事

目录 小白学Java:迭代器原来是这么回事 迭代器概述 迭代器设计模式 Iterator定义的方法 迭代器:统一方式 Iterator的总结 小白学Java:迭代器原来是这么回事 前文传送门:Enumeration 上一篇,我们谈到了那个古老的迭代器Enumeration,还谈到了取代他的新迭代器--Iterator.相比于以往,这个新物种又有哪些优点呢? 迭代器这个词,在没查找许多资料之前,我只知道个大概,我知道它可以用来遍历集合,但是至于它其中的奥妙,并没有做深究.本篇文章关于Iterato

小白学Java:奇怪的RandomAccess

目录 小白学Java:奇怪的RandomAccess RandomAccess是个啥 forLoop与Iterator的区别 判断是否为RandomAccess 小白学Java:奇怪的RandomAccess 我们之前在分析那三个集合源码的时候,曾经说到:ArrayList和Vector继承了RandomAccess接口,但是LinkedList并没有,我们还知道继承了这个接口,就意味着其中元素支持快速随机访问(fast random access). RandomAccess是个啥 出于好奇,

小白学JAVA if判断 switch 循环

Java if 判断语句 package XunHuanPanDuan;import java.util.Scanner;public class ifDemo01 {    //if 判断语句    public static void main(String[] args) {        Scanner scanner = new Scanner(System.in);        System.out.println("请输入成绩:");        int cj = s

【小白学Java for循环】3分钟学会Java的for循环,让看懂for循环嵌套再不是难事

目录 一.单个for循环介绍 二.for循环嵌套 听讲时能听懂的for循环为什么一做题就晕菜?一个for循环还勉强能看懂,但为什么一看到双重for循环脑子里就感觉脑子全是浆糊? 如果有上述问题那么就继续看这篇文章吧~让你3分钟学会Java的for循环,让看懂for循环嵌套再不是难事! 一.单个for循环介绍 1.语法格式: for(①初始化部分;②循环条件部分;④迭代部分){ ? ③循环体部分 } 例子: 2.执行过程: ①→②→③→④→②→③→④→②→③→④→--→② 3.说明: ②循环条件部

公钥和私钥的区别[小白学java]

一.公钥加密 假设一下,我找了两个数字,一个是1,一个是2.我喜欢2这个数字,就保留起来,不告诉你们(私钥),然后我告诉大家,1是我的公钥.我有一个文件,不能让别人看,我就用1加密了.别人找到了这个文件,但是他不知道2就是解密的私钥啊,所以他解不开,只有我可以用 数字2,就是我的私钥,来解密.这样我就可以保护数据了. 我的好朋友x用我的公钥1加密了字符a,加密后成了b,放在网上.别人偷到了这个文件,但是别人解不开,因为别人不知道2就是我的私钥, 只有我才能解密,解密后就得到a.这样,我们就可以传

【经验分享】新手学Java编程语言怎么入门?

新手学Java编程语言怎么入门?掌握语言基础是第一步,了解java基础知识,Java关键字.核心概念或者基本编码技术.掌握操作符.控制执行流程.访问权限控制.复用类.多态.接口.字符串.泛型.数组.容器深入研究.JavaI/O系统.枚举类型.并发以及图形化用户界面等内容. 为了帮助大家更轻松的学好java开发,给大家分享一套java开发学习资料,小编推荐一个学java开发技术的学习裙:三七四三二零二八二,无论你是大牛还是小白,是想转行还是想入行都可以来了解一起进步一起学习!裙内有开发工具,很多干

零基础java培训靠谱吗?职场转行,零基础开始学Java开发靠谱吗?

学技术转行发展,是职场常见的提升方式,无论是在职充电还是为转行跳槽做准备,选择一个专业技能进行培训学习,都是非常可取的.在能力至上的今天,单凭学历已经不能成为入行敲门砖,特别是在互联网企业,通常在面试过程中就会考核技术能力,此外看你的项目作品,可见技术能力在招聘中是最具说服力的.华清远见教育职业规划专家表示零基础java培训靠谱吗,如果不清楚学什么技术更好,可以访问这里做职业规划,此外还可以通过试学来了解自己对技术课程的兴趣点. 华清远见教育开设的面向零基础人群提供的,从学习到就业一站式的浸入式

10.4-全栈Java笔记:常用流详解(二)

上节我们讲到「Java中常用流:文件字节流和字节数组流」,本节我们继续走起~  缓冲流 BufferedInputStream和BufferedOutputStream这两个流是处理流,通过内部缓存数组来提高操作流的效率. [示例1]使用缓冲流实现文件的高效率复制操作 public class Demo06 { public static void main(String[] args) { new Demo06().copyFile("d:/a.txt", "d:/b.tx

黑马程序员——Java基础--IO流(一)---字符流和字节流

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 一.IO流的介绍及体系 IO流用来处理设备之间的数据传输.java对数据的操作是通过流的方式.java用于操作流的对象都在IO包中. 输入流和输出流相对于内存设备而言:将外设中的数据读取到内存中:输入.将内存中的数据写出到外设中:输出. 流按照操作数据分为两种:字节流和字符流. 字符流的由来:其实就是字节流读取文字字节数据后,不直接操作而是先查指定的编码表,获取对应的文字,再对这个文字进行操作