美文网首页Java 杂谈码农的世界程序员
2019-03-04

2019-03-04

作者: DreamPath | 来源:发表于2019-03-05 23:50 被阅读15次

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

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

    高效缓冲流

    • 字节缓冲流： 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写入的基本数据和对象进行反序列化。

    相关文章

      网友评论

        本文标题：2019-03-04

        本文链接：https://www.haomeiwen.com/subject/elebuqtx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        Java 杂谈

        码农的世界

        程序员

        关于我们|服务条款|联系我们|2019-03-04|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！