Java 字节缓冲流及异常处理
package com.fish.buffered;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
我们清楚读取文件数据使用缓冲数组读取效率更高，sun也知道使用缓冲数组读取效率更高，那么
这时候sun给我们提供了一个------缓冲输入字节流对象,让我们可以更高效率读取文件。
输入字节流体系：
----| InputStream 输入字节流的基类。 抽象
----------| FileInputStream 读取文件数据的输入字节流
----------| BufferedInputStream 缓冲输入字节流 缓冲输入字节流的出现主要是为了提高读取文件数据的效率。
其实该类内部只不过是维护了一个8kb的字节数组而已。
注意： 凡是缓冲流都不具备读写文件的能力。
使用BufferedInputStream的步骤 :
1. 找到目标文件。
2. 建立数据 的输入通道
3. 建立缓冲 输入字节流流
4. 关闭资源
*/
public class Demo1 {
public static void main(String[] args) throws IOException {
readTest2();
}
public static void readTest2() throws IOException{
//找到目标文件
File file = new File("F:\\a.txt");
//建立数据的输入通道
FileInputStream fileInputStream= new FileInputStream(file);
//建立缓冲输入字节流
//疑问一：为什么创建BufferInputStream的时候需要传递FileInputStream？
//BufferedInputStream本身不具备读文件的能力，所以需要借助FileInputStream来读取文件数据
BufferedInputStream bufferedInputStream= new BufferedInputStream(fileInputStream);
//bufferedInputStream.read();
FileOutputStream fileOutputStream= new FileOutputStream(file);
BufferedOutputStream bufferedOutputStream= new BufferedOutputStream(fileOutputStream);
fileOutputStream.write(null);
//读取文件数据
int content = 0 ;
//疑问二：BufferedInputStream出现 的目的是了提高读取文件的效率，但是BufferedInputStream的read方法每次读取一个字节的数据
//而FileInputStreram每次也是读取一个字节的数据，那么BufferedInputStream效率高从何而来？
//FileInputStreram 是读硬盘，BufferedInputStream是读内存
while((content = bufferedInputStream.read())!=-1){
System.out.print((char)content);
}
//关闭资源
bufferedInputStream.close();//调用BufferedInputStream的close方法实际上关闭的是FileinputStream.
}
//读取文件的时候我们都是使用缓冲数组读取。效率会更加高
public static void readTest() throws IOException{
File file = new File("F:\\a.txt");
//建立数组通道
FileInputStream fileInputStream = new FileInputStream(file);
//建立缓冲数组读取数据
byte[] buf = new byte[1024*8];
int length = 0;
while((length = fileInputStream.read(buf))!=-1){
System.out.print(new String(buf,0,length));
}
//关闭资源
fileInputStream.close();
}
}
package com.fish.buffered;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
输出字节流
--------| OutputStream 所有输出字节流的基类 抽象类
------------| FileOutputStream 向文件 输出数据 的输出字节流
------------| Bufferedoutputstream 缓冲输出字节流 BufferedOutputStream出现的目的是为了提高写数据的效率。
内部也是维护了一个8kb的字节数组而已。
使用BufferedOutputStream的步骤：
1. 找到目标文件
2. 建立数据的输出通道
BufferedOutputStream 要注意的细节
1. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中。
2. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中，如果需要把数据真正的写到硬盘上面，需要
调用flush方法或者是close方法、 或者是内部维护的字节数组已经填满数据的时候。
*/
public class Demo2 {
public static void main(String[] args) throws IOException {
//找到目标文件
File file = new File("F:\\a.txt");
//建立数据的输出通道
FileOutputStream fileOutputStream = new FileOutputStream(file);
//建立缓冲输出字节流对象
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//把数据写出
bufferedOutputStream.write("hello world".getBytes());
//把缓冲数组中内部的数据写到硬盘上面。
//bufferedOutputStream.flush();
bufferedOutputStream.close();
}
}
package com.fish.buffered;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
练习： 使用缓冲输入输出字节流拷贝一个图片。
*/
public class CopyImage {
public static void main(String[] args) throws IOException {
//找到目标文件
File inFile = new File("F:\\图片\\1.jpg");
File outFile = new File("E:\\1.jpg");
//建立数据输入输出通道
FileInputStream fileInputStream = new FileInputStream(inFile);
FileOutputStream fileOutputStream = new FileOutputStream(outFile);
//建立缓冲输入输出流
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//边读边写
int content = 0;
// int length = bufferedInputStream.read(buf); 如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组中的字节个数。
while((content = bufferedInputStream.read())!=-1){ // 如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容。
bufferedOutputStream.write(content);
//bufferedOutputStream.flush(); //这里不要刷
}
//关闭资源
bufferedInputStream.close();
bufferedOutputStream.close();
}
}
package com.fish.exception;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import javax.management.RuntimeErrorException;
/*
IO异常 的处理
*/
public class Demo1 {
public static void main(String[] args) throws IOException {
readTest();
// copyImage();
}
// 拷贝图片
public static void copyImage() {
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
// 找到目标文件
File inFile = new File("F:\\美女\\1.jpg");
File outFile = new File("E:\\1.jpg");
// 建立输入输出通道
fileInputStream = new FileInputStream(inFile);
fileOutputStream = new FileOutputStream(outFile);
// 建立缓冲数组，边读边写
byte[] buf = new byte[1024];
int length = 0;
while ((length = fileInputStream.read(buf)) != -1) {
fileOutputStream.write(buf, 0, length);
}
} catch (IOException e) {
System.out.println("拷贝图片出错...");
throw new RuntimeException(e);
} finally {
// 关闭资源
try {
if (fileOutputStream != null) {
fileOutputStream.close();
System.out.println("关闭输出流对象成功...");
}
} catch (IOException e) {
System.out.println("关闭输出流资源失败...");
throw new RuntimeException(e);
} finally {
if (fileInputStream != null) {
try {
fileInputStream.close();
System.out.println("关闭输入流对象成功...");
} catch (IOException e) {
System.out.println("关闭输入流对象失败...");
throw new RuntimeException(e);
}
}
}
}
}
public static void readTest() {
FileInputStream fileInputStream = null;
try {
// 找到目标文件
File file = new File("E:\\aaaaa.txt");
// 建立数据输入通道
fileInputStream = new FileInputStream(file);
// 建立缓冲数组读取数据
byte[] buf = new byte[1024];
int length = 0;
while ((length = fileInputStream.read(buf)) != -1) {
System.out.print(new String(buf, 0, length));
}
} catch (IOException e) {
/* 正常情况来说，catch了异常之后，后面的代码是能继续执行的，但是读取文件的操作，后面的代码一般都有文件内容为基础，所以一旦遇到文件类的异常，应该终止后续代码的执行
* //处理的代码... 首先你要阻止后面的代码执行,而且要需要通知调用者这里出错了... throw new
* RuntimeException(e);
* //把IOException传递给RuntimeException包装一层，然后再抛出，这样子做的目的是
* 为了让调用者使用变得更加灵活。
*/
System.out.println("读取文件资源出错....");
throw new RuntimeException(e);
} finally {
try {
if (fileInputStream != null) {
fileInputStream.close();
System.out.println("关闭资源成功...");
}
} catch (IOException e) {
System.out.println("关闭资源失败...");
throw new RuntimeException(e);
}
}
}
}
字节流：
输入字节流
-----------| InputStream 输入字节流的基类 抽象类
----------------| FileInputStream 读取文件数据的输入字节流。
----------------| BufferedInputStream 缓冲输入字节流 缓冲输入字节流出现的目的： 为了提高读取文件数据的效率。 该类其实内部就是维护了一个8kb字节数组而已。
输出字节流：
---------| OutputStream 输出字节流的基类。 抽象类。
--------------| FileOutStream 向文件输出数据的输出字节流。
--------------| BufferedOutputStream 缓冲输出字节流。 该类出现的目的是为了提高写数据的效率 。 其实该类内部也是维护了一个8kb的数组而已，当
调用其write方法的时候数据默认是向它内部的数组中存储 的，只有调用flush方法或者是close方法或者是8kb的字节数组存储满数据的时候才会真正的向硬盘输出。
本文出自 “小鱼的博客” 博客，谢绝转载！