菜鸡学习day21_缓冲流&BufferedOutputStream&BufferedInputStream&BufferedWriter&BufferedReader&。。。

菜鸡学习day21

package day21;

import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;

/*
缓冲流
给基本的流增加一个（数组）缓冲区，提高读取效率

字节缓冲输出流
BufferedOutputStream
继承自父类的共性成员方法
public void close（）
public void flush（）
public void write（byte【】b）
public void write（byte【】b，int off，int len）
public abstract void write（int b）

构造方法
BufferedOutputStream（OutputStream out）创建一个字节缓冲输出流，将数据（默认大小）写入指定的底层输出流
BufferedOutputStream（OutputStream out，int size）指定缓冲区大小
参数：OutputStream out：字节输出流（可以传递FileOutputStream，缓冲流会给其增加一个缓冲区，提高写入效率）
     int size （指定缓冲区大小）
使用步骤：1.创建FileOutputStream对象，构造方法中绑定输出目的地
         2.创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象对象，提高其效率
         3.使用FileOutputStream对象中的方法write将数据写入缓冲区
         4.使用FileOutputStream对象中的方法flush，将缓冲区数据刷新到文件
         5，close 释放资源（里面包含flush，可以省略上面的flush）

字节缓冲输入流
BufferedInputStream
继承自父类的共性成员方法
public void close（）
public void read（）
public void read（byte【】b）

构造方法
BufferedInputStream（InputStream in）创建一个字节缓冲输入流，用缓冲区保存数据
BufferedInputStream（InputStream in，int size）指定缓冲区大小
参数：InputStream in：字节输入流（可以传递FileInputStream，缓冲流会给其增加一个缓冲区，提高读取效率）
     int size （指定缓冲区大小）
使用步骤：1.创建FileInputStream对象，构造方法中绑定数据源
         2.创建BufferedInputStream对象，构造方法中传递FileOutputStream对象对象，提高其读取效率
         3.使用FileInputStream对象中的方法read读取数据
         4.close 释放资源

字符缓冲流

字符缓冲输出流
BufferedWriter
继承自父类的共性成员方法
public void close（）没有包含刷新
public void flush（）
public void write（int i）
public void write（char[]cbuf）
public void write（String str）
public void write（String str, int off, int len）
public abstract void write（char[]cbuf）

构造方法
BufferedWriter（Writer out）
BufferedWriter（Writer out，int size）缓冲区指定大小

特有的成员方法
void newLine（）写入一个行分隔符，换行
使用步骤同上。。

字符缓冲输入流
BufferedReader
继承自父类的共性成员方法
public void close（）
public void read（）
public void read（char【】cbuf）

构造方法
BufferedReader（Reader in）
BufferedReader（Reader in，int size）

特有的成员方法
String readLine（）读取一个文本行，不包含末尾符，返回null

转换流

OutputSteamWriter（字符流->字节流的桥梁）
继承自父类的共性成员方法
public void close（）没有包含刷新
public void flush（）
public void write（int i）
public void write（char[]cbuf）
public void write（String str）
public void write（String str, int off, int len）
public abstract void write（char[]cbuf, int off, int len）

构造方法
OutputSteamWriter（OutputSteam out）创建使用默认编码的OutputSteamWriter
OutputSteamWriter（OutputSteam out，String charsetName）指定编码表
参数：OutputSteam out 字节输出流
     String charsetName 编码表名称，不区分大小写 utf-8/gbk/。。。
使用步骤：1.创建OutputSteamWriter对象，构造方法中传递字节输出流和编码表名称
         2.使用write将字符流转换成字节流存储到缓冲区
         3.flush刷新到文件
         4.close释放资源

InputSteamReader（字节->字符）
继承自父类的共性成员方法
public void close（）
public void read（）
public void read（char【】cbuf）

构造方法
InputSteamReader（InputSteam in）
InputSteamReader（InputSteam in，String charsetName）

使用步骤：同上。。
注：构造方法中指定的编码表名称要与文件编码相同，否则乱码

序列化流
序列化（写入）反序列化（读取）
ObjectOutputStream extends OutputStream
把对象以流的形式写入文件
构造方法
ObjectOutputStream（OutputStream out）将指定对象写入文件
使用步骤：1.创建ObjectOutputStream对象，构造方法中传递字节输出流
         2.使用writeObject把对象写入文件

序列化和反序列化时，会抛出NotSerializableException异常
必须实现Serializable接口（标记型接口），给类一个标记

反序列化流
把文件中保存到对象读取出来使用
ObjectInputStream extends InputStream
构造方法
ObjectInputStream（InputStream in）创建从指定InputStream读取的ObjectInputStream
 参数：InputStream in字节输入流
 特有的成员方法
 Object readObject（）从ObjectInputStream读取对象classnotfound异常
使用步骤：1.创建对象
         2.使用readObject读取保存对象的文件
         3.释放资源
         4.使用

transient关键字：瞬态关键字？？
被其修饰的变量不能被序列化

打印流
PrintStream
特点：只负责数据输出
     永远不会抛出IOException
     特有方法 print println 输出任意类型的值
     可以改变打印流的流向（输出语句的目的地）使用System.setOut方法
构造方法
PrintStream（File file）输出目的地是文件
PrintStream（OutputStream out）字节输出流
PrintStream（String fileName）文件路径
注：若使用继承自父类的write写数据，则会查询编码97--->a
    若使用特有方法print等，97---->97
 */
public class D2101 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        outAndIn();
//        fuZhi();
//        ziFu();
//        paiXu();
//        writeUTF_8();
//        readUTF_8();
//        zhuanHuan();
//        xulie();
//        fanXuLie();
        lianXi();
    }
    
    private static void outAndIn() throws IOException {
        FileOutputStream fos =new FileOutputStream("day21\\a.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        bos.write("zzx\\".getBytes());
        bos.close();
        fos.close();

        FileInputStream fis = new FileInputStream("day21\\a.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
//        int len = 0;
//        while((len = bis.read()) != -1){
//            System.out.println(len);
//        }
        byte[] b = new byte[1024];
        int len = 0;
        while ((len = bis.read(b)) != -1){
            System.out.println(new String(b,0,len));
        }
        bis.close();
        fis.close();
    }

    private static void fuZhi() throws IOException {
        long time1 = System.currentTimeMillis();
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day21\\batimg.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day21\\fuZhi.jpg"));
//        int len = 0;
        while((len = bis.read()) != -1){
            bos.write(len);
        }
        byte[] b = new byte[1024];
        int len = 0;
        while((len = bis.read(b)) != -1){
            bos.write(b,0,len);
        }//为什么用数组更慢了，37ms和2ms，emmmmm
        bos.close();
        bis.close();
        long time2 = System.currentTimeMillis();
        System.out.println("复制jpg文件共耗时：" + (time2 - time1) + "ms");
    }

    private static void ziFu() throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("day21\\b.txt"));
        for (int i = 0; i < 2; i++) {
            bw.write("字符缓冲输出流。");
            bw.write("你看会有换行。");
            bw.newLine();
        }
        bw.flush();
        bw.close();

        BufferedReader br = new BufferedReader(new FileReader("day21\\b.txt"));
        String str;
        while((str = br.readLine()) != null){
            System.out.println(str);
        }
        br.close();//字符缓冲输出流。你看会有换行。
                   //字符缓冲输出流。你看会有换行。

    }

    private static void paiXu() throws IOException {
        HashMap<String,String> hm = new HashMap<>();
        BufferedReader br = new BufferedReader(new FileReader("day21\\c.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("day21\\d.txt"));
        String str;//读取输出设置成同一个地址就全空了。。
        while ((str = br.readLine()) != null){
            String[] s = str.split("\\.");
            hm.put(s[0],s[1]);
        }
        for(String key : hm.keySet()){
            String value = hm.get(key);
            str = key + "." + value;
            bw.write(str);
            bw.newLine();
    }
        bw.close();
        br.close();

    }

    private static void writeUTF_8() throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day21\\e.txt"),"gbk");
        for (int i = 0; i < 2; i++) {
            osw.write("啦啦啦啦！！！");
        }
        osw.flush();
        osw.close();
    }

    private static void readUTF_8() throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("day21\\e.txt"),"gbk");
        int len = 0;
        while((len = isr.read()) != -1){
            System.out.print((char)len);
        }
        isr.close();
    }

    private static void zhuanHuan() throws IOException {//gbk---->utf-8
        InputStreamReader isr = new InputStreamReader(new FileInputStream("day21\\e.txt"),"gbk");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day21\\f.txt"),"utf-8");
        int len = 0;
        while((len = isr.read()) != -1){
            osw.write(len);
        }
        osw.flush();
        osw.close();
        isr.close();
    }

    private static void xulie() throws IOException {//没有序列化接口NotSerializableException
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day21\\g.txt"));
        oos.writeObject(new Person("小周",17));
        oos.flush();
        oos.close();
    }

    private static void fanXuLie() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day21\\g.txt"));
        Object obj = ois.readObject();//throw异常
        ois.close();
        System.out.println(obj);//Person{name='小周', age=17}
    }

    private static void lianXi() throws IOException, ClassNotFoundException {//序列化集合，保存多个对象（集合），对集合进行序列化和反序列化
        ArrayList<Person> list = new ArrayList<>();
        //创建写入集合
        list.add(new Person("小明",13));
        list.add(new Person("小红",12));
        list.add(new Person("小周",17));
        //创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day21\\h.txt"));
        //序列化
        oos.writeObject(list);
        //创建反序列化流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day21\\h.txt"));
        //读取集合
        Object obj = ois.readObject();
        ois.close();
        oos.close();
        ArrayList<Person> list2 = (ArrayList<Person>) obj;
        System.out.println(list2);
    }
}

package day21;

import java.io.Serializable;

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;//设置一个固定不变的序列号，防止类修改后，新class与txt序列号不一致异常
    private String name;
    private int age;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}