节点流和处理流二

1. 节点流和处理流接上 

2. 处理流BufferedInputStream 和 BufferedOutputStream

2.1 介绍BufferedInputStream   626

BufferedInputStream是字节流在创建BufferedInputStream会创建一个内部缓冲区数组.

2.2 介绍BufferedOutputStream  626

BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

3. 应用案例  627

要求:编程完成图片/音乐的拷贝(要求使用Buffered..流).

代码在com.stulzl.bufferedcopy_.包中

BufferedCopy_

package com.stulzl.bufferedcopy_;

import java.io.*;

//案例BufferedInputStream 和 BufferedOutputStream  627
//使用他们，可以完成二进制文件拷贝.
//要求:编程完成图片/音乐的拷贝(要求使用Buffered..流).

public class BufferedCopy_ {
    public static void main(String[] args) {
        String srcFilePath = "e:\\guidao.jpg";
        String destFilePath = "e:\\guidao2.jpg";
        //思考：字节流可以操作二进制文件，可以操作文本文件吗？当然可以
//        String srcFilePath = "e:\\story.txt";
//        String destFilePath = "e:\\story3.txt";
        
        //创建BufferedInputStream 和 BufferedOutputStream对象
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream(srcFilePath));
            bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
            //循环的读取文件，并写入到 destFilePath
            byte[] buff = new byte[1024];//临时缓冲字节数组
            int readLen = 0;
            //当返回 -1 时，就表示文件读取完毕
            while((readLen=bis.read(buff))!=-1){
                bos.write(buff,0,readLen);
            }
            System.out.println("文件拷贝成功……");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if(bis!=null){
                    bis.close();
                }
                if(bos!=null){
                    bos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4. 对象流ObjectInputStream 和 ObjectOutputStream  628

➢看一个需求

1.将int num = 100这个int数据保存到文件中，注意不是100数字，而是int 100,井且，能够

从文件中直接恢复int 100

2.将Dog dog = new Dog(“小黄"，3)这个dog对象保存到文件中，并且能够从文件恢复.

3.上面的要求， 就是能够将基本数据类型或者对象进行序列化和反序列化操作

4.1 序列化和反序列化  628

1.序列化就是在保存数据时， 保存数据的值和数据类型

2.反序列化就是在恢复数据时， 恢复数据的值和数据类型

3.需要让某个对象支持序列化机制， 则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一:

Serializable // 这是一个标记接口，没有方法

Externalizable //该接口有方法需要实现，因此我们一般实现上面的Serializable接口

4.2 对象流介绍

功能：提供了对基本类型或对象类型的序列化和反序列化的方法

ObjectOutputStream 提供 序列化功能

ObjectInputStream 提供 反序列化功能

4.3 应用案例ObjectOutputStream序列化   629

1.使用ObjectOutputStream 序列化基本数据类型和一个Dog对象(name, age),并

保存到data.dat文件中

代码在com.stulzl.objectoutputstream_.包中

共有的Dog类4.4案列也共有这个Dog

package com.stulzl.objectoutputstream_;

import java.io.Serializable;

//如果需要序列化某个类的对象，需要实现Serializable接口或者Externalizable接口

public class Dog implements Serializable {
    private String name;
    private int age;
    
//serialVersionUID 序列化的版本号，可以提高兼容性
private static final long serialVersionUID = 1L;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

ObjectOutputStream_

package com.stulzl.objectoutputstream_;

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

//应用案例ObjectOutputStream 完成序列化  629
//1.使用ObjectOutputStream 序列化基本数据类型和一个Dog对象(name, age),并
//保存到data.dat文件中
public class ObjectOutputStream_ {
    public static void main(String[] args) throws Exception {
        //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
        String filePath = "e:\\data.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到e:\data.txt
        //这里的int boolean char double String都实现了Serializable接口
        //因此可以序列化
        oos.writeInt(100);// int -> Integer (实现了 Serializable)
        oos.writeBoolean(true);//// boolean -> Boolean (实现了 Serializable)
        oos.writeChar('a');// char -> Character (实现了 Serializable)
        oos.writeDouble(9.5);// double -> Double (实现了 Serializable)
        oos.writeUTF("中国");//String类型(实现了 Serializable)

        //保存一个dog对象
        oos.writeObject(new Dog("旺财",10));
        oos.close();
        System.out.println("数据序列化完毕");
    }
}

4.4 应用案例ObjectInputStream反序列化  630

2. 使用ObjectInputStream读取data.dat并反序列化恢复数据

代码在com.stulzl.objectinputstream_.包中

ObjectInputStream_

package com.stulzl.objectinputstream_;

import com.stulzl.objectoutputstream_.Dog;

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

//应用案例ObjectInputStream反序列化  630
//2. 使用ObjectInputStream读取data.dat并反序列化恢复数据
public class ObjectInputStream_ {
    public static void main(String[] args) throws Exception {
        //指定反序列化文件
        String filePath = "e:\\data.dat";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        //读取
        //读取(反序列化)的顺序需要和你保存的数据的顺序一致，否则会出现异常
        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readChar());
        System.out.println(ois.readDouble());
        System.out.println(ois.readUTF());//这个是读取字符串

        //dog 的编译类型是 Object , dog 的运行类型是 Dog
        Object dog = ois.readObject();//这里接收一下dog对象
        System.out.println("运行类型="+dog.getClass());
        System.out.println("dog信息="+dog);//底层 Object->Dog

        //这里是特别重要的细节:
        //1. 如果我们希望调用Dog的方法, 需要向下转型
        //2. 需要我们将Dog类的定义，放在到可以引用的位置
        Dog dog2 = (Dog)dog;
        System.out.println(dog2.getName()); //旺财

        //关闭流
        ois.close();
        System.out.println("反序列化完毕");

    }
}

5. 对象节点流和处理流细节  631

1)读写顺序要致

2)要求序列化或反序列化对象，需要实现Serializable

3)序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性

4)序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员

5)序列化对象时，要求里面属性的类型也需要实现序列化接口

6)序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

6. 标准输入输出流  632

6.1 介绍  632

6.2  应用案例标准输入输出流  632

传统方法System.out.println(””); 是使用out对象将数据输出到显示器

传统的方法，Scanner是从标准输入键盘接收数据

代码在com.stulzl.standard_.包中

InputAndOutput_

package com.stulzl.standard_;

import java.util.Scanner;

//演示说明标准输入输出流  632
public class InputAndOutput_ {
    public static void main(String[] args) {
        //System.in是 System类中的一个属性-》public final static InputStream in = null
        // System.in 编译类型   InputStream
        // System.in 运行类型   BufferedInputStream
        // 表示的是标准输入 键盘
        System.out.println(System.in.getClass());
        //System.out是 System类中的一个属性-》public final static PrintStream out = null;
        //2. 编译类型 PrintStream
        //3. 运行类型 PrintStream
        //4. 表示标准输出 显示器
        System.out.println(System.out.getClass());

        //例，此例没有特别意义不必追究
        System.out.println("hello,world");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容");
        String next = scanner.next();
        System.out.println("next="+next);
    }
}

7. 转换流InputStreamReader 和 OutputStreamWriter  633

7.1 先看一个文件乱码问题，引出转换流必要性.  633

代码在com.stulzl.transformation_.

CodeQuestion_

package com.stulzl.transformation_;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

//先看一个文件乱码问题，引出学习转换流必要性. 633
public class CodeQuestion_ {
    public static void main(String[] args) throws IOException {
        //读取 e:\\a.txt 文件到程序
        //思路
        //1. 创建字符输入流 BufferedReader [处理流]
        //2. 使用 BufferedReader 对象读取 a.txt
        //3. 默认情况下，读取文件是按照 utf-8 编码
        String filePath = "e:\\a.txt";
        BufferedReader br = new BufferedReader(new FileReader(filePath));
        //我们在读文件数据默认情况下是按照utf-8 编码的，一但我们改变了文件的编码形式
        // ，再读取时就会出现乱码问题
        String s = br.readLine();//按行读取
        System.out.println("读取到的内容为="+s);
        br.close();
    }
}

7.2 基本介绍  634

1. InputStreamReader:Reader的子类，可以将InputStream(字节流)包装成(转换)Reader(字符流)

2. OutputStreamWriter:Writer的子类， 实现将OutputStream(字节流)包装成Writer(字符流)

3.当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流

4.可以在使用时指定编码格式(比如utf 8, gbk，gb2312, IS08859-1等)

7.3 应用案例InputStreamReader字节输入转换流

编程将字节流FileInputStream 包装成(转换成)字符流InputStreamReader,对文件进行读取(按照utf-8/gbk格式),进而在包装成BufferedReader

代码在com.stulzl.inputstreamreader_.包中

InputStreamReader_

package com.stulzl.inputstreamreader_;

import java.io.*;

//演示InputStreamReader转换流解决中文乱码问题，  634
// 将字节流 FileInputStream 转成字符流 InputStreamReader, 指定编码 gbk/utf-8
// 对文件进行读取(按照utf-8/gbk格式),进而在包装成BufferedReader
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "e:\\a.txt";
        //解读
        //1. 把 FileInputStream 转成 InputStreamReader
        //2. 指定编码为 gbk
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
        //3. 把 InputStreamReader 传入 BufferedReader
        BufferedReader br = new BufferedReader(isr);

        //将 2 和 3 合在一起
//        BufferedReader br = new BufferedReader(new InputStreamReader(
//                new FileInputStream(filePath), "gbk"));


        //读取
        String s = br.readLine();//按行读取
        System.out.println("读取到的内容为="+s);
        //关闭流
        br.close();
    }
}

7.4 案例OutputStreamWriter字节输出转换流  635

2.编程将字节流FileOutputStream包装成(转换成)字符流OutputStreamWriter,对文件进行写入(按照gbk格式,可以指定其他，比如utf-8)

代码在com.stulzl.outputstreamwriter_.包中

OutputStreamWriter_

package com.stulzl.outputstreamwriter_;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

//演示 OutputStreamWriter 使用  635
//2.编程将字节流FileOutputStream包装成(转换成)字符流OutputStreamWriter,
// 对文件进行写入(按照gbk格式,可以指定其他，比如utf-8)
public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "e:\\lzl.txt";
        String charSet = "utf-8";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
        osw.write("hi,中国");//按gbk编码将此句输出到e:\lzl.txt
        osw.close();
        System.out.println("按照 "+charSet+"保存文件成功");
    }
}