java I-O流（转载）

最新推荐文章于 2024-10-31 15:56:11 发布
最新推荐文章于 2024-10-31 15:56:11 发布
阅读量82 收藏
点赞数
分类专栏： java 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mc46790090/article/details/84530436
版权

原文地址：http://249326109.iteye.com/blog/1321915

Java 的10 流是实现输入/输出的基础，它可以方便地实现数据的输入/输出操作， Java 中把不同的输入/输出源(键盘、文件、网络连接等)抽象表述为"流" (stream) ，通过流的方式允许Java 程序使用相同的方式来访问不同的输入/输出源。stream 是从起源(source) 到接收(sink) 的有序数据。

      流按照相对于内存的方向分为输入流和输出流，也可以按照读写的单位分为字节流和字符流,而且还可以根据流的使用不同分为节点流和封装流（采用了典型的装饰器的设计模式，使得IO流用起来非常灵活）。

 

以下来自core java:

      In the Java API, an object from which we can read a sequence of bytes is called an input stream. An object to which we can write a sequence of bytes is called an output stream. These sources and destinations of byte sequences can be—and often are—files, but they can also be network connections and even blocks of memory. The abstract classes InputStream and OutputStream form the basis for a hierarchy of input/output (I/O) classes.

      Because byte-oriented streams are inconvenient for processing information stored in Unicode (recall that Unicode uses multiple bytes per character), there is a separate hierarchy of classes for processing Unicode characters that inherit from the abstract Reader and Writer classes. These classes have read and write operations that are based on two-byte Unicode code units rather than on single-byte characters.

 

    以下是字节流和字符流的层次图。

 

 

 

 





 
 

 




 


 由上图可看出，java IO 体系中有访问文件，数组，管道和字符串的节点流；以及缓冲流，对象流，推回输入流，特殊流

等高层处理流；还有两个转换流。

 下面程序分别使用了字节和字符读取文件并复制一份，并且与buffered版本进行了对比。

Java代码 复制代码  收藏代码
  1. package stream;   
  2.   
  3. import java.io.BufferedInputStream;   
  4. import java.io.BufferedOutputStream;   
  5. import java.io.BufferedReader;   
  6. import java.io.BufferedWriter;   
  7. import java.io.FileInputStream;   
  8. import java.io.FileOutputStream;   
  9. import java.io.FileReader;   
  10. import java.io.FileWriter;   
  11. import java.io.IOException;   
  12. import java.io.Writer;   
  13.   
  14. public class Streamtest {   
  15.   
  16.     /**  
  17.      * @param args  
  18.      * @throws IOException  
  19.      */  
  20.     public static void main(String[] args) throws IOException {   
  21.         FileInputStream fileInputStream = null;   
  22.         FileOutputStream fileOutputStream = null;   
  23.         FileReader fReader = null;   
  24.         FileWriter fWriter = null;   
  25.         BufferedInputStream bis = null;   
  26.         BufferedOutputStream bos = null;   
  27.         BufferedReader br=null;   
  28.         BufferedWriter bw=null;   
  29.            
  30.         //stream   
  31.         long byteStart =System.currentTimeMillis();   
  32.         try {   
  33.                
  34.             fileInputStream = new FileInputStream("三国演义.txt");   
  35.             fileOutputStream = new FileOutputStream("三国演义副本一.txt");   
  36.             int hasRead = 0;   
  37.             byte[] buf = new byte[10];   
  38.             while ((hasRead = fileInputStream.read(buf)) > 0) {   
  39.                 fileOutputStream.write(buf, 0, hasRead);   
  40.             }   
  41.         } catch (IOException e) {   
  42.             e.printStackTrace();   
  43.         } finally {   
  44.             if (fileInputStream != null)   
  45.                 fileInputStream.close();   
  46.             if (fileOutputStream != null)   
  47.                 fileOutputStream.close();   
  48.             long byteEnd=System.currentTimeMillis();   
  49.             System.out.println("字节复制完毕！花费"+(byteEnd-byteStart)+" ms.");   
  50.         }   
  51.         //buffered stream   
  52.         long bufferedByteStart =System.currentTimeMillis();   
  53.         try {   
  54.                
  55.             fileInputStream = new FileInputStream("三国演义.txt");   
  56.             fileOutputStream = new FileOutputStream("buffered三国演义副本一.txt");   
  57.             bis=new BufferedInputStream(fileInputStream);   
  58.             bos=new BufferedOutputStream(fileOutputStream);   
  59.             int hasRead = 0;   
  60.             byte[] buf = new byte[10];   
  61.             while ((hasRead = bis.read(buf)) > 0) {   
  62.                 bos.write(buf, 0, hasRead);   
  63.             }   
  64.         } catch (IOException e) {   
  65.             e.printStackTrace();   
  66.         } finally {   
  67.             if (bis != null)   
  68.                 bis.close();   
  69.             if (bos != null)   
  70.                 bos.close();   
  71.             long bufferedByteEnd=System.currentTimeMillis();   
  72.             System.out.println("buffered字节复制完毕！花费"+(bufferedByteEnd-bufferedByteStart)+" ms.");   
  73.         }   
  74.            
  75.                
  76.         //reader writer   
  77.         long charStart=System.currentTimeMillis();   
  78.         try {   
  79.             fReader = new FileReader("三国演义.txt");   
  80.             fWriter = new FileWriter("三国演义副本二.txt");   
  81.             char[] cbuf = new char[10];   
  82.             int hasRead = 0;   
  83.             while ((hasRead = fReader.read(cbuf)) > 0) {   
  84.                 fWriter.write(cbuf, 0, hasRead);   
  85.             }   
  86.   
  87.         } catch (IOException e) {   
  88.             // TODO: handle exception   
  89.         } finally {   
  90.             if (fReader != null)   
  91.                 fReader.close();   
  92.             if (fWriter != null)   
  93.                 fWriter.close();   
  94.             long charEnd=System.currentTimeMillis();   
  95.             System.out.println("字符复制完毕！ 花费"+(charEnd-charStart)+" ms.");   
  96.         }   
  97.            
  98.         //buffered reader writer    
  99.         long bufferedCharStart=System.currentTimeMillis();   
  100.         try {   
  101.             fReader = new FileReader("三国演义.txt");   
  102.             fWriter = new FileWriter("buffered三国演义副本二.txt");   
  103.             br=new BufferedReader(fReader);   
  104.             bw=new BufferedWriter(fWriter);   
  105.             char[] cbuf = new char[10];   
  106.             int hasRead = 0;   
  107.             while ((hasRead = br.read(cbuf)) > 0) {   
  108.                 bw.write(cbuf, 0, hasRead);   
  109.             }   
  110.   
  111.         } catch (IOException e) {   
  112.             // TODO: handle exception   
  113.         } finally {   
  114.             if (br != null)   
  115.                 br.close();   
  116.             if (bw != null)   
  117.                 bw.close();   
  118.             long bufferedCharEnd=System.currentTimeMillis();   
  119.             System.out.println("buffered字符复制完毕！花费"+(bufferedCharEnd-bufferedCharStart)+" ms.");   
  120.         }   
  121.   
  122.     }   
  123.   
  124. }  
package stream;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class Streamtest {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		FileInputStream fileInputStream = null;
		FileOutputStream fileOutputStream = null;
		FileReader fReader = null;
		FileWriter fWriter = null;
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		BufferedReader br=null;
		BufferedWriter bw=null;
		
		//stream
		long byteStart =System.currentTimeMillis();
		try {
			
			fileInputStream = new FileInputStream("三国演义.txt");
			fileOutputStream = new FileOutputStream("三国演义副本一.txt");
			int hasRead = 0;
			byte[] buf = new byte[10];
			while ((hasRead = fileInputStream.read(buf)) > 0) {
				fileOutputStream.write(buf, 0, hasRead);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fileInputStream != null)
				fileInputStream.close();
			if (fileOutputStream != null)
				fileOutputStream.close();
			long byteEnd=System.currentTimeMillis();
			System.out.println("字节复制完毕！花费"+(byteEnd-byteStart)+" ms.");
		}
		//buffered stream
		long bufferedByteStart =System.currentTimeMillis();
		try {
			
			fileInputStream = new FileInputStream("三国演义.txt");
			fileOutputStream = new FileOutputStream("buffered三国演义副本一.txt");
			bis=new BufferedInputStream(fileInputStream);
			bos=new BufferedOutputStream(fileOutputStream);
			int hasRead = 0;
			byte[] buf = new byte[10];
			while ((hasRead = bis.read(buf)) > 0) {
				bos.write(buf, 0, hasRead);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (bis != null)
				bis.close();
			if (bos != null)
				bos.close();
			long bufferedByteEnd=System.currentTimeMillis();
			System.out.println("buffered字节复制完毕！花费"+(bufferedByteEnd-bufferedByteStart)+" ms.");
		}
		
			
		//reader writer
		long charStart=System.currentTimeMillis();
		try {
			fReader = new FileReader("三国演义.txt");
			fWriter = new FileWriter("三国演义副本二.txt");
			char[] cbuf = new char[10];
			int hasRead = 0;
			while ((hasRead = fReader.read(cbuf)) > 0) {
				fWriter.write(cbuf, 0, hasRead);
			}

		} catch (IOException e) {
			// TODO: handle exception
		} finally {
			if (fReader != null)
				fReader.close();
			if (fWriter != null)
				fWriter.close();
			long charEnd=System.currentTimeMillis();
			System.out.println("字符复制完毕！ 花费"+(charEnd-charStart)+" ms.");
		}
		
		//buffered reader writer 
		long bufferedCharStart=System.currentTimeMillis();
		try {
			fReader = new FileReader("三国演义.txt");
			fWriter = new FileWriter("buffered三国演义副本二.txt");
			br=new BufferedReader(fReader);
			bw=new BufferedWriter(fWriter);
			char[] cbuf = new char[10];
			int hasRead = 0;
			while ((hasRead = br.read(cbuf)) > 0) {
				bw.write(cbuf, 0, hasRead);
			}

		} catch (IOException e) {
			// TODO: handle exception
		} finally {
			if (br != null)
				br.close();
			if (bw != null)
				bw.close();
			long bufferedCharEnd=System.currentTimeMillis();
			System.out.println("buffered字符复制完毕！花费"+(bufferedCharEnd-bufferedCharStart)+" ms.");
		}

	}

}

 

结果可以看出，buffered封装后却是提高了效率。

Java代码 复制代码  收藏代码
  1. 字节复制完毕！花费1020 ms.   
  2. buffered字节复制完毕！花费21 ms.   
  3. 字符复制完毕！ 花费90 ms.   
  4. buffered字符复制完毕！花费30 ms.   
字节复制完毕！花费1020 ms.
buffered字节复制完毕！花费21 ms.
字符复制完毕！ 花费90 ms.
buffered字符复制完毕！花费30 ms.

 

关于buffer：首先要知道什么是缓冲，buffering，如CPU和硬盘之间的关系，寄存器或内存就是作为缓冲，如果没有缓冲，当CPU要向硬盘存取数据时，只能直接存取，导致效率低下。
比如总共要读取10个字符，每次用一个，那只能每次从硬盘读一个用一个，如果有缓冲，就能先直接缓冲10个，然后再从缓冲中读一个用一个，出于硬件条件等的天生受限，使用buffering会大大提高效率。

 

PrintStream 和 PrintWriter

 

PrintStream是OutputStream的子类，PrintWriter是Writer的子类，两者处于对等的位置上，所以它们的API是非常相似的。PrintWriter实现了PritnStream的所有print方法。对于PrintStream，所有println方法都在内部调用相应的print方法，比如println(char x)的方法体就是调用print(x);再写入一个平台相关的换行符。PrintStream构建时会在内部new一个BufferedWriter，所有print方法都在内部调用这个Writer的write方法（write(String)或write(char[])）——对于print(char[])，直接调用write(char[])；对于其他的print方法，先用String.valueOf获得参数的字符串表示，然后调用write(String)。
         对于PrintWriter，所有println方法也都在内部调用print方法，print方法调用write方法。传入OutputStream时，PrintWriter会在内部构造一个BufferedWriter；而传入Writer时，PrintStream内部直接使用该Writer，此时PrintWriter是否进行了缓冲全看该Writer。
所以，对于使用print系列方法的场合，二者没什么区别。

         但是，PrintStream是字节流，它有处理raw byte的方法，write(int)和write(byte[],int,int)；PrintWriter是字符流，它没有处理raw byte的方法。PrintStream和PrintWriter的auto flushing机制有点不同，前者在输出byte数组、调用println方法、输出换行符或者byte值10（即\n）时自动调用flush方法，后者仅在调用println方法时发生auto flushing。

mc46790090
关注
专栏目录
Java8 I/O源码-InputStream
潘威威的博客
09-28 6012
本文简单介绍所有字节输入流的父类InputStream。InputStream是抽象类。继承这个抽象类的类必须提供返回下一个输入字节的方法。
Java8 I/O源码-ByteArrayOutputStream
潘威威的博客
10-11 2785
ByteArrayOutputStream属于字节型输出流，该输出流中的数据被写入到一个byte数组里。byte数组会随着被写入其中的数据的增长而增长。
Java I/O流详解
热门推荐
Window_mouse的博客
04-10 1万+
Java I/O流 1、Java I/O流概述 IO就是输入、输出。Java IO类库基于抽象基础类InputStream和OutputStream构建了一套I/O体系，主要解决从数据源读入数据和将数据写入到目的端的问题。我们可以将数据源和目的地理解为IO流的两端。 从一种数据源中通过InputStream流对象读入数据到程序内存中流程如图 1-1所示； 从程序内存中通过OutputStream流对象写入到目的地的流程图如图 1-2所示。 图 1-1 图 1-2 然后，除了面向字节流的InputSt
java I/O流
Code-lover's Learning Notes
04-09 2464
Java I/O流简介: 为使程序设计简单明了,Java把程序的输入\输出抽象为流(Stream),而其中输入或输出的数据称为数据流.简单地说:流就是指在计算机与输入\输出之间流动的数据序列.序列中的数据可以是二进制数据,也可以是其他符合某种格式规定的特定数据,如字符流等。 按照数据的流动方向：   输入流   输出流 按照处理数据的类型:   字节流   字符流 按照流是否直接
java -- 解决InputStream不可重复读的问题
opLW的博客
07-22 1986
产生SkImageDecoder::Factory returned null的原因及解决办法
什么是 Java 输入输出流？流的用法大全
你若盛开，蜜蜂自来
01-31 9251
博主声明： 转载请在开头附加本文链接及作者信息，并标记为转载。本文由博主威威喵原创，请多支持与指教。 本文首发于此 博主：威威喵|博客主页：https://blog.csdn.net/smile_running I/O 流 关于数据的存储，分为内部存储和外部存储。内部存储就像内存一样，是一种临时性的对数据进行储存的方式，这种方式存储的数据量不大，但是获...
Java——文件和流操作
m0_74137602的博客
02-06 1500
Java期末知识复习！！！Java知识总复习！！！Java知识介绍！！！Java——文件和流操作！！！
Java8 I/O源码-OutputStream
潘威威的博客
09-29 2064
OutputStream这个抽象类是所有表示字节输出流的类的父类。输出流接受输出字节并将这些字节发送到某个“池”。继承这个抽象类的类必须提供至少一种可写入一个输出字节的方法。
Java 标准I/O重定向
薛瑄的博客
06-16 1317
转载：http://blog.csdn.net/zhy_cheng/article/details/7891142Java的标准输入/输出分别通过System.in和System.out来代表，在默认的情况下分别代表键盘和显示器 当程序通过System.in来获得输入时，实际上是通过键盘获得输入。 当程序通过System.out执行输出时，程序总是输出到屏幕。 在System类中提供了三个重定向标准
Java之I/O输入输出流解析
空名先生
07-26 6696
推荐资源站：https://zhimalier.com/ 一、流的概述 流是一组有序的数据序列，根据操作的类型，可以分为输入流和输出流。I/O流提供了一条通道程序，可以使用这条通道把源中的字节序列送到目的地。二、输入模式 输出模式图 三、java流的分类 按流向分: 输入流: 程序可以从中读取数据的流。 输出流: 程序能向其中写入数据的流。 按数据传输单位分: 字...
深入分析 Java I/O 的工作机制(转载)
04-03
Java I/O（输入/输出）系统是Java编程语言中用于处理数据流的重要组成部分，它允许程序与外部资源如文件、网络、硬件设备等进行交互。深入理解Java I/O的工作机制对于开发高效、可靠的系统至关重要。以下是对Java I/...
JavaI/O流
m0_64113557的博客
05-11 544
为什么需要I/0流 当我们的程序需要从硬盘，网络，或其他应用程序中读取或写入数据时候，数据传输量可能很大，而我们的内存或带宽有限，无法一次性读取获取写入大量数据。 而流（Stream）可以实现一点一点的逐步传输数据。 想想我们是怎样下载一个大文件的, 下载软件(例如x雷)并不会占用你内存很大的空间, 而只是在内存划分一个缓冲区, 一点一点地下载到自己的内存(缓冲区满了再写到硬盘),。 Stream Stream是一个java类，这个类用于java程序和外部设备之前的输入输出操作。 所谓外部设备可以
通过源码认识设计模式-装饰器模式（JAVA I/O流）
java_dazhuzhu的博客
08-12 203
1.java/IO流 什么是流 简单理解，数据在两个设备之间进行的是流传输（流的本质就是数据传输）； 分类 根据数据类型不同分为字符流（以字符为单位），字节流（以字节为单位）其中字节流可以处理所有类型的数据 根据数据的流向分为输入流和输出流 java/io的知识架构图 InputStream 是所有输入字节流的父类，他是一个抽象类 其下面的子类： ByteArrayInputStream、StringBufferInputStream、FileInputStream 这三个是基础的输入流，他们
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1223
项目功能：商品分类,商品信息,用户。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1006
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 489
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1226
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java复习24（PTA)
2301_79272475的博客
10-30 292
Java复习24（PTA)：多种排序的book类*
JavaScript的第十一天
最新发布
全栈学习ing
10-31 547
在使用offset系列时需注意该属性为css属性，一般用于和javascript结合使用来获取信息，所以在使用该属性时只能获取值而不能改变值。最近的具有定位属性的祖先元素顶部边缘左侧边缘。
Java I/O流详解：文件内容读取实例与技巧
Java使用I/O流进行文件内容读取是编程中常见的操作，本文将详细介绍如何通过Java的InputStream及其子类如FileInputStream和BufferedInputStream来实现这一功能。首先，了解I/O流的基本概念至关重要，它将数据作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值