IO流之字节流（上）

1.1 什么是IO流

I
input 输入流
read 读取数据
O
output 输出流
write 写入数据
一般情况下都是按照当前程序使用的内存为参照物来考虑数据的走向问题。
文件操作为例：
从内存中保存数据到硬盘 output
从硬盘中读取数据到内存 input

IO流基类

InputStream 输出流基类 read
OutputStream 输出流基类 write

1.2 IO流分类

按流向分类 :输入流 输出流
按照文件操作处理单元分类：字节流和字符流

字节流

FileInputStream 文件操作输入字节流
FieOutputStream 文件操作输出字节流

字符流

FileReader 文件操作输入字符流
FileWriter 文件操作输出字符流

1.3文件操作字节流

1.3.1 文件操作输入字节流

Constructor 构造方法

FileInputStream(File file) 这里是根据提供的File类对象创建对应的文件操作输入字节流
FileInputStream(String pathName) 这里是根据提供的String类型文件路径，创建对应的文件操作输入字节流

Method 成员方法

int read() 从文件中读取一个字节数据返回到方法外
int read(byte[] bud) 读取文件的内容是存储在byte类型数组中，返回值是读取到的字节数
int read(byte[] bud, int offset, int count) 读取文件的内容是存储在byte类型数组中，要求从byte数组offset位置开始，到count长度结束，返回值是读取到的字节数

1.3.2 文件读取使用缓冲和非缓冲的差距

使用缓冲之后，从硬盘中一口气读取8kb数据存储在内存中，供程序使用

FileInputStream 代码演示：

package bkDay14.IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
 * 文件操作输入字节流
 * 		1.确认读取哪一个文件
 * 		2.创建对应文件的fileInputStream
 * 		3.读取数据
 * 		4.关闭资源 【容易忘记】
 */

public class Demo1 {
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		Test1();
		long end = System.currentTimeMillis();
		System.out.println("时间：" + (end - start));
	}
	
	public static void Test2() {
		//1.字节输入流读取文件对象
		File file2 = new File("/Users/xiao.shuo./Desktop/a.txt");
		
		//2.字节输入流读取对象
		FileInputStream fileInputStream = null;
		
		try {
			//3.根据用户File类对象创建对应的字节输入流
			fileInputStream = new FileInputStream(file2);
			
			/*
			* 这里使用了字节缓冲数组
			*/
			
			//4.准备一个8KB字节缓冲数组
			byte[] buff = new byte[1024 * 8];
			int length = -1;
			
			//5.读取数据
			while((length = fileInputStream.read(buff)) != -1) {
				System.out.println(new String(buff, 0, length));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if(fileInputStream != null) {
				try {
					fileInputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	public static void Test1() {
		//1.确定要操作的文件
		File file = new File("/Users/xiao.shuo./Desktop/a.txt");
		
		//2.字节输入流读取对象
		FileInputStream fileInputStream = null;
		
		try {
			//3.根据File类对象创建对应的字节输入流
			fileInputStream = new FileInputStream(file);

			/*
			* 这里没有使用字节缓冲数组
			*/
			
			//4.读取文件	
//			int content = fileInputStream.read();
//			System.out.println(content);
			int content = -1;
			while((content = fileInputStream.read()) != -1) {
				System.out.println((char)content);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(fileInputStream != null) {
				try{
					fileInputStream.close();
				}catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}
}

1.3.3 文件操作输出字节流

constructor 构造方法

FileOutputStream(File file) 根据File类对象创建对应的文件输出字节流对象
FileOutputStream(String pathName) 根据String类型文件路径创建对应的文件输出字节流对象
以上两种构造方法创建的FileOutStream是删除写/清空写操作，会将原文件中的内容全部删除之后，写入收据
FileOutputStream(String pathName, boolean append) 根据String类型文件路径创建对应的文件输出字节流对象，创建时给予append参数为true,表示追加写

FileOutputStream构造方法是拥有创建文件的功能，如果文件存在，不创建，文件不存在且路径正确，则创建对应文件

method 成员方法

void write(int b) 写入一个字节数据到当前文件中，参数是int类型，但是有且只会操作对应的低八位数据
void write(byte[] bud) 写入字节数组中的内容到文件中
void wrute(byte[] buf,int offset, int length) 写入字节数组中的内容到文件中，从指定的offset开始，到指定长度length

FileOutoutStream代码演示:

package bkDay14.IO;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 文件操作输出字节流
 * 		1.确定文件
 * 		2.创建FileOutputStream
 * 		3.写入数据到文件中
 * 		4.关闭资源
 */
public class Demo2 {
	public static void main(String[] args) {
		long start1 = System.currentTimeMillis();
		test1();
		long end1 = System.currentTimeMillis();
		System.out.println("时间：" + (end1 - start1));
		
		long start2 = System.currentTimeMillis();
		test2();
		long end2 = System.currentTimeMillis();
		System.out.println("时间；" + (end2 - start2));
	}
	
	public static void test2() {
		//1.确定要写入的文件
		File file2 = new File("/Users/xiao.shuo./Desktop/c.txt");
		
		//2.文件操作字节输出流对象
		FileOutputStream fileOutputStream = null;
		try {
			//3.创建FileOutputStream
			fileOutputStream = new FileOutputStream(file2);
			
			//4.准备byte类型数组
			byte[] bytes = "武汉加油！！中国加油！！".getBytes();
			
			//5.写入数据
			fileOutputStream.write(bytes);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if(fileOutputStream != null) {
				try {
					fileOutputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	public static void test1() {
		//1.确定要写入的文件
		File file = new File("/Users/xiao.shuo./Desktop/b.txt");
		
		//2.文件操作字节输出流对象
		FileOutputStream fileOutputStream = null;
		try {
			//3.创建fileOutputStream
			fileOutputStream = new FileOutputStream(file);
			
			//4.写入数据
			fileOutputStream.write('D');
			fileOutputStream.write('D');
			fileOutputStream.write('D');
			fileOutputStream.write('D');
			fileOutputStream.write('D');
			fileOutputStream.write('D');
			fileOutputStream.write('D');
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if(fileOutputStream != null) {
				try {
					fileOutputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

1.3.4 文件拷贝对比（使用缓冲数组）

代码演示：

package bkDay14.IO;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 拷贝操作
 */
public class Demo3 {
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		test1();
		long end = System.currentTimeMillis();
		System.out.println("时间：" + (end - start));
		
		long start1 = System.currentTimeMillis();
		test2();
		long end1 = System.currentTimeMillis();
		System.out.println("时间：" + (end1 - start1));
	}
	
	public static void test2() {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		
		try {
			//创建文件输入字节流
			fis = new FileInputStream("/Users/xiao.shuo./Desktop/a.txt");
			//创建文件输出字节流
			fos = new FileOutputStream("/Users/xiao.shuo./Desktop/aaa.txt");
			
			int content = -1;
			//读文件数据 
			/*
			 * 这种情况 会造成复制后得到的文件大小偏大
			 */
			while((content = fis.read()) != -1) {
				//写入数据
				fos.write(content);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if(fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	public static void test1() {
		
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			//创建文件输入字节流
			fis = new FileInputStream("/Users/xiao.shuo./Desktop/a.txt");
			//创建文件输出字节流
			fos = new FileOutputStream("/Users/xiao.shuo./Desktop/aa.txt");
			//准备一个缓冲数组 8kb
			byte[] buff = new byte[1024 * 8];
			int length = -1;
			
			//读取文件数据
			while((length = fis.read(buff)) != -1) {
				//写入数据
				fos.write(buff,0,length);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//关闭资源 遵循先开后关 后开先关原则
			if(fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}