IO:缓冲

原理详解:http://ifeve.com/java-io-char-buffered-filter/

BufferedInputStream字节流输入缓冲:

 1 void bufferedInputStream() {
 2         // BufferedInputStream带有缓冲区,多线程可见
 3         // 读取中文会乱码
 4         // 没有readLine()
 5         File file = new File("E:\\abcdata.txt");
 6         InputStream inputStream = null;
 7         BufferedInputStream bis = null;
 8         byte[] b = new byte[1024];
 9         int len;
10         StringBuilder sb = new StringBuilder();
11         try {
12             inputStream = new FileInputStream(file);
13             bis = new BufferedInputStream(inputStream);
14             while ((len = bis.read(b)) != -1) {
15                 String string = new String(b, 0, len, "UTF-8");
16                 sb.append(string);
17             }
18             System.out.println(sb);
19         } catch (FileNotFoundException e) {
20             // TODO Auto-generated catch block
21             e.printStackTrace();
22         } catch (IOException e) {
23             // TODO Auto-generated catch block
24             e.printStackTrace();
25         } finally {
26             if (bis != null) {
27                 try {
28                     bis.close();
29                 } catch (IOException e) {
30                     // TODO Auto-generated catch block
31                     e.printStackTrace();
32                 }
33             }
34         }
35
36     }

BufferedOutputStream字节流输出缓冲:

 1 void bufferedOutputStream() {
 2         File file = new File("E:\\abcdata.txt");
 3         OutputStream outputStream = null;
 4         BufferedOutputStream bos = null;
 5         byte[] b = new byte[1024];
 6         String s = "测试输出!!";
 7         try {
 8             outputStream = new FileOutputStream(file, true);
 9             bos = new BufferedOutputStream(outputStream);
10             b = s.getBytes();
11             bos.write(b);
12             // 刷新缓冲
13             bos.flush();
14         } catch (FileNotFoundException e) {
15             // TODO Auto-generated catch block
16             e.printStackTrace();
17         } catch (IOException e) {
18             // TODO Auto-generated catch block
19             e.printStackTrace();
20         } finally {
21             if (bos != null) {
22                 try {
23                     bos.close();
24                 } catch (IOException e) {
25                     // TODO Auto-generated catch block
26                     e.printStackTrace();
27                 }
28             }
29         }
30     }

BufferedReader字符流输入缓冲:

 1 void bufferedReader() {
 2         File file = new File("E:\\test.txt");
 3         BufferedReader br = null;
 4         Reader reader = null;
 5         String string;
 6         StringBuilder sb = new StringBuilder();
 7         try {
 8             reader = new FileReader(file);
 9             br = new BufferedReader(reader);
10             while ((string = br.readLine()) != null) {
11                 sb.append(string);
12             }
13             System.out.println(sb);
14         } catch (FileNotFoundException e) {
15             // TODO Auto-generated catch block
16             e.printStackTrace();
17         } catch (IOException e) {
18             // TODO Auto-generated catch block
19             e.printStackTrace();
20         } finally {
21             if (br != null) {
22                 try {
23                     br.close();
24                 } catch (IOException e) {
25                     // TODO Auto-generated catch block
26                     e.printStackTrace();
27                 }
28             }
29         }
30
31     }

BufferedWriter字符流输出缓冲:

 1 void bufferedWriter() {
 2         File file = new File("E:\\test.txt");
 3         Writer writer = null;
 4         BufferedWriter bw = null;
 5         String string = "test 测试!!";
 6         try {
 7             writer = new FileWriter(file,true);
 8             bw = new BufferedWriter(writer);
 9             bw.write(string);
10             bw.flush();
11         } catch (IOException e) {
12             // TODO Auto-generated catch block
13             e.printStackTrace();
14         } finally {
15             if (bw != null) {
16                 try {
17                     bw.close();
18                 } catch (IOException e) {
19                     // TODO Auto-generated catch block
20                     e.printStackTrace();
21                 }
22             }
23         }
24
25     }
时间: 2024-10-13 14:33:50

IO:缓冲的相关文章

一文快速了解Posix IO 缓冲

1. 背景知识 IO写入的过程是这样的: 用户数据 –> 进程IO缓冲区 –> 内核缓冲区 –> (磁盘缓冲区->磁盘) 通常我们认为一个写请求(注意我们讨论的粒度一定是一个request,在不同环节request可能会被拆分合并)落盘,则是在它从内核缓冲区(内存中的一块区域)刷到磁盘上(不关心磁盘缓冲区).对于持久化存储磁盘,当数据落盘成功后,断电/宕机数据依然会在磁盘上. 缓冲区公共的作用是聚集小IO,提高性能. 进程缓冲区.经常做IO写出的同学都知道,必要的时候我们会在代码里

Java文件与io——缓冲流

对文件或其它目标频繁的读写操作,效率低,性能差. 使用缓冲流的好处,能够更高效的读写信息,原理是将数据先缓冲起来,然后一起写入或者读取出来. BufferedInputStream:为另一个输入流添加一些功能,在创建时,会创建一个内部缓冲区数组,用于缓冲数据 BufferedOutputStream:通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必针对每次字节写入调用底层系统 BufferedReader:从字符输入流中读取文本,缓冲各个字符,从而实现字符.数组和行的高效读取

Unix环境之标准IO库

UNIX的文件IO都是针对文件描述符的,而标准IO的操作则是围绕流进行的.当一个流最初被创建时,它并没有定向.若在未定向的流上使用一个多字节IO函数,则将该流的定向设置为宽定向:若在未定向的流上使用一个单字节IO函数,则将该流的定向设置为字节定向. stdio.h定义了三个标准流,stdin.stdout和stderr,分别是标准输入.标准输出和标准出错. 缓冲-- 标准IO库提供缓冲的目的是尽可能减少使用read和write调用的次数.它也对每个IO流自动地进行缓冲管理,从而避免了应用程序需要

linux下的文件IO缓冲区,及其相关操作

linux下的文件IO操作 浅谈文件IO缓冲 Read()和write()函数在操作磁盘文件时不会直接发起磁盘访问,而是仅仅在用户空间缓冲区与内核缓冲区高速缓存之间复制数据. 当调用write()函数的写入3个字节的时候,由于系统调用与磁盘操作并不同步,在write()函数结束后续某个时刻,内核才会将其缓冲区中的数据写入磁盘.如果在此期间,另一个进程试图读取该文件的这几个字节,那么内核将自动从缓冲区高速缓存中提供这些数据,而不是文件中. 与此同理,对输入而言,内核从磁盘中读取数据并存储到内核缓冲

IO流简要总结

IO流小总结 IO流的本质就是用于数据的传输,根据流的方向的不同,有输入流.输出流.根据数据类型的不同,又有字节流.字符流. 字节流 字节输入流   InputStream 字节输出流   OutputStream 字节流:主要用来处理字节或二进制对象.例如:视频.音频.图片等. 字符流:主要用来处理字符.字符数组或者字符串文件.例如html.css.txt等 字节流又称万能流,能处理任何文件,但是在处理字符方面不太擅长,于是就有了字符流. 常用的基本方法 void close()  关闭此输出

10.4 缓冲流 BufferedReader & BufferedWriter& 缓冲流特殊功能readLine

缓冲流和正常流的使用大致相同,缓冲流效率更高. package day10_io_fileWrite_Read.buffer_stream; import java.io.*; /* * BufferedWriter:将文本写入字符输出流,缓冲各个字符,从而提供单个字符.数组和字符串的高效写入. * BufferedReader:从字符输入流中读取文本,缓冲各个字符,从而实现字符.数组和行的高效读取. */ public class BufferedStream { public static

文件描述符与文件指针等文件操作的几个问题

1.二者对比: 文件描述符就是open文件时产生的一个整数,直到一个索引作用,它用于UNIX系统中,用于标识文件.它是系统调用产生的. 文件指针是指向一个FILE的结构体,这个结构体里有一个元素就是文件描述符.它用于ANSI C标准的IO库调用中,用于标识文件.fopen是依赖于open的: 既然FILE中包含文件描述符元素,可以用fopen()直接获取指针fp,然后使用fp获得fp中所包含文件描述符fd的信息. 文件描述符应该是唯一的,但文件指针(值)却不是唯一的,但指向的对象却应该是唯一的.

C/C++框架和库 (真的很强大) 转

http://blog.csdn.net/xiaoxiaoyeyaya/article/details/42541419 值得学习的C语言开源项目 - 1. Webbench Webbench是一个在Linux下使用的非常简单的网站压测工具.它使用fork()模拟多个客户端同时访问我们设定的URL,测试网站在压力下工作的性能,最多可以模拟3万个并发连接去测试网站的负载能力.Webbench使用C语言编写, 代码实在太简洁,源码加起来不到600行. 下载链接:http://home.tiscali

C语言的角落——C之很常使用特性(一)

本文搜集整理了一些之前博客中没有提到的,C语言不经常使用的特性,算是对C系列的最后一次补充. 对C语言有兴趣的朋友能够浏览一下,查漏补缺. 变长參数列表 <stdarg.h> 头文件定义了一些宏,当函数參数未知时去获取函数的參数 变量:typedef  va_list 宏: va_start() va_arg() va_end() va_list类型通过stdarg宏定义来訪问一个函数的參数表.參数列表的末尾会用省略号省略 (va_list用来保存va_start,va_end所需信息的一种类

值得推荐的C/C++框架和库(深度好文)

[本文系外部转贴,原文地址:http://www.cppblog.com/merlinfang/archive/2014/12/26/209311.html http://coolshell.info/c/c++/2014/12/13/c-open-project.htm]留作存档 公交车上看到的好文,忍不住转发!下次造轮子前先看看现有的轮子吧-- 值得学习的C语言开源项目 - 1. Webbench Webbench是一个在linux下使用的非常简单的网站压测工具.它使用fork()模拟多个客