IO-2-字节流

字节流

​ 在计算机中，所有文件都能以二进制的形式存在，这个二进制形式就是字节数据

​ java 的io中针对字节传输操作提供了一系列的流，为字节流。

两个抽象基类

InputStream、OutpuStream。

分别处理字节流的输入和输出

所有的字节都继承自这俩。

void close() 关闭此流并释放相关联所有系统资源
//操作IO流的时候回占用宝贵的系统资源，当操作完成后就应该讲IO所占用的系统资源释放

输入、输出，相对于谁？

当然，输出和输出这个概念出现了，就必须要有一个参照物，这里的参照物是——程序。

InputStream类的方法

boolean markSupported() 	此输入流是否支持mark和reset
void mark(int readlimit)	在此输入流中标记当前位置
void reset()				将此流重新定位到上次调用mark时的位置

int available 		返回此输入流下一个方法调用，可以不受阻赛地从此输入流读取（或跳过）的估计字节数
long skip(long n)	跳过和丢弃此输入流中数据的n个字节

最常用就是三个重载的read（）和close（）。

int read() 			 从输入流中逐个读取数据每个字节
int read(byte[] b)	 从输入流中读取一定数量的字节，存储在缓冲区数组b中，并返回读取的字节数
int read(byte[] b,int off,int len)将输入流中最多len个数据字节读入b数组
//后面这两个带数组的都是，一次性全部读入，提高读取效率。

OutputStream类的方法

void wirte(byte[] b) 将b数组中的字节全部写入此输出流
void wirte(int b)	将指定的字节写入此输出流
void wirte(byte[] b)	将指定的b数组中的从偏移量off开始的len个字节写入此输出流

void close() 	关闭此输出流，并释放相关所有系统资源
void flush()	刷新此输出流，强制写出所有缓冲区的输出字节

字节流读取文件

FileInputStream

FileOutputStream

如何从文件中读取数据？

首先新建一个文本文件read.txt 内容如下

Look at me now!

package test1;
import java.io.*;

public class Class1{
public static void main(String[] args){

//定义一个文件输出流
	FileInputStream fis = null;
	try{
		//创建文件输入流对象
		fis = new FileInputStream("F:/eclipse/test1/src/test1/read.txt");
		//设定读取的字节数，设定缓冲数组buffer
		int n = 512; 
		byte buffer[] = new byte[n];
		
		//读取输入流，一直读到 n = -1，就读完了 一定要有while才有效
		while((fis.read(buffer,0,n) != -1)&&(n > 0)){
			System.out.print(new String(buffer));
		}
	}catch(Exception e){
		System.out.println(e);
	}finally{
		try{
			fis.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
	
}}

I'm so handsome.

若中途出现错误，程序会直接中断，所以一定将close（）方法写到finally中。

因为finally中不能直接访问try中的内容，所以要将FileInputStream定义在try的外面。

遇到问题：找不到文件

java.io.FileNotFoundException: read.txt (系统找不到指定的文件。)

原因是：没有加上路径，即使和当前类创建在同一个目录下，eclipse也不会去寻找

在要打开的文件前加上路径即可。

以下两种皆可：

1、Unix中，/ 表示目录； \ 表示转义字符。

"F:/eclipse/test1/src/read.txt"

2、Windows中，正斜杠 / 表示除法；反斜杠 \ 用来表示目录。

fis = new FileInputStream("F:\\\\eclipse\\\\test1\\\\src\\\\read.txt");

字节流写入文件

package test1;
import java.io.*;

public class Class1{
public static void main(String[] args) throws IOException{

	System.out.print("输入要保存的内容：");
	int count,n = 512;
	byte buffer[] = new byte[n];
	
//读取标准输入流
	count = System.in.read(buffer);
	
//创建文件输出流对象
	FileOutputStream fos = new FileOutputStream("F:/eclipse/test1/src/test1/read.txt");
//write() 写入字节流
	fos.write(buffer,0,count);
	System.out.println("已成功保存到read.txt。");
	fos.close();//释放资源
	
}}

结果

输入要保存的内容：I'm so handsome.
已成功保存到read.txt。

弊端

虽然当文件不存在的时候，就会自己创建文件，再输出内容到文件中。

这里，read.txt已经存在，从结果看来，程序是将之前的全部覆盖掉了。

遇到报错

Unhandled exception type IOException

原因：未抛出异常。

解决：处理 main（）函数，抛出异常即可

public static void main(String[] args) throws IOException{

添加文件内容

如果想要不清除文件内容，就需要

FileOutputStream(String FileName,boolean append)来创关键文件输出流的对象。

并且把指定的参数appedn设定为true。

package test1;
import java.io.*;

public class Class1{
public static void main(String[] args) throws IOException{

	System.out.print("输入要添加的内容：");
	int count,n = 512;
	byte buffer[] = new byte[n];
	
//读取标准输入流
	count = System.in.read(buffer);
//创建文件输出流对象，在构造时比覆写的多一个参数true即可
	FileOutputStream fos = new FileOutputStream("F:/eclipse/test1/src/test1/read.txt",true);
//写入
	fos.write(buffer,0,count);
	System.out.println("已成功保存到read.txt。");
	fos.close();//释放资源
	
}}

I'm so handsome.
I'm so handsome,too.

文件的复制

先创建一个文件copy.txt

package test1;
import java.io.*;


public class Class1{
public static void main(String[] args) throws IOException{

//创建输入流数据
	FileInputStream fis = new FileInputStream("F:/eclipse/test1/src/test1/copy.txt");
//创建输出流数据
	FileOutputStream fos = new FileOutputStream("F:/eclipse/test1/copy.txt");
	int len; //定义len，记录每次读取的字节数

//记录复制文件前的系统时间
	long begin = System.currentTimeMillis();
//读取文件并判断是否到达文件末尾
	while((len = fis.read()) != -1){
		fos.write(len);//将读到的字节写入文件
	}
//复制文件后的系统时间
	long end = System.currentTimeMillis();
	System.out.println("复制文件耗时：" + (end - begin) + "毫秒");
	fos.close();
	fis.close();

}}

复制文件耗时：2毫秒

字节流的缓冲区

上节虽然是复制文件，但是复制方式是一个个字节地复制，效率很低。

这里使用缓冲区，就是说，把一堆字节全部堆到一起，要用的时候，一次性全部带走。

一次性直接输出到文件，大大提高效率。

package test1;
import java.io.*;


public class Class1{
public static void main(String[] args) throws IOException{

//创建输入流数据
	FileInputStream fis = new FileInputStream("F:/eclipse/test1/src/test1/copy.txt");
//创建输出流数据
	FileOutputStream fos = new FileOutputStream("F:/eclipse/test1/copy.txt");
//定义缓冲区数组b的大小。	定义i，记录每次读取的字节数
	byte[]b = new byte[512];
	int i; 

//记录复制文件前的系统时间
	long begin = System.currentTimeMillis();
//读取文件并判断是否到达文件末尾
	while((i = fis.read()) != -1){
		fos.write(len);//将读到的字节写入文件
	}
//复制文件后的系统时间
	long end = System.currentTimeMillis();
	System.out.println("复制文件耗时：" + (end - begin) + "毫秒");
	fos.close();
	fis.close();

}}

复制文件耗时：1毫秒

应用缓冲区后，操作文件的次数减少了，从而提高了读写效率。

装饰设计模式

就是在不改变原来的类和使用的继承的情况下，动态扩展一个对象的功能。

创建一个包装对象，来装饰包裹真实的对象。

就像买了一套房，再安装一台空调，这样夏天才不会太热，过几年空调太老化了，想换就换掉。

要求

首先，装饰对象和被装饰的都要实现同一个接口。装饰对象要拥有被装饰对象的实例。

如图，Scource\Decorator都实现了Sourceable接口。

package test1;
import java.io.*;


public class Class1{
public static void main(String[] args) throws IOException{

//实例化source
	Sourceable source = new Source();
	System.out.println("----------装饰前----------");
	source.method();
	System.out.println("----------装饰后----------");
//创建装饰类对象，并且将被装饰类当成参数传入
	Sourceable obj =new Decorator(source);
	obj.method();
	}

}

//定义公共接口
interface Sourceable{
	public void method();
}

//定义被装饰类，只给一个method，房子
class Source implements Sourceable{
	public void method(){
		System.out.println("只是一栋房子");
	}
}

//定义装饰类，
class Decorator implements Sourceable{
//定义一个
	private Sourceable source;
//构造方法	
	public Decorator(Sourceable source){
	super();
	this.source = source;
	}
	public void method(){
		source.method();
		System.out.println("有空调啦");
		System.out.println("有电视！");
}}

----------装饰前----------
只是一栋房子
----------装饰后----------
只是一栋房子
有空调啦
有电视！

这样呢，还能动态撤销。

而继承的话，就不可以，是静态的，不能动态地增删。

字节缓冲流

IO中的一些流也用到了装饰设计模式

分别是BufferedInputStream、BufferedOutputStream

在其构造方法中，分别接收InputStream，OutputStream类型的参数作为被装饰对象，在执行的时候提供缓冲。

如图，程序和文件这两个节点互传的数据是节点流，并且是由缓冲流包裹的。

缓冲流就是对已经存在的节点流的连接和封装。

package test1;
import java.io.*;


public class Class1{
public static void main(String[] args) throws IOException{

//创建文件输入流对象
	FileInputStream fis = new FileInputStream("F:/eclipse/test1/src/test1/copy.txt");
//创建文件输出流对象
	FileOutputStream fos = new FileOutputStream("F:/eclipse/test1/copy.txt");
	
//将创建的节点流的对象，作为形参传递给缓冲流的构造方法
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
	int len; //定义len，记录每次读取的字节数

//记录复制文件前的系统时间
	long begin = System.currentTimeMillis();
//读取文件并判断是否到达文件末尾
	while((len = fis.read()) != -1){
		fos.write(len);//将读到的字节写入文件
	}
//复制文件后的系统时间
	long end = System.currentTimeMillis();
	System.out.println("复制文件耗时：" + (end - begin) + "毫秒");
	fos.close();
	fis.close();

}}

复制文件耗时：1毫秒

和之前的字节流缓冲区类似，都是对数据进行缓冲，减少操作次数。

下一节：字符流