高效缓冲流，转换流，序列化流，打印流。。

• 能够高效读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等。

高效缓冲流

• 字节缓冲流： BufferedInputStream ， BufferedOutputStream
• 字符缓冲流： BufferedReader ， BufferedWriter
  缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO 次数，从而提高读写的效率。

效率测试

• 使用高效缓冲字节流一个字节一个字节的读取写入

package bufferedStream;

import java.io.*;

/**
 * public BufferedInputStream(InputStream in) ：创建一个新的缓冲输入流。
 * public BufferedOutputStream(OutputStream out) ： 创建一个新的缓冲输出流
 */
public class BufferedDemo {
    public static void main(String[] args) throws IOException {
        //计算开始时间
        long first=System.currentTimeMillis();
        BufferedInputStream inputStream =null;
        BufferedOutputStream outputStream=null;
        // 创建字节缓冲输入流
        try {
          inputStream= new BufferedInputStream(new FileInputStream("D:\\Java代码\\Java基础加强\\Day10\\src\\bufferedStream\\枪.mp4"));

          // 创建字节缓冲输出流
            outputStream=new BufferedOutputStream(new FileOutputStream("D:\\Java代码\\Java基础加强\\Day10\\src\\copy.mp4"));
          int len;

            while ((len=inputStream.read())!=-1) {
                outputStream.write(len);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) inputStream.close();
        }
       long end=System.currentTimeMillis();

        System.out.println("使用高校缓冲区所消耗的时间是："+(end-first)+"ms");
        //使用高校缓冲区所消耗的时间是：866ms
    }
}

** 使用普通字节流一个字节一个字节的读取写入**

package bufferedStream;

import java.io.*;

public class StreamDemo {
    public static void main(String[] args) {
        long begin=System.currentTimeMillis();

        FileInputStream in=null;
        FileOutputStream out=null;

        try {
            in=new FileInputStream("D:\\Java代码\\Java基础加强\\Day10\\src\\bufferedStream\\枪.mp4");
            out=new FileOutputStream("D:\\Java代码\\Java基础加强\\Day10\\src\\普通字节流复制.mp4");

            int len;
        while ((len=in.read())!=-1){
            out.write(len);
        }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (out == null) {
                try {
                    out.close();

                } catch (IOException e) {
                    e.printStackTrace();
                }
            } if (in == null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        long end=System.currentTimeMillis();

        System.out.println("使用普通字节流复制视频所需毫秒值为"+(end-begin));
        //使用普通字节流复制视频所需毫秒值为288631
        //  288631/1000/60=4.8分钟
        //实用高效缓冲区只需要886毫秒，也就是不到1秒的时间完成。
    }
}

** 使用字节数组，普通字节流来复制视频文件**

package bufferedStream_byteArray;

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

/**
 * 创建输入输出流对象
 * 创建字节数组读取
 */
public class StreamDemo2_ByteArray {
    public static void main(String[] args) {
        long begin=System.currentTimeMillis();

        FileInputStream in=null;
        FileOutputStream out=null;
        try {
            in=new FileInputStream("D:\\Java代码\\Java基础加强\\Day10\\src\\bufferedStream\\枪.mp4");
            out=new FileOutputStream("D:\\Java代码\\Java基础加强\\Day10\\src\\普通字节流复制.mp4");

            int len;
            byte [] bytes=new byte[1024];
            while ((len=in.read(bytes))!=-1){

                out.write(bytes,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (out == null) {
                try {
                    out.close();

                } catch (IOException e) {
                    e.printStackTrace();
                }
            } if (in == null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        long end=System.currentTimeMillis();

        System.out.println("使用普通字节流，字节数组复制视频所需时间为："+(end-begin)+"毫秒");

        //        使用普通字节流，字节数组复制视频所需时间为：507毫秒
            //明显快了不少

    }
}

使用高校缓冲区，字节数组测试

package bufferedStream_byteArray;

import java.io.*;

public class BufferedByteDemo {
    public static void main(String[] args) {
        //计算开始时间
        long first=System.currentTimeMillis();
        BufferedInputStream in =null;
        BufferedOutputStream out=null;
        // 创建字节缓冲输入流
        try {
            in= new BufferedInputStream(new FileInputStream("D:\\Java代码\\Java基础加强\\Day10\\src\\bufferedStream\\枪.mp4"));

            // 创建字节缓冲输出流
            out=new BufferedOutputStream(new FileOutputStream("D:\\Java代码\\Java基础加强\\Day10\\src\\copy.mp4"));
            int len;
                byte [] bytes=new byte[1024];
            while ((len=in.read(bytes))!=-1) {
                out.write(bytes,0,len);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        long end=System.currentTimeMillis();

        System.out.println("使用高校缓冲区，字节数组所消耗的时间是："+(end-first)+"ms");

        /**
         * 输出结果：使用高校缓冲区，字节数组所消耗的时间是：123ms
         */


    }
}

从这可以看出高效缓冲流，字节数组是最快的方式了，复制视频音乐文件。

字符缓冲流

BufferedReader
BufferedWriter

package buffered_Reader_Writer;

import java.io.*;

/**
 *  public BufferedReader(Reader in) ：创建一个 新的缓冲输入流。
 *  public BufferedWriter(Writer out) ： 创建一个新的缓冲输出流。
 *
 * 用于纯文本文件.
 *  特有方法:
 * 字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。
 * BufferedReader： public String readLine() : 读一行文字。
 * BufferedWriter： public void newLine() : 写一行行分隔符,由系统属性定义符号
 */
public class BUfferedDemo {
    public static void main(String[] args) {
        //计算开始时间
        long first=System.currentTimeMillis();
        //创建流对象
        BufferedReader reader=null;
        BufferedWriter writer=null;
        try {
         reader=new BufferedReader(new FileReader("D:\\Java代码\\Java基础加强\\ss.txt"));
        writer=new BufferedWriter(new FileWriter("D:\\Java代码\\Java基础加强\\sss.txt"));

       String line=null;

       while ((line=reader.readLine())!=null){
           System.out.println(line);
           writer.write(line);
           writer.newLine();
       }

        } catch (IOException e) {
            e.printStackTrace();
        }
        //计算开始时间
        long end=System.currentTimeMillis();

        System.out.println("消耗时间为"+(end-first));
//比较高效读取写入,专为字符串类型的。
    }
}

文本信息恢复顺序

package buffered_Reader_Writer;

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

/**
 * 实现排序，要先读取文本
 * 排序当然要使用集合，内容当然要截取，用到字符串的截取操作splt()方法：\\.
 *集合存的数据为序号和内容，以便后续操作排序，因此需要使用HashMap集合
 * 遍历集合，获取集合键，使用将
 */
public class PaiXuBufferedDemo {
    public static void main(String[] args)  {
        //计算开始时间
        long first=System.currentTimeMillis();
        //创建存储序号和内容的键和值的集合
        Map<String,String> map=new HashMap<>();
        //创建流对象
        try (BufferedReader reader = new BufferedReader(new FileReader("D:\\Java代码\\Java基础加强\\出师表乱序.txt"));
                BufferedWriter writer = new BufferedWriter(new FileWriter("D:\\Java代码\\Java基础加强\\出师表修正.txt"))) {

            String line = null;
            while ((line = reader.readLine()) != null) {
                // 解析文本
                String[] split = line.split("\\.");
                //将序号和内容别放入集合的键和值中
                map.put(split[0], split[1]);
            }
            for (int i = 1; i < map.size(); i++) {
                    //获取集合中的键值
                String key=String.valueOf(i);
                // 获取map中文本
                String value=map.get(key);
                // 写出拼接文本
                    writer.write(key+"."+value);
                    //换行
                    writer.newLine();

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //计算开始时间
        long end=System.currentTimeMillis();

        System.out.println("消耗时间为"+(end-first));
        //消耗时间为79  毫秒
    }

}

转换流

字符编码

存储：
- 在计算机中储存字符都是存储的所对应的数值以二进制的形式表示

展示：
- 去相关的编码表中查找该值（存储的值）所对应的字符。

常见的：
- ASCII表： 用7bit来表示存储数据

- ISO-8859-1:   拉丁码表

- GB2312：   简体中文编码（国标码）

- GBK：      gb2312做了增强        （做中文网站就够了）

- GB18030：  对GBK做了增强

- BIG5：     支持繁体中文

- Uniclde：      支持多种国家的语言，这是国际标准，用两个字节来储存
        - 不管是什么字符都是2个字节，会有浪费。

- UTF-8:（首选编码）支持多种国家的语言，针对不同字符的范围给出不同的字节表示。- 0，a，A用一个字符存储，中间的字节用两个字节，中文就使用三个字节

注意：

• 写入的编码和读取的编码必须要一致，否只会有乱码。

InputStreamReader类

• java.io.InputStreamReader是Reader的子类，也是从字节流到字符流的桥梁。
• 其字符集可以由名称指定，也可以接受平台的默认字符集。

指定编码读取

package in_out_Reader_Writer;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * InputStreamReader(InputStream in) : 创建一个使用默认字符集的字符流。
 * InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。
 */
public class InputStreamReaderDemo {

    public static void main(String[] args) throws IOException {
            // 创建流对象,默认UTF8编码
        InputStreamReader reader1 = new InputStreamReader(new FileInputStream("E:\\ssy.txt"));
        // 创建流对象,指定GBK编码
        InputStreamReader reader2 = new InputStreamReader(new FileInputStream("E:\\ssy.txt"),"gbk");

        //默认编码读取
        int le;
        while ((le=reader1.read())!=-1){

            System.out.print((char) le);
        }
        reader1.close();
        //指定编码读取
        int len;
        while ((len=reader2.read())!=-1){
                        System.out.print((char) len);
                    }
        reader2.close();

    }
}

OutputStreamWriter类

• 转换流 java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。
• 使用指定的字符集将字符编码为字节。其字符集可以由名称指定，也可以接受平台的默认字符集。

package in_out_Reader_Writer;

import java.io.*;

/**
 * OutputStreamWriter(OutputStream in) : 创建一个使用默认字符集的字符流。
 * OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流
 */
public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter writer1=new OutputStreamWriter(new FileOutputStream("D:\\Java代码\\Java基础加强\\ms1.txt"));

        OutputStreamWriter writer2=new OutputStreamWriter(new FileOutputStream("D:\\Java代码\\Java基础加强\\ms2.txt"),"gbk");
        
            writer1.write("你好");//默认的编码为utf-8   你好  字节数为  6
            writer1.close();//你好

            writer2.write("你好");  //gbk  两个字节一个字   存储字节数为  4
            writer2.close();//���


    }

}

转换文件编码
将GBK编码的文本文件，转换为UTF-8编码的文本文件。

打印流

只做输出没有输入
分为字节打印流和字符打印流
PrintWriter：字符打印流
特点： 1.可以打印各种数据类型
2.封装了字符输入流，还可以实现字符流和字节流的转换
3.可以使用自动刷新，则只有再调用println，printf或者format的其中一个方法时才能完成此操作
4.可以直接向文件中写数据

序列化流（对象流）
范例：从txt文件中加载属性信息
把对象以流的形式存储在硬盘上或者数据库中的过程就是写序列化流。
序列化流：
对象输出流：
ObjectOutputStream将Java对象的基本数据类型和图形写入OutputStream。
对象输入流：
ObjectInputStream对以前使用的ObjectOutputStream写入的基本数据和对象进行反序列化。