很多人刚学习程序流一章的时候,就是搞不清楚In和Out,不知道什么时候用in什么时候用out,所以一部分人采取死记硬背的方式,诸如如下这位:
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("infilename")));
不管你从磁盘读,从网络读,或者从键盘读,读到内存,就是InputStream。
写文件
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("outfilename")));
不管你写倒磁盘,写到网络,或者写到屏幕,都是OuputStream。
那么有什么好方法不用背就能记住呢,即使是反应稍微慢点,但是绝对不会错的方法呢?
好吧,那我就来说说,老程序员可以关闭该页面了!
我们所说的流,都是针对内存说的,比如为什么打印到屏幕上就是System.out.println();而从屏幕等待用户输入的却是System.in呢?因为对于内存来说,把字符串打印到屏幕上是从内存流向屏幕这个显示器的,也就是输出,而从屏幕等待用户输入呢?就是等待键盘将字符输入到内存中。
所以,你根本就不用死记硬背,当你遇到IO的时候,就想两件事,第一,我的内存是中心,第二看看流的方向(矢量)!
好吧,那么往硬盘上写文件是out还是in呢?别一看到“写”文件你就说in,那是望文生义,你看,写文件的流向,是 内存---------->硬盘 内存为中心,到硬盘,OK 用out 那么就是FileOutputStream、BufferedOutputStream 等等
那读文件呢?是 内存<---------------硬盘 那么就是in了 , 看清楚数据的流向就OK!
那我访问网络,看网页是什么呢 网络--------------->内存 是in 因为我们访问页面是要抓取该页面得一个html文件,那我要是在网络上输入帐号密码登陆呢? 是不是内存的东西要写到该服务器上呢,所以当然是out了!
同样socket编程用到更多的IO,这里分别用Server(服务器端)和Client(客户端)来说明
Server: 遇到请求,网络----->内存 IN 服务器应答, 内存------->网络 OUT
----------------------------------------------------------------------------------------------
Client: 请求服务, 内存----->网络 OUT 服务器应答, 网络------->内存 IN
被搞糊涂了?那么你先别想太多,只是想是内存的数据出去了就是out 外设的东西到内存了就IN了
以前计算机考试经常考的弱智问题不知道现在还考不考,那就是计算机由几部分组成,分别是什么?这道题通常会出现在试卷的第一题
我想,现在依然有人不会,答(弱智问题):计算机由5部分组成 1 控制器 2 计算器 3 存储器 4 输入 5 输出
这个问题是世界上所有的计算机的组成要素,包括“银河”、“曙光”等大家都没见过的国家用的那种庞大的计算机。那我们用的计算机和“银河”不一样吗?从这道题上回答是一样的。要说不一样,只能说硬件结构和指令系统不一样罢了
我们现在用的计算机,外行都叫电脑,我从来不说电脑,因为不专业,它还够不上大脑的要素,他不会思维,他是按照人们安排的指令无条件执行的。
那么我们的计算机(PC personal computer)是如何构造的呢?
1控制器 2计算器 :我们都叫他CPU(Center Process Unit 中央处理单元或叫中央处理器),他遵循IBM X86架构,我们用的计算机的处理器(计算机心脏)被硬件商将控制器和计算器集成到一起了,所以有时叫做微处理器,CPU既负责控制计算机又负责计算
3存储器:有两种分类方法,1)存储器分为内存和外存,2)存储器分为RAM(随机存储器)和ROM(只读存储器)。 内存,大家都知道,一切数据都必须经过内存,比如,运行的程序,从硬盘读取的电影,内存又叫做随机存储器(RAM),也就是说数据可以随机的进入内存的某个地址(由操作系统管理),但是只要掉电它里边的数据就没了。
硬盘,也是随机存储器,你所看到硬盘里一个一个罗列的文件像是整齐的在排列,其实那时逻辑上的,学过数据结构的人应该知道,硬盘分为控制区和数据区,数据区是放用户数据的,而控制区其实就是放的指针地址,他所索引它的前置数据和后置数据,我们买硬盘的时候硬件商人告诉我们这是80G的硬盘,实际上我们看到只有72G左右,就是这个道理,不是“奸商”所为,而是计算不同,硬盘出厂时,厂家计算容量是以硬盘的总容量来计算的,也就是说硬盘的容量=数据区+控制区,而我们在操作系统里,或者说引导盘格式化完后看到的是数据区总容量,丢失的那些容量其实是控制区的,它对于用户不可见,只有操作系统才能用它
ROM、RAM:ROM从名字看出就是存进去不能在写的存储器,比如CD-ROM DVD-ROM 当然现代的存储器高级了,还有CD-R CD-RW DVD-R DVD-RW 他不就不是只读的了吗?我要说明的是,它还是ROM,为什么,不是可写了吗?但是他是相对只读,你给我像硬盘一样往里写点东西我看看,只是技术的进步,材料的进步,我们可以用驱动器 将激光的能量在ROM里改变一些材料的物理特性,实现可写,但一旦刻录完成,它就不再可写了,有人会反驳,那RW呢,你不记得当你要改变光盘里的东西的时候要擦除光盘的数据吗?RW是有使用次数的,当你刻录若干次之后,他将永远不能刻录了,ROM不可能像硬盘一样你想什么时候写就什么时候写。当然有人混淆了ROM和光驱的概念,ROM就是我们的光盘,比如DVD-ROM CD-ROM,而光驱呢,就是驱动该ROM的设备,就想硬盘里有盘片,外边的壳子是驱动那个磁盘片转动的,现在可能大多数人没见过软盘驱动器了,只有个别的低端服务器上偶尔能见到,磁盘驱动器和硬盘是一个道理的,用磁头夹着盘面进行读写,有3寸盘、5寸盘,当然还有我没见过的Zip盘。
4输入:输入有什么?键盘、摄像头、游戏机手柄(计算机用)、鼠标、触摸板、轨迹球、DVD-ROM等等了,为什么叫输入?因为它上面的数据最终都要进入内存阿!
5输出:输出比如显示器、打印机。有人会说,我的显示器是手写的,算输入不?我告诉你的是,其实手写是手写、显示器是显示器,手写是输入,它通过电流感应等技术做成的,屏幕上有微弱的电流流过,当你的手指阻挡了电流,那么,改点就被识别,当然这里有其他的实现技术,有兴趣的可以查。
————————————————————————————————————————————————————————————————————
ByteArrayOutputStream类是在创建它的实例时,程序内部创建一个byte型别数组的缓冲区,然后利用ByteArrayOutputStream和ByteArrayInputStream的实例向数组中写入或读出byte型数据。在网络传输中我们往往要传输很多变量,我们可以利用ByteArrayOutputStream把所有的变量收集到一起,然后一次性把数据发送出去。
——————————————————————————————————————————————
===========================================================
加点自己的理解,以实际的工作场景出发,
1. 需要读取一个文件(并写到内存中)以新建一个对象,则用in
X509Certificate cert = (X509Certificate) CertificateFactory.getInstance("X.509")
.generateCertificate(new ByteArrayInputStream(Base64.decode(CERTIFICATE)));
2. 需要输出(产生)一个文件,或者打印某对象到控制台以便debugging,就用out:
OutputStream out = new ByteArrayOutputStream();
TransformerFactory.newInstance().newTransformer().transform(returnMessage.getPayload(), new StreamResult(out));
String result = ((ByteArrayOutputStream) out).toString();
——————————————————————————————————————————————————————————————————————————————
Java将数据于目的地及来源之间的流动抽象化为一个流(Stream),而流当中流动的则是位数据。
14.2.1 InputStream和OutputStream
计算机中实际上数据的流动是通过电路,而上面流动的则是电流,电流的电位有低位与高位,即数字的0与1位。从程序的观点来说,通常会将数据目的地(例如内存)与来源(例如文件)之间的数据流动抽象化为一个流(Stream),而其中流动的则是位数据,如图14-1所示。
图14-1 数据的流动抽象化为流的概念
在Java SE中有两个类用来作流的抽象表示:java.io.InputStream与java.io.OutputStream。
InputStream 是所有表示位输入流的类之父类,它是一个抽象类,继承它的子类要重新定义其中所定义的抽象方法。InputStream是从装置来源地读取数据的抽象表示,例如System中的标准输入流in对象就是一个InputStream类型的实例。在Java程序开始之后,in流对象就会开启,目的是从标准输入装置中读取数据,这个装置通常是键盘或是用户定义的输入装置。
OutputStream 是所有表示位输出流的类之父类,它是一个抽象类。子类要重新定义其中所定义的抽象方法,OutputStream是用于将数据写入目的地的抽象表示。例如 System中的标准输出流对象out其类型是java.io.PrintStream,这个类是OutputStream的子类 (java.io.FilterOutputStream继承OutputStream, PrintStream再继承FilterOutputStream)。在程序开始之后,out流对象就会开启,可以通过out来将数据写至目的地装置,这个装置通常是屏幕显示或用户定义的输出装置。
范例14.4可以读取键盘输入流,in对象的read()方法一次读取一个字节的数据,读入的数据以int类型返回。所以在使用out对象将数据显示出来时,就是10进制方式。
ü 范例14.4 StreamDemo.java
package onlyfun.caterpillar;
import java.io.*;
public class StreamDemo {
public static void main(String[] args) {
try {
System.out.print("输入字符: ");
System.out.println("输入字符十进制表示: " +
System.in.read());
}
catch(IOException e) {
e.printStackTrace();
}
}
}
执行结果:
输入字符: A
输入字符十进制表示: 65
字符A输入后由标准输入流in读取,A的位表示以十进制来看就是65,这是A字符的编码(查查ASCII编码表就知道了)。
一般来说,很少直接实现InputStream或OutputStream上的方法,因为这些方法比较低级,通常会实现它们的子类。这些子类上所定义的方法在进行输入/输出时更为方便。
14.2.2 FileInputStream和FileOutputStream
java.io.FileInputStream 是InputStream的子类。从开头File名称上就可以知道,FileInputStream与从指定的文件中读取数据至目的地有关。而 java.io.FileOutputStream是OutputStream的子类,顾名思义,FileOutputStream主要与从来源地写入数据至指定的文件中有关。
当建立一个FileInputStream或FileOutputStream的实例时,必须指定文件位置及文件名称,实例被建立时文件的流就会开启;而不使用流时,必须关闭文件流,以释放与流相依的系统资源,完成文件读/写的动作。
FileInputStream可以使用 read()方法一次读入一个字节,并以int类型返回,或者是使用read()方法时读入至一个byte数组,byte数组的元素有多少个,就读入多少个字节。在将整个文件读取完成或写入完毕的过程中,这么一个byte数组通常被当作缓冲区,因为这么一个byte数组通常扮演承接数据的中间角色。
范例14.5是使用FileInputStream与FileOutputStream的一个例子。程序可以复制文件,它会先从来源文件读取数据至一个byte数组中,然后再将byte数组的数据写入目的文件。
ü 范例14.5 FileStreamDemo.java
package onlyfun.caterpillar;
import java.io.*;
public class FileStreamDemo {
public static void main(String[] args) {
try {
byte[] buffer = new byte[1024];
// 来源文件
FileInputStream fileInputStream =
new FileInputStream(new File(args[0]));
// 目的文件
FileOutputStream fileOutputStream =
new FileOutputStream(new File(args[1]));
// available()可取得未读取的数据长度
System.out.println("复制文件:" +
fileInputStream.available() + "字节");
while(true) {
if(fileInputStream.available() < 1024) {
// 剩余的数据比1024字节少
// 一位一位读出再写入目的文件
int remain = -1;
while((remain = fileInputStream.read())
!= -1) {
fileOutputStream.write(remain);
}
break;
}
else {
// 从来源文件读取数据至缓冲区
fileInputStream.read(buffer);
// 将数组数据写入目的文件
fileOutputStream.write(buffer);
}
}
// 关闭流
fileInputStream.close();
fileOutputStream.close();
System.out.println("复制完成");
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println(
"using: java FileStreamDemo src des");
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
}
}
程序中示范了两个read()方法,一个方法可以读入指定长度的数据至数组,另一个方法一次可以读入一个字节。每次读取之后,读取的光标都会往前进,如果读不到数据则返回–1,使用available()方法获得还有多少字节可以读取。除了使用File来建立FileInputStream、 FileOutputStream的实例之外,也可以直接使用字符串指定路径来建立。
// 来源文件FileInputStream fileInputStream = new FileInputStream(args[0]);// 目的文件FileOutputStream fileOutputStream = new FileOutputStream(args[1]);在不使用文件流时,记得使用close()方法自行关闭流,以释放与流相依的系统资源。一个执行的结果范例如下,它将FileDemo.java复制为FileDemo.txt:
java onlyfun.caterpillar.FileStreamDemo FileDemo.java FileDemo.txt
复制文件:1723字节
复制完成
FileOutputStream默认会以新建文件的方式来开启流。如果指定的文件名称已经存在,则原文件会被覆盖;如果想以附加的模式来写入文件,则可以在构建FileOutputStream实例时指定为附加模式。例如:
FileOutputStream fileOutputStream = new FileOutputStream(args[1], true);构建方法的第二个append参数如果设置为true,在开启流时如果文件不存在则会新建一个文件,如果文件存在就直接开启流,并将写入的数据附加至文件末端。
虽然我一向不喜欢使用过长的范例来作程序示范(也不喜欢看很长的范例),不过本章的范例与其他各章的比起来相对长了一些,我会在程序中多用注释解释程序的逻辑。因为解释输入/输出操作最好的方式,是呈现一个具实用性的范例,本章的范例除了练习的作用之外,日后需要某些输入/输出功能时,也可以来参考看看如何实现。
14.2.3 BufferedInputStream和BufferedOutputStream
在介绍FileInputStream和 FileOutputStream的例子中,使用了一个byte数组来作为数据读入的缓冲区,以文件存取为例,硬盘存取的速度远低于内存中的数据存取速度。为了减少对硬盘的存取,通常从文件中一次读入一定长度的数据,而写入时也是一次写入一定长度的数据,这可以增加文件存取的效率。
java.io.BufferedInputStream 与java.io.BufferedOutputStream可以为InputStream、OutputStream类的对象增加缓冲区功能。构建 BufferedInputStream实例时,需要给定一个InputStream类型的实例,实现BufferedInputStream时,实际上最后是实现InputStream实例。同样地,在构建BufferedOutputStream时,也需要给定一个OutputStream实例,实现 BufferedOutputStream时,实际上最后是实现OutputStream实例。
BufferedInputStream的数据成员buf是一个位数组,默认为2048字节。当读取数据来源时,例如文件,BufferedInputStream会尽量将buf填满。当使用read ()方法时,实际上是先读取buf中的数据,而不是直接对数据来源作读取。当buf中的数据不足时,BufferedInputStream才会再实现给定的InputStream对象的read()方法,从指定的装置中提取数据,如图14-2所示。
图14-2 BufferedInputStream在内部有buf成员作为缓冲区
BufferedOutputStream的数据成员buf是一个位数组,默认为512字节。当使用write()方法写入数据时,实际上会先将数据写至buf中,当buf已满时才会实现给定的 OutputStream对象的write()方法,将buf数据写至目的地,而不是每次都对目的地作写入的动作。
下面将范例14.5做个改写,这次不用自行设置缓冲区,而使用BufferedInputStream和BufferedOutputStream让程序看来简单一些,也比较有效率。
ü 范例14.6 BufferedStreamDemo.java
package onlyfun.caterpillar;
import java.io.*;
public class BufferedStreamDemo {
public static void main(String[] args) {
try {
byte[] data = new byte[1];
File srcFile = new File(args[0]);
File desFile = new File(args[1]);
BufferedInputStream bufferedInputStream =
new BufferedInputStream(
new FileInputStream(srcFile));
BufferedOutputStream bufferedOutputStream =
new BufferedOutputStream(
new FileOutputStream(desFile));
System.out.println("复制文件:" +
srcFile.length() + "字节");
while(bufferedInputStream.read(data) != -1) {
bufferedOutputStream.write(data);
}
// 将缓冲区中的数据全部写出
bufferedOutputStream.flush();
// 关闭流
bufferedInputStream.close();
bufferedOutputStream.close();
System.out.println("复制完成");
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println(
"using: java UseFileStream src des");
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
}
}
为了确保缓冲区中的数据一定被写出至目的地,建议最后执行flush()将缓冲区中的数据全部写出目的流中。这个范例的执行结果与范例14.5是相同的。
BufferedInputStream和 BufferedOutputStream并没有改变InputStream或 OutputStream的行为,读入或写出时的动作还是InputStream和OutputStream负责。 BufferedInputStream和BufferedOutputStream只是在操作对应的方法之前,动态地为它们加上一些额外功能(像缓冲区功能),在这里是以文件存取流为例,实际上可以在其他流对象上也使用BufferedInputStream和BufferedOutputStream 功能。
*************************************************************************************
本篇主要分析:1.如何将byte数组适配至ByteArrayInputStream,对应与IO部分的适配器模式;2.BufferedInputStream的工作原理,对应于IO的装饰器模式,会首先研究InputStream和FilterInputStream的源代码,同时会将要谈谈软件设计中的缓存相关的知识。后面专门一章分析PipedInputStream和PipedOutStream,简单谈谈管道相关的知识,以及软件架构的想法。
1 InputStream
InputStream 是输入字节流部分,装饰器模式的顶层类。主要规定了输入字节流的公共方法。
package java.io;
public abstract class InputStream implements Closeable {
private static final int SKIP_BUFFER_SIZE = 2048; //用于skip方法,和skipBuffer相关
private static byte[] skipBuffer; // skipBuffer is initialized in skip(long), if needed.
public abstract int read() throws IOException; //从输入流中读取下一个字节,
//正常返回0-255,到达文件的末尾返回-1
//在流中还有数据,但是没有读到时该方法会阻塞(block)
//Java IO和New IO的区别就是阻塞流和非阻塞流
//抽象方法哦!不同的子类不同的实现哦!
//将流中的数据读入放在byte数组的第off个位置先后的len个位置中
//放回值为放入字节的个数。
public int read(byte b[], int off, int len) throws IOException { //
if (b == null) {
throw new NullPointerException();
} else if (off < 0 || len < 0 || len > b.length - off) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
} //检查输入是否正常。一般情况下,检查输入是方法设计的第一步
int c = read(); //读取下一个字节
if (c == -1) { return -1; } //到达文件的末端返回-1
b[off] = (byte)c; //放回的字节downcast
int i = 1; //已经读取了一个字节
try {
for (; i < len ; i++) { //最多读取len个字节,所以要循环len次
c = read(); //每次循环从流中读取一个字节
//由于read方法阻塞,
//所以read(byte[],int,int)也会阻塞
if (c == -1) { break; } //到达末尾,理所当然放回-1
b[off + i] = (byte)c; //读到就放入byte数组中
}
} catch (IOException ee) { }
return i;
//上面这个部分其实还有一点比较重要,int i = 1;在循环的外围,或许你经常见到,
//或许你只会在循环是才声明,为什么呢?
//声明在外面,增大了变量的生存周期(在循环外面),所以后面可以return返回
//极其一般的想法。在类成员变量生命周期中使用同样的理念。
//在软件设计中,类和类的关系中也是一样的。
} //这个方法在利用抽象方法read,某种意义上简单的Templete模式。
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
} //利用上面的方法read(byte[] b)
public long skip(long n) throws IOException {
long remaining = n; //方法内部使用的、表示要跳过的字节数目,
//使用它完成一系列字节读取的循环
int nr;
if (skipBuffer == null)
skipBuffer = new byte[SKIP_BUFFER_SIZE]; //初始化一个跳转的缓存
byte[] localSkipBuffer = skipBuffer; //本地化的跳转缓存
if (n <= 0) { return 0; } //检查输入参数,应该放在方法的开始
while (remaining > 0) { //一共要跳过n个,每次跳过部分,循环
nr = read(localSkipBuffer, 0, (int) Math.min(SKIP_BUFFER_SIZE, remaining));
//利用上面的read(byte[],int,int)方法尽量读取n个字节
if (nr < 0) { break; } //读到流的末端,则返回
remaining -= nr; //没有完全读到需要的,则继续循环
}
return n - remaining;//返回时要么全部读完,要么因为到达文件末端,读取了部分
}
public int available() throws IOException { //查询流中还有多少可以读取的字节
return 0;
}
//该方法不会block。在java中抽象类方法的实现一般有以下几种方式:
//1.抛出异常(java.util);2.“弱”实现。象上面这种。子类在必要的时候覆盖它。
//3.“空”实现。下面有例子。
public void close() throws IOException {}
//关闭当前流、同时释放与此流相关的资源
public synchronized void mark(int readlimit) {}
//在当前位置对流进行标记,必要的时候可以使用reset方法返回。
//markSupport可以查询当前流是否支持mark
public synchronized void reset() throws IOException {
throw new IOException("mark/reset not supported");
}
//对mark过的流进行复位。只有当流支持mark时才可以使用此方法。
//看看mark、available和reset方法。体会为什么?!
public boolean markSupported() { //查询是否支持mark
return false;
} //绝大部分不支持,因此提供默认实现,返回false。子类有需要可以覆盖。
}
2 FilterInputStream
这是字节输入流部分装饰器模式的核心。是我们在装饰器模式中的Decorator对象,主要完成对其它流装饰的基本功能。下面是它的源代码:
package java.io;
//该类对被装饰的流进行基本的包裹。不增加额外的功能。
//客户在需要的时候可以覆盖相应的方法。具体覆盖可以在ByteInputStream中看到!
public class FilterInputStream extends InputStream {
protected volatile InputStream in; //将要被装饰的字节输入流
protected FilterInputStream(InputStream in) { //通过构造方法传入此被装饰的流
this.in = in;
}
//装饰器的代码特征:被装饰的对象一般是装饰器的成员变量
//上面几行可以看出。
//下面这些方法,完成最小的装饰――0装饰,只是调用被装饰流的方法而已
public int read() throws IOException {
return in.read();
}
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
}
public int read(byte b[], int off, int len) throws IOException {
return in.read(b, off, len);
}
public long skip(long n) throws IOException {
return in.skip(n);
}
public int available() throws IOException {
return in.available();
}
public void close() throws IOException {
in.close();
}
public synchronized void mark(int readlimit) {
in.mark(readlimit);
}
public synchronized void reset() throws IOException {
in.reset();
}
public boolean markSupported() {
return in.markSupported();
}
//以上的方法,都是通过调用被装饰对象in完成的。没有添加任何额外功能
//装饰器模式中的Decorator对象,不增加被装饰对象的功能。
//它是装饰器模式中的核心。更多关于装饰器模式的理论请阅读博客中的文章。
}
本文转载自InputStream与OutputStream归纳_进击的小黑的博客-CSDN博客_inputstream和outputstream的作用