标签：
流总结：
一、流的分类：
数据单位：字节流 字符流
方向： 输出流 输入流
角色： 节点流 套节流
字节流：以Stream结尾。
字符流：以Reader 和Writer 结尾。
输入流：所有带有Input或者Reader。
输出流：所有带有Output或者Writer。
节点流：构造时传入文件对象或文件路径的类都是字节流类。
处理流：构造时传入其他流的对象的类都是处理流类。
二、InputStream 是所有字节输入流的基类：
最典型的实现是：FileInputStream
最重要的三个方法：
int read() 从输入流中读取一个字节数据。
int read(byte[] b) 从输入流中将最多 b.length 个字节的数据读入 byte 数组 b 中。
int read(byte[] b, int off, int len) 从输入流中将最多 len 个字节的数据读入 byte 数组 b 中。
三、OutputStream 是所有字节输出流的基类:
最典型的是：FileOutputStream
最重要的三个方法：
void write(int b) 将指定的字节写入此输出流。
void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个 字节写入此输出流。
四、Reader
Reader 是所有字符输入流的基类
Reader 的典型实现时 FileReader 类
最重要的方法：
int read() 从输入流中读取一个字符数据。
int read(char[] c) 从输入流中将最多 c.length 个字符的数据读入 char 数组 c 中。
int read(char[] c, int off, int len) 从输入流中将最多 len 个字符的数据读入 char 数组 c 中。
五、Writer
Writer 是所有字符输出流的基类。
1.Writer 的典型实现就是 FileWriter 最重要的方法：
void write(int c) 将指定的字符写入此输出流。
void write(char[] c) 将 c.length 个字符从指定的 char 数组写入此输出流。
void write(char[] c, int off, int len) 将指定 char 数组中从偏移量 off 开始的 len 个 字符写入此输出流。
void write(String s) 将字符串写入此输出流。
void write(String s, int off, int len) 将指定字符串中从偏移量 off 开始的 len 个 字符写入此输出流。
七、字节缓冲流：
BufferedInputStream（FileInputStream）
BufferedOutputStream(FileOutputStream)//括号里是举例
八、字符缓冲流：
BufferedReader(FileReader)
BufferedWriter(FileWriter)//括号里是举例
缓冲流要套接在相应的节点流上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。
九、转换流：
转换流提供了在字节流和字符流之间的转换。
InputStreamReader和OutputStreamWriter。
InputStreamReader需要套接在InputStream对象上操，
OutputStreamWriter需要套接在OutputStream对象上操作
构造方法：
InputStreamReader(InputStream)
InputStreamReader(InputStream,String charsetName)
OutputStreamWriter(OutputStream)
OutputStreamWriter(OutputStream,String charsetName)
转换流通常在操作系统非默认的字符（并且明确知道文件的字符编码）编码文件时使用。
十、流的关闭
流的对象是不作为 Java 虚拟机垃圾回收处理的对象的，所以需要手动关闭流。
流的对象在使用完之后必须调用流对象的 close()方法来关闭流，释放堆内存（heap）。
十一、为什么Gc回收不了流对象？
垃圾回收是Java中自动内存管理的另一种叫法。垃圾回收的目的是为程序保持尽可能多的可用堆（heap）。 JVM会删除堆上不再需要从堆引用的对象。
Gc是主要清理内存，但close方法还要释放掉一些系统资源，比如硬盘读写所使用的资源。如果没有close，程序还是在运行，Gc不把它当成垃圾，回收不了。
如果一个流不关闭会产生一些额外问题。比如说锁定了某种资源。如果你用流打开了一个文件，没有关闭的话，这个文件就不能再被操作。会提示有程序在操作这个文件。而且也会占 用系统句柄。
缓冲流的关闭 ：关闭缓冲流，那么会自动关闭它所包装的底层节点流。
十二、字节流和字符流的应用
1.在处理视频，音频，图片等二进制数据文件是使用字节流。
2.在处理文本文件等字符文件时使用字符流。
十三、缓冲流通过减少调用本地 API 的次数来优化的输入和输出。
因为：
使用非缓冲 I/O。这意味着每次读或写请求是由基础 OS 直接处理。这可以使一个程序效率非常低下，因为每个这样的请求通常引发磁盘访问，网络活动，
或一些其它的操作，而这些是相对昂贵的。
十四、flush()方法：
1.在调用缓冲输出流的 write 方法时并没有把数据写入文件，而是从内存缓冲进入了输出流中，通过调用缓冲输出流的 flush 方法可以强制把输出流中的数据输出到文件中。
2.缓冲输出流调用 close 方法时会先进行 flush 操作再关闭流。
举例：
例一：输入流
package com.hpe.test2;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class TestInputStream {
public static void main(String[] args) {
File file = new File("src/abc.txt");
FileInputStream fis =null;
try {
fis=new FileInputStream(file);
int b=0;
while((b=fis.read())!=-1){
System.out.print((char)b);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
例二：输出流
package com.hpe.test2;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestOutputStream {
public static void main(String[] args) {
// TODO Auto-generated method stub
String src = "src/aaa.txt";
String target = "src/bbb.txt";
fileCopyByStream(src,target);
fileCopyByStreamArray(src,target);
}
public static void fileCopyByStream(String srcFile,String targetFile){
File file=new File(srcFile);
File file1 = new File(targetFile);
FileInputStream fis =null;
FileOutputStream fos=null;
try {
int b;
fis = new FileInputStream(file);
fos=new FileOutputStream(file1);
while((b=fis.read())!=-1){
fos.write(b);
}
fos.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
fis.close();
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void fileCopyByStreamArray(String srcFile,String targetFile){
File file=new File(srcFile);
File file1 = new File(targetFile);
FileInputStream fis =null;
FileOutputStream fos=null;
try {
int length;
byte[] b=new byte[10];
fis = new FileInputStream(file);
fos=new FileOutputStream(file1);
while((length=fis.read(b))!=-1){
fos.write(b,0,length);
}
fos.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
fis.close();//关闭流
fos.close();//关闭流
} catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
例三：文件复制四种方法效率比较
package com.hpe.test2;
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 TestFileCopy {
public static void main(String[] args) {
// TODO Auto-generated method stub
String src = "D:/aaa/abc.rar";
String target1 = "D:/bbb/cba1.rar";
String target2 = "D:/bbb/cba2.rar";
String target3 = "D:/bbb/cba3.rar";
String target4 = "D:/bbb/cba4.rar";
long start = System.currentTimeMillis();
fileCopyByStream(src,target1);
long end = System.currentTimeMillis();
System.out.println("执行时间为" + (end - start) + "毫秒");
start = System.currentTimeMillis();
fileCopyByStreamArray(src,target2);
end = System.currentTimeMillis();
System.out.println("执行时间为" + (end - start) + "毫秒");
start = System.currentTimeMillis();
fileCopyByBufferStream(src,target3);
end = System.currentTimeMillis();
System.out.println("执行时间为" + (end - start) + "毫秒");
start = System.currentTimeMillis();
fileCopyByBufferStreamArray(src,target4);
end = System.currentTimeMillis();
System.out.println("执行时间为" + (end - start) + "毫秒");
}
public static void fileCopyByStream(String srcFile, String targetFile){
File file = new File(srcFile);
File file1 = new File(targetFile);
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream(file);
fos = new FileOutputStream(file1);
int b = 0;
while((b = fis.read()) != -1){
// System.out.print((char)b);
fos.write(b);
}
fos.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
fis.close();
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void fileCopyByStreamArray(String srcFile, String targetFile){
File file = new File(srcFile);
File file1 = new File(targetFile);
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream(file);
fos = new FileOutputStream(file1);
int len = 0;
byte[] b = new byte[1024];
while((len = fis.read(b)) != -1){
// System.out.print((char)b);
fos.write(b,0,len);
}
fos.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
fis.close();
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void fileCopyByBufferStream(String srcFile, String targetFile){
File file = new File(srcFile);
File file1 = new File(targetFile);
FileInputStream fis = null;
FileOutputStream fos = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
fis = new FileInputStream(file);
fos = new FileOutputStream(file1);
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
int b = 0;
while((b = bis.read()) != -1){
// System.out.print((char)b);
bos.write(b);
}
bos.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
fis.close();
fos.close();
bis.close();
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void fileCopyByBufferStreamArray(String srcFile, String targetFile){
File file = new File(srcFile);
File file1 = new File(targetFile);
FileInputStream fis = null;
FileOutputStream fos = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
fis = new FileInputStream(file);
fos = new FileOutputStream(file1);
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
int len = 0;
byte[] b = new byte[1024];
while((len = bis.read(b)) != -1){
// System.out.print((char)b);
bos.write(b,0,len);
}
bos.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
fis.close();
fos.close();
bis.close();
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
标签：
原文地址：http://www.cnblogs.com/greatfish/p/5844113.html
