Day33-Buffered处理流、对象处理流

BufferedReader(字符流)

package com.ghy.reader;

import java.io.BufferedReader;
import java.io.FileReader;

//演示BufferedReader
public class BufferedReader01 {
    public static void main(String[] args) throws Exception{
        //路径
        String filePath = "D:\\code\\LoveStory.txt";
        //创建BufferedReader对象
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        String line;//按行读取,效率高
        //当返回null时，说明读取完毕。
        while((line = bufferedReader.readLine())!=null){
            System.out.println(line);
        }
        //关闭流
        //这里只需要关闭BufferedReader就可以了，因为底层会自动的去关闭节点流（FileReader）
        bufferedReader.close();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输出

小赵爱情故事。XIAOZHAO喜欢小龚~嘿嘿嘿
1

BufferedWriter

package com.ghy.reader;

import java.io.BufferedWriter;
import java.io.FileWriter;

//演示BufferedWriter的使用
public class BufferedWriter01 {
    public static void main(String[] args) throws Exception {
        String filePath = "D:\\code\\LoveStory.txt";
        //创建BufferedWriter对象
        //1.new FileWriter(filePath,true)是以追加的方式写入
        //2.new FileWriter(filePath)是以覆盖的方式写入
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        bufferedWriter.write("小赵最厉害！");
        bufferedWriter.newLine();//插入一个换行
        bufferedWriter.write("但是！");
        bufferedWriter.newLine();//插入一个换行
        bufferedWriter.write("小龚当家做主！");
        //关闭流，底层也会自动关闭节点流
        bufferedWriter.close();
        System.out.println("写入成功!");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输出

写入成功!
1

查看

Buffered（字符流）拷贝

package com.ghy.writer;

import java.io.*;

public class BufferedCopy01 {
    public static void main(String[] args)  {
        String srcPath = "D:\\code\\LoveStory.txt";//原文件路径
        String newPath = "D:\\code\\LoveStory2.txt";//目的路径
        BufferedReader br = null;
        BufferedWriter bw = null;
        String line;
        //创建对象
        try {
            br = new BufferedReader(new FileReader(srcPath));
            bw = new BufferedWriter(new FileWriter(newPath));
            //读取
            while((line = br.readLine()) != null){
                //每读取一行就写入一行
                bw.write(line);
                //插入换行，读取一行换一行
                bw.newLine();
            }
            System.out.println("拷贝成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭bw流
            if(bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //关闭br流
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

输出

拷贝成功！
1

查看

1.BufferedReader和BufferedWriter是按照字符操作

2.不要操作二进制文件（声音、视屏、word文档…），可能造成文件损坏

Buffered字节处理流

• BufferedInputStream

• BufferedoutputStream

实时流处理系统

doc 0星 超过10%的资源 584KB

下载

Buffered（字节流）拷贝

package com.ghy.outputstream;

import java.io.*;

//演示使用BufferedOutPutStream和BufferedInPutStream
public class BufferedCopy02 {
    public static void main(String[] args) {
        String srcPath = "d:\\code\\分島花音 - still doll(オルゴール・ヴァージョン).mp3";//原路径
        String newPath = "d:\\code\\拷贝的歌.mp3";//目的路径
        BufferedOutputStream bo = null;
        BufferedInputStream bi = null;
        //创建对象
        try {
            //
            bi = new BufferedInputStream(new FileInputStream(srcPath));
            bo = new BufferedOutputStream(new FileOutputStream(newPath));
            byte[] buff = new byte[1024];
            int readLen = 0;
            //循环的读取文件，并写入到拷贝文件
            //当返回的是-1时，就表示文件读取完毕
            while ((readLen = bi.read(buff))!=-1){
                //读取多少就写入多少
                bo.write(buff,0,readLen);
            }
            System.out.println("拷贝成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流，关闭外层的处理流即可，底层会去关闭节点流
            if(bi!=null){
                try {
                    bi.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bo!=null){
                try {
                    bo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

输出

拷贝成功！
1

查看

对象处理流

ObjectOutPutStream

package com.ghy.outputstream;

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

//演示ObjectOutPutStream的使用，完成数据的序列化
public class ObjectOutPutStream01 {
    public static void main(String[] args) throws Exception{
        //序列化后，保存的文件格式，不是纯文本，而是按照他的格式来保存的
        String filePath = "D:\\code\\data.dat";
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到D:\code\data.dat
        os.writeInt(100);//int -> Integer(实现了 Serialiazable)
        os.writeBoolean(true);//boolean->Boolean(实现了 Serialiazable)
        os.writeChar('G');//char->Character(实现了 Serialiazable)
        os.writeDouble(9.11);//double->Double(实现了 Serialiazable)
        os.writeUTF("最爱小赵");//String(实现了 Serialiazable)
        //保存一个xiaozhao对象
        os.writeObject(new xiaozhao("小赵",18));
        //关闭流
        os.close();
        System.out.println("数据保存完毕（序列化型形式）");
    }
}
//如果需要实例化某个类对象，实现接口
class xiaozhao implements Serializable {
    private String name;
    private int age;

    public xiaozhao(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

java数据流总结

png 5星 超过95%的资源 76KB

下载

输出

数据保存完毕（序列化型形式）
1

查看

因为保存的不是文本模式，所以查看的时候有乱码，但是可以看出保存了数据和数据类型

ObjectInPutStream

(进行反序列化恢复文件)

package com.ghy.inputstream;

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

public class ObjectInPutStream01 {
    public static void main(String[] args) throws Exception{
        String filePath = "D:\\code\\data.dat";//指定路径文件
        //创建对象
        ObjectInputStream oi = new ObjectInputStream(new FileInputStream(filePath));
        //读取
        //读取顺序要与序列化顺序一致，否则会出现异常
        System.out.println(oi.readInt());
        System.out.println(oi.readBoolean());
        System.out.println(oi.readChar());
        System.out.println(oi.readDouble());
        System.out.println(oi.readUTF());
        //xiaozhao的编译类型是Object，运行类型是xiaozhao
        Object xiaozhao = oi.readObject();
        System.out.println("运行类型=" + xiaozhao.getClass());
        System.out.println("xiaozhao信息=" + xiaozhao);
        //1. 如果我们需要xiaozhao方法需要向下转型
        //2.需要我们将xiaozhao类的定义，拷贝到可以引用的位置
        //关闭流
        oi.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

输出

100
true
G
9.11
最爱小赵
运行类型=class com.ghy.outputstream.xiaozhao
xiaozhao信息=xiaozhao{name='小赵',age=18}
1
2
3
4
5
6
7