黑马程序员——java基础——IO流跟缓冲的理解_二进制和io流缓冲作用-优快云博客

本文链接：https://blog.youkuaiyun.com/xiaozhijiang/article/details/42492109

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

Java IO流详细介绍
1、分类：
1.1、按流向分类：
1.2、按数据传输单位分类：
1.3、按功能分类：
2、字节流
2.1、输入流：
2.1.1、字节输入流抽象类及其关键的方法：
2.1.2、输入流的操作：
2.1.3、抽象类InputStream的类层次：
2.1.4、字节数组输入流ByteArrayInputStream
相关例子：
2.2、输出流：
2.2.1、字节输出流的抽象类及其最关键的方法：
2.2.2、输出流的操作：
2.2.3、抽象类OutputStream的类层次结构：
3、过滤流：
3.1、缓冲输出流BufferedOutputStream
3.2、过滤流的使用例子：
4、IO流的链接：
Input Stream Chain
Output Stream Chain

Java IO流详细介绍
Java中流的实现是在java.io包中定义类的层次结构的。
1、分类：
1.1、按流向分类：
输入流: 程序可以从中读取数据的流。
输出流: 程序能向其中写入数据的流。
1.2、按数据传输单位分类：
字节流：以字节（8位二进制）为单位进行处理。主要用于读写诸如图像或声音的二进制数据。
字符流：以字符（16位二进制）为单位进行处理。
都是通过字节流的方式实现的。字符流是对字节流进行了封装，方便操作。在最底层，所有的输入输出都是字节形式的。
1.3、按功能分类：
节点流：从特定的地方读写的流类，如磁盘或者一块内存区域。
过滤流：使用节点流作为输入或输出。过滤流是使用一个已经存在的输入流或者输出流连接创建的。
2、字节流
2.1、输入流：
2.1.1、字节输入流抽象类及其关键的方法：
java.io
类 InputStream
java.lang.Object
java.io.InputStream
abstract int read()
从输入流中读取数据的下一个字节。
int read(byte[] b)
从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int read(byte[] b, int off, int len)
将输入流中最多 len 个数据字节读入 byte 数组。
2.1.2、输入流的操作：
打开一个输入流
循环读取
关闭输入流
这里使用InputStream的子类FileInputStream读入文件：

<span style="font-size:18px;">import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

public class BufferDemo {
	public static void main(String[] args) throws Exception {
		FileWriter fw=new FileWriter("D://buff.txt",true);
		BufferedWriter bw=new BufferedWriter(fw);
		BufferedReader br1=new BufferedReader(new InputStreamReader(System.in));
		System.out.println("从键盘上输入你要保存的数据：");
		String buf=null;
		while((buf=br1.readLine())!=null)
		{
			if(buf.equals("886"))
				break;
			if(buf.equals("\n\r"))
				bw.write("\n\r");
		bw.write(buf);
		bw.flush();}
	}
}
</span>

代码演示：字节数组输入流

<span style="font-size:18px;">public static void main(String[] args) {

    //创建读取数据源
    String input = "arthinking";
    //获取字节数组
    byte[] b = input.getBytes();
    //创建字节数组输出流
    ByteArrayInputStream bis = new ByteArrayInputStream(b);
    //循环逐个读取
    for(int i = 0; i < input.length(); i++){
        int c;
        //读取下一个字节
        while((c = bis.read()) != -1){
            System.out.print((char)c);
        }
    }
    //将缓冲区的位置重置为标记位置
    bis.reset();
}</span>

代码演示：字节数组输出流

<span style="font-size:18px;">public static void main(String[] args) throws IOException {

    //创建字节输出流
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    String output = "arthinking";
    //创建需要输出的字节数组
    byte[] buffer = output.getBytes();
    //把字节数组写到输出流
    bos.write(buffer);
    //创建文件输出流
    OutputStream os = new FileOutputStream("D:/itzhai/arthinking.txt");
    //把字节输出流写到文件输出流
    bos.writeTo(os);

}</span>

 
 2.2、输出流： 

 
 2.2.1、字节输出流的抽象类及其最关键的方法： 

 
 java.io
 类 OutputStream
 java.lang.Object
 java.io.OutputStream 

void write(byte[] b)
将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract void write(int b)
将指定的字节写入此输出流

由此可以看出，只有最后一个方法才是抽象的，原因是前面两个都调用了第三个抽象方法，这样继承这个抽象类的子类都必须提供抽象的write(int b)的实现，从而使得每个子类的实现都不一样。

 
 2.2.2、输出流的操作： 

 
 打开输出流
 循环写入
 关闭输入流 

这里使用了OutputStream的子类FileOutputStream输出到文件：

<span style="font-size:18px;">public static void main(String[] args) throws IOException {
    //创建一个输出流
    OutputStream os = new FileOutputStream("D:/itzhai/arthinking.txt", true);
    String output = "http://www.itzhai.com";
    //从字符串中获取字节数组
    byte[] buffer = output.getBytes();
    //写出到输出流
    os.write(buffer);
    //关闭输出流
    os.close();
}</span>

装饰类跟继承的区别

什么是装饰设计模式:

当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。

如一个简单的demo 人吃饭，刚开始人穷只是普通的吃饭后来人生活好了吃饭就不一样了增强了吃饭的功能虽然例子不是恰当能说明问题就行

看代码：

<span style="font-size:18px;">//穷的时候吃饭简简单单的吃饭  
class Person  
{  
    public void chiFan(){  
      
        System.out.println("吃饭");  
    }  
}  
  
//富裕后吃饭 吃饭前来杯酒吃饭后来根烟 但是这中间的过程还是有吃饭  
class SuperPerson  
{  
    private Person p;  
    public SuperPerson(Person p){  
      
        this.p=p;  
    }  
  
    public void superChiFan(){  
        //吃饭前来杯开胃酒增加食量  
        System.out.println("开胃酒");  
        p.chiFan();  
        //吃完饭后来根烟  
        System.out.println("来根烟");  
    }  
  
}  
public class PersonDemo  
{   public static void main(String args[]){  
    Person p=new Person();  
  
    SuperPerson sp= new SuperPerson(p);  
  
    sp.superChiFan();  
    }  
}  </span>

以上只是简单说明一下，在JAVA IO中用了很多增强如：FileRead中read()方法只是一个一个字节去读，为了读得更快在BufferedReader就增强了read()方法而产生了reandLine()一行一行的去读

有人说没必要那么麻烦：你只要拿superPerson继承person 在覆写person的chiFan()方法不就行了？

装饰是构造函数参数传递进行增强

如果为了某个功能而产生子类（继承）那么那个体系是非常臃肿的

例如：你有个对象有个功能是在N年前建立的，如今你觉得功能不够用了写个类把对象传进来就可以解决问题了如果这个功能写错了我就把自己写的功能去掉又不影响以前的功能灵活性相当强的。

装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。