精华内容
下载资源
问答
  • 字节缓冲流

    2019-09-24 07:23:34
    1 字节缓冲流 字节缓冲流根据流的方向,共有2个 写入数据到流中,字节缓冲输出流 BufferedOutputStream 读取流中的数据,字节缓冲输入流 BufferedInputStream 它们的内部都包含了一个缓冲区,通过缓冲区读写...

    缓冲流

    读取数据量大的文件时,读取的速度会很慢,很影响我们程序的效率

    Java中提高了一套缓冲流,它的存在,可提高IO流的读写速度

    1 字节缓冲流

    字节缓冲流根据流的方向,共有2个

     写入数据到流中,字节缓冲输出流 BufferedOutputStream

     读取流中的数据,字节缓冲输入流 BufferedInputStream

    它们的内部都包含了一个缓冲区,通过缓冲区读写,就可以提高了IO流的读写速度。

    1.1 字节缓冲输出流BufferedOutputStream

    构造方法:public BufferedOutputStream(OutputStream out)

    复制代码
        //字节输出缓冲流
        public static void method01() throws IOException{
            FileOutputStream fos=new FileOutputStream("E:\\java\\demo.txt");
            BufferedOutputStream bos=new BufferedOutputStream(fos);
            fos.write(100);
            bos.close();
        }
    复制代码

    1.2字节缓冲输入流BufferedInputStream

    构造方法:

    public BufferedInputStream(InputStream in) 

    复制代码
    //字节输入缓冲流
        public static void method02() throws IOException{
            FileInputStream fis=new FileInputStream("E:\\java\\demo.txt");
            BufferedInputStream bis=new BufferedInputStream(fis);
            int len=0;
            while((len=bis.read())!=-1){
                System.out.println((char)len);
            }
            bis.close();
        }
    复制代码

       使用基本的流与高效的流完成复制文件

    复制代码
    //单个字节,字节缓冲流复制
        public static void method04() throws IOException{
            //明确数据源
            FileInputStream fis=new FileInputStream("E:\\java\\aaa.zip");
            BufferedInputStream bis=new BufferedInputStream(fis);
            //明确目的地
            FileOutputStream fos=new FileOutputStream("E:\\java\\a\\aaa.zip");
            BufferedOutputStream bos=new BufferedOutputStream(fos);
            //开始复制
            long time1=System.currentTimeMillis();
            int len=0;
            byte[] ch=new byte[1024];
            while((len=bis.read(ch))!=-1){
                bos.write(ch,0,len);
            }
            long time2=System.currentTimeMillis();
            System.out.println(time2-time1);
            //释放资源
            bos.close();
            bis.close();
        }
    复制代码

    转载于:https://www.cnblogs.com/lxzwhite/p/10668466.html

    展开全文
  • 1. 缓冲流 1.1 缓冲流的作用 使用缓冲数组以后,整体的读取,写入效率提升很大!!! 降低了CPU通过内存访问硬盘的次数。提高效率,降低磁盘损耗。 字节输入缓冲 BufferedInputStream ...1.2 字节缓冲流
  • java IO流学习笔记——(3)字节缓冲流&字符缓冲流&转换流&数据流 目录java IO流学习笔记——(3)字节缓冲流&字符缓冲流&转换流&数据流字节缓冲流 —BufferedInputStream&BufferedOutputStream字符缓冲流—...
  • 缓冲流之字节缓冲流

    2019-01-04 20:04:00
    1 字节缓冲流 字节缓冲流根据流的方向,共有2个 写入数据到流中,字节缓冲输出流 BufferedOutputStream 读取流中的数据,字节缓冲输入流 BufferedInputStream 它们的内部都包含了一个缓冲区,通过缓冲区读写,就...

    缓冲流

    读取数据量大的文件时,读取的速度会很慢,很影响我们程序的效率

    Java中提高了一套缓冲流,它的存在,可提高IO流的读写速度

    1 字节缓冲流

    字节缓冲流根据流的方向,共有2个

     写入数据到流中,字节缓冲输出流 BufferedOutputStream

     读取流中的数据,字节缓冲输入流 BufferedInputStream

    它们的内部都包含了一个缓冲区,通过缓冲区读写,就可以提高了IO流的读写速度。

    1.1 字节缓冲输出流BufferedOutputStream

    构造方法:public BufferedOutputStream(OutputStream out)

        //字节输出缓冲流
        public static void method01() throws IOException{
            FileOutputStream fos=new FileOutputStream("E:\\java\\demo.txt");
            BufferedOutputStream bos=new BufferedOutputStream(fos);
            fos.write(100);
            bos.close();
        }

    1.2字节缓冲输入流BufferedInputStream

    构造方法:

    public BufferedInputStream(InputStream in) 

    //字节输入缓冲流
        public static void method02() throws IOException{
            FileInputStream fis=new FileInputStream("E:\\java\\demo.txt");
            BufferedInputStream bis=new BufferedInputStream(fis);
            int len=0;
            while((len=bis.read())!=-1){
                System.out.println((char)len);
            }
            bis.close();
        }

       使用基本的流与高效的流完成复制文件

    //单个字节,字节缓冲流复制
        public static void method04() throws IOException{
            //明确数据源
            FileInputStream fis=new FileInputStream("E:\\java\\aaa.zip");
            BufferedInputStream bis=new BufferedInputStream(fis);
            //明确目的地
            FileOutputStream fos=new FileOutputStream("E:\\java\\a\\aaa.zip");
            BufferedOutputStream bos=new BufferedOutputStream(fos);
            //开始复制
            long time1=System.currentTimeMillis();
            int len=0;
            byte[] ch=new byte[1024];
            while((len=bis.read(ch))!=-1){
                bos.write(ch,0,len);
            }
            long time2=System.currentTimeMillis();
            System.out.println(time2-time1);
            //释放资源
            bos.close();
            bis.close();
        }

     

    转载于:https://www.cnblogs.com/zzq123/p/10222184.html

    展开全文
  • 1、字节缓冲流首先要明确一个概念:对文件或其他目标频繁的读写操作,效率低,性能差。使用缓冲流的好处是,能够高效的读写信息,原理是将数据先缓冲起来,然后一起写入或者读取出来。BufferedInputStream:为另一个...

    1、字节缓冲流

    首先要明确一个概念:对文件或其他目标频繁的读写操作,效率低,性能差。

    使用缓冲流的好处是,能够高效的读写信息,原理是将数据先缓冲起来,然后一起写入或者读取出来。

    BufferedInputStream:为另一个输入流添加一些功能,在创建BufferedInputStream时,会创建一个内部缓冲区数组,用于缓冲数据。

    BufferedOutputStream:通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必针对每次字节写入调用底层系统。

    import java.io.BufferedInputStream;

    import java.io.BufferedOutputStream;

    import java.io.File;

    import java.io.FileInputStream;

    import java.io.FileNotFoundException;

    import java.io.FileOutputStream;

    import java.io.IOException;

    import java.io.InputStream;

    import java.io.OutputStream;

    /**

    * 缓存的目的:解决写入文件操作时,频繁的操作文件所带来的性能降低的问题

    * BufferedOutputStream内部默认的缓存大小是8kb,每次写入时存储到缓存中的byte数组中, 会把数组中的数据写入文件,并且下标归零

    */

    public class BufferedStreamDemo {

    public static void main(String[] args) {

    byteWriter();

    byteReader();

    }

    private static void byteReader() {

    File file = new File("F:/test.txt");

    try {

    InputStream in = new FileInputStream(file);

    // 构造一个字节缓冲流

    BufferedInputStream bis = new BufferedInputStream(in);

    byte[] flush = new byte[1024];

    int len = -1;

    while ((len = bis.read(flush)) != -1) {

    System.out.println(new String(flush, 0, len));

    }

    bis.close();

    } catch (FileNotFoundException e) {

    e.printStackTrace();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }// byteReader

    private static void byteWriter() {

    File file = new File("F:/test.txt");

    try {

    OutputStream out = new FileOutputStream(file, true);

    BufferedOutputStream bos = new BufferedOutputStream(out);

    String info = "你爱Java吗?";

    bos.write(info.getBytes());

    bos.close();

    } catch (FileNotFoundException e) {

    e.printStackTrace();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }// byteWriter

    }

    2、字符缓冲流

    BufferedReader:从字符输入流中读取文本,缓冲各个字节,从而实现字符、数组和行的高效读取。

    BufferedWriter:将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。

    private static void charWriter() {

    File file = new File("F:/test.txt");

    try {

    Writer writer = new FileWriter(file, true);

    BufferedWriter bw = new BufferedWriter(writer);

    bw.write("我爱Java SE");

    bw.flush();

    bw.close();

    } catch (FileNotFoundException e) {

    e.printStackTrace();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }// charWriter

    private static void charReader() {

    File file = new File("F:/test.txt");

    try {

    Reader reader = new FileReader(file);

    // 为字符流提供缓存,达到高效读取的目的

    BufferedReader br = new BufferedReader(reader);

    char[] buf = new char[1024];

    int len = -1;

    while ((len = br.read(buf)) != -1) {

    System.out.println(new String(buf, 0, len));

    }

    br.close();// 不用关闭reader,是因为关闭br时内部已经帮我们关闭了reader

    } catch (FileNotFoundException e) {

    e.printStackTrace();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }// charReader

    为什么要用字符缓冲流

    字符缓冲流: 加入字符缓冲流,增强读取功能,新增方法readLine() 更高效的读取

    FileReader:内部使用InputStreamReader,解码过程,byte->char,默认缓存大小是8k

    BufferedReader:默认缓存大小是8k,但是可以手动指定大小,把数据直接读取到缓存中,减少转换过程的次数,效率更高。所以虽然FileReader中已经加入了缓存,仍要加上BufferedReader的原因

    展开全文
  • 缓冲流_01字节缓冲流

    2020-07-03 00:31:48
    字节缓冲流:BufferedInputStream / BufferedOutputStream 字符缓冲流:BufferedReader / BufferedWriter 基本原理:创建流对象时,会创建一个内存的默认大小的缓冲区数组,通过缓冲区读写,减少系统IO次数,从而...

    概述

    缓冲流,也叫高效流,是对四个基本的Filexxx流的增强,也是流

    • 字节缓冲流:BufferedInputStream / BufferedOutputStream
    • 字符缓冲流:BufferedReader / BufferedWriter

    基本原理:创建流对象时,会创建一个内存的默认大小的缓冲区数组,通过缓冲区读写,减少系统IO次数,从而提高读写的效率。

    字节缓冲流

    1、java.io.BufferedOutputStream extends FilterOutputStream extends OutputStream

    • BufferedOutputStream:字节缓冲输出流

    • 继承父类的共性成员方法:
      - void close() 关闭此输出流并释放与此流有关的所有系统资源。
      - void flush() 刷新此输出流并强制写出所有缓冲的输出字节。

      • 写入一个字节:
        • abstract void write(int b) 将指定的字节写入此输出流。
      • 一次写多个字节:
        • void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
        • void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
    • 构造方法:
      - BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流,以将数据写入指定的底层输出流。
      - BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流,以将具有指定缓冲区大小的数据写入指定的底层输出流。

      • 参数:
        OutputStream out:字节输出流,可以传递FileOutputStream,缓冲流会给FileOutputStream增加一个缓冲区,提高FileOutputStream的写入效率
        int size:指定缓冲流内部缓冲区的大小,不指定则使用系统默认的大小
    • 使用步骤(重点):
      1 创建FileOutputStream对象,构造方法中绑定要输出的目的地
      2 创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象,提高FileOutputStream对象效率
      3 使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中
      4 使用BufferedOutputStream对象中的方法flush,把内部缓冲区的数据刷新到文件中
      5 释放资源(会先把内存缓冲区的数据刷新到文件中,第4步可以省略)

    public class demo02BufferedOutputStream {
    	public static void main(String[] args) throws IOException {
    		FileOutputStream fos = new FileOutputStream("D:\\Eclipse\\workplace\\day1\\src\\num11\\a.txt");
    		BufferedOutputStream bos = new BufferedOutputStream(fos);
    		bos.write("我把数据写入到内存缓冲区".getBytes());
    		bos.flush();  //可省略
    		bos.close();
    	}
    }
    

    2、 java.io.BufferedInputStream extends FilterInputStream extends InputStream

    • BufferedInputStream:字节缓冲输入流

    • 继承自父类的成员方法:
      - abstract int read() 从输入流中读取数据的下一个字节。
      - int read(byte[] b) 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。
      - void close() 关闭此输入流并释放与该流关联的所有系统资源

    • 构造方法:
      - BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。
      - BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用

      • 参数:
        InputStream in:字节输入流,可以传递FilterInputStream,缓冲流会给FilterInputStream增加一个缓冲区,提高FilterInputStream的读取效率
        int size:指定缓冲流内部缓冲区的大小,不指定则使用系统默认的大小
    • 使用步骤(重点):
      1 创建FilterInputStream对象,构造方法中绑定要读取的数据源
      2 创建BufferedInputStream对象,构造方法中传递FilterInputStream对象,提高FilterInputStream对象的读取效率
      3 使用BufferedInputStream对象中的方法read,读取文件
      4 释放资源(会先把内存缓冲区的数据刷新到文件中,第4步可以省略)

    public class demo03BufferedInputStream {
    	public static void main(String[] args) throws IOException {
    		FileInputStream fis = new FileInputStream("D:\\Eclipse\\workplace\\day1\\src\\num11\\a.txt");
    		BufferedInputStream bis = new BufferedInputStream(fis);
    		/*
    		int len = 0;
    		while((len = bis.read())!= -1) {
    			System.out.println(len);
    		}
    		*/
    		int len = 0; //有效读取的字节个数
    		byte[] bytes = new byte[1024];  //存储每次读取的数据
    		while((len = bis.read(bytes))!= -1) {
    			System.out.println(new String(bytes,0,len));  //ABC
    		}
    		bis.close();  //只需要关闭bis,fis会随之关闭
    	}
    }
    
    1. 文件复制案例(测试缓冲流效率)
    /*
     	使用缓冲流:
     		1 创建一个字节缓冲输入流对象,构造方法绑定要读取的数据源
     		2 创建一个字节缓冲输出流对象,构造方法中绑定要写入的目的地
     		3 使用字节缓冲输入流对象中的方法read读取文件
     		4 使用字节缓冲输出流对象中的方法write,把读取的数据写入内部缓冲区中
     		5 释放资源(会先把内存缓冲区的数据刷新到文件中)
     		
     	不使用缓冲流:一次读取一个字符1431ms ---> 一次读取多个字符4ms 
     	使用缓冲流:一次读取一个字符:13ms   ---> 一次读取多个字符3ms
     //可能因为文件不够大,只有读取单个字符时效率差大,使用数组都有缓冲,所以时间差距小。
    */
    public class demo05BufferCopyFile {
    	public static void main(String[] args) throws IOException {
    		long b = System.currentTimeMillis();
    		//1 创建一个字节缓冲输入流对象,构造方法绑定要读取的数据源
    		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\d3.jpg"));
    		//2 创建一个字节缓冲输出流对象,构造方法中绑定要写入的目的地
    		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\d4.jpg"));
    		//3 使用字节缓冲输入流对象中的方法read读取文件
    		/*
    		int len = 0;
    		while((len = bis.read())!= -1) {
    			bos.write(len);
    		}
    		*/
    		//使用数组
    		int len = 0;
    		byte[] bytes = new byte[1024];
    		while((len = bis.read(bytes))!= -1) {
    			bos.write(bytes,0,len);
    		}
    		
    		bos.close();  //先关闭写
    		bis.close();
    		long e = System.currentTimeMillis();
    		System.out.println("复制文件耗时:"+(e-b)+"毫秒");  //复制文件耗时:1毫秒
    	}
    }
    
    
    展开全文
  • 字节缓冲流 1.介绍 字节缓冲流根据流的方向,分为: 1.写入数据到流中,字节缓冲输出流 BufferedOutputStream 2.读取流中的数据,字节缓冲输入流 BufferedInputStream 它们的内部都包含了一个缓冲区,通过缓冲...
  • IO流(文件 字节流 字节缓冲流)一、文件File类1.File 类的构造方法2.File类的获取方法二、IO流1.IO流的定义2.IO流的分类3.IO流顶层父类三、字节流1.字节输出流 OutputStream2.字节输出流子类 FileOutputStream构造...
  • JAVA—缓冲流(字节缓冲流和字符缓冲流) 字节缓冲输出流: BufferedOutputStream 方法: BufferedOutputStream(OutputStream out):参数:字节输出流 BufferedOutputStream(OutputStream out , int size):参数1:...
  • 目录一、使用字节缓冲流 一、使用字节缓冲流 BufferedInputStream和BufferedOutputStream称为字节缓冲流,使用字节缓冲流内置了一个缓冲区,第 一次调用read方法时尽可能多地从数据源读取数据到缓冲区,后续再到用...
  • 处理流(装饰流):字节缓冲流,字符缓冲流:用于提高字节流的性能 BufferedInputStream,BufferedOutputStream (字节缓冲流) BufferedInputStream is = new BufferedInputStream(new FileInputStream(file)); ...
  • 字节缓冲流&字符流

    2020-12-22 08:59:28
    1.字节缓冲流 1.1字节缓冲流构造方法【应用】 字节缓冲流介绍 lBufferOutputStream:该类实现缓冲输出流。 通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用...
  • Java字节缓冲流

    2020-08-02 17:00:31
    1字节缓冲流构造方法【应用】 2字节流复制视频【应用】 1字节缓冲流构造方法【应用】 字节缓冲流介绍 lBufffferOutputStream:该类实现缓冲输出流。 通过设置这样的输出流,应用程序可以向底层输出流写 入...
  • 字节缓冲流、字符流

    2020-03-16 14:02:21
    1. 字节缓冲流 - 输出字节缓冲流:BufferedOutPutStream(OutPutStream) flush()刷新缓冲区 - 读入字节缓冲流:BufferedInPutStream(InputStream)2. 为什么出现字符流 - 因为字节流操作中文不方便 - Idea:默认UTF-...
  • 文章目录缓冲流1、字节缓冲流构造方法2、字符缓冲流构造方法练习:文章段落排序 缓冲流 缓冲流在基础的字节流和字符流上做功能的增强,能够高效读写的缓冲流,能够转换编码的转换流,能够持久化存储对象的序列化。 ...
  • 字节缓冲流& 字符流

    2020-08-16 09:16:33
    1. 字节缓冲流 1.1 字节缓冲流构造方法【应用】 字节缓冲流介绍 IBufferOutputStream:该类实现缓冲 输出流。通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用...
  • 字节缓冲流 & 字符流

    2020-08-14 00:16:46
    1.字节缓冲流 1.1字节缓冲流构造方法【应用】 字节缓冲流介绍 lBufferOutputStream:该类实现缓冲输出流。 通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用...
  • 使用字节缓冲流

    2020-03-18 22:24:11
    BufferedInputStream和BufferedOutputStream称为字节缓冲流。使用字节缓冲流内置了一个缓冲区,使用了缓冲字节流可以减少I/O操作次数,提高效率。 BufferedInputStream构造方法主要有: BufferedInputStream...
  • 字节缓冲流与字符流

    2019-11-28 22:42:53
    1.字节缓冲流 1.1字节缓冲流构造方法【应用】 字节缓冲流介绍 lBufferOutputStream:该类实现缓冲输出流。 通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用...
  • 字节缓冲流与字符缓冲流 缓冲流解决多次对文件进行操作带来的性能降低 字节缓冲流BufferedOutputStream、BufferedInputStream 字符缓冲流BufferedWriter、BufferedReader import java.io.BufferedOutputStream; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,234
精华内容 3,293
关键字:

字节缓冲流