流的原理
1) 在 Java 程序中，对于数据的输入/输出操作以“流”
(stream) 方式进行；
2) J2SDK 提供了各种各样的“流”类，用以获取不同种类的
数据；程序中通过标准的方法输入或输出数据。
3) Java 的流类型一般位于 java.io 包中
IO流基本概念：----->https://www.cnblogs.com/oubo/archive/2012/01/06/2394638.html
文件字节流
FileInputStream/FileOutputStream
使用 FileInputStream 读取文件内容
1) abstract int read( ); //一次读取一个字节，读到文件末尾为-1
2) int read( byte b[ ] ); //从该输入流读取最多 b.length个字节的数据为字节数组。
3) int read( byte b[ ], int off, int len );
4) int available( ); //估算文件字节数
5) close( ); //关闭文件输入流
FileInputStream fis=new FileInputStream(new File("D:\\test.txt")); //在此之前"D:\\test.txt"不存在则new File(path)
如果"D:\\test.txt"已经存在，则不需new,直接FileInputStream fis=new FileInputStream("D:\\test.txt");即可
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException; public class TestInpuStream {
public static void main(String[] args) throws IOException {
//(1)数据源与应用程序之间搭建管道
FileInputStream fis=new FileInputStream(new File("D:\\test.txt"));
//(2)从数据源开始向程序中读数据
int count=fis.available();
System.out.println("文件中大概有"+count+"个字节"); //中转站比较小，一次读一个字节
//System.out.println(fis.read()); //读取一个字节
//System.out.println(fis.available()); //文件中还有多少字节未读取 int buf=0;//存储读到的字节
int i=0;
while((buf=fis.read())!=-1){
i++;
System.out.print((char)buf);
}
//(3)关闭
fis.close();
System.out.println(i);
}
}
import java.io.FileInputStream;
import java.io.IOException; public class TestInputStream2 {
public static void main(String[] args) throws IOException {
//(1)搭桥
FileInputStream fis=new FileInputStream("D:\\test.txt");
//(2)创建大一些的中转站
byte [] buf=new byte[1024];
int len=0;//用于存储每次读到的实际字节
int i=0;
while((len=fis.read(buf))!=-1){
i++;
//借助String类构造方法
System.out.println(new String(buf,0,len));
}
//(3)关闭
fis.close();
System.out.println(i);
}
}
使用 FileOutputStream 写内容到文件
1) abstract void write( int b ); //一次写一个字节
2) void write( byte b[ ] ); //将 b.length个字节从指定的字节数组写入此文件输出流。
3) void write( byte b[ ], int off, int len );
4) void flush( );//刷新缓冲区
5) void close( ); //关闭
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException; public class TestFileOutputStream {
public static void main(String[] args) {
//(1)搭桥
FileOutputStream fos=null;
try {
fos = new FileOutputStream("D:\\a.txt",true);//如果有true这个参数则写入方式为追加，前提是有这个文件
//(2)写数据，一次写一个字节
//fos.write(97);
//(2)一次写多个字节
byte [] buf="helloworld".getBytes();//使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中。
fos.write(buf);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
//(3)关闭
try {
if(fos!=null){
fos.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
使用字节流实现文件复制
文件复制的原理
文件复制的代码实现
1.没经过异常处理前的代码
import java.io.FileInputStream;
import java.io.FileOutputStream; public class TestFileCopy { public static void main(String[] args) {
//数据源是文件
FileInputStream fis = new FileInputStream("D:\\test.txt");
//目的地
FileOutputStream fos = new FileOutputStream("E:\\tager.txt"); int b = 0;//用于存储读到的字节，中转站
while( (b = fis.read()) != -1 ) {
//写入文件
fos.write(b);
}
//关闭
fos.close();
fis.close();
}
}
2.经过异常处理的代码：选中要处理的代码块(7~16行)，按住Alt+Shift+Z，选第一个添加try/cath,写个finally把关闭io流放到里面去，在finally还要处理关闭io异常
先分别为两个关闭io流添加try/cath，在try中添加判断，如果io流不为null再关闭(为null会抛出一个空指针异常), 每次只读一个字节太费io，改为一次读字节数组个字节
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException; public class TestFileCopy { public static void main(String[] args) {
//数据源是文件
FileInputStream fis = null;
//目的地
FileOutputStream fos = null;
try {
fis = new FileInputStream("D:\\test.txt");
fos = new FileOutputStream("E:\\tager.txt");
byte[] buf = new byte[1024];//中转站
int len = 0;//用于存储每次读到的字节个数
while( ((len = fis.read(buf)) != -1)) {
fos.write(buf,0,len);
}
/*int b = 0;//用于存储读到的字节，中转站
while( (b = fis.read()) != -1 ) {
//写入文件
fos.write(b);
}*/
} catch (FileNotFoundException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {//无论程序是否产生异常，最后io都要关闭
//关闭
try {
if(fos != null) {
fos.close();
}
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
try {
if(fis != null) {
fis.close();
}
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
}
文件字符流
Reader/Writer
使用 Reader 读取文件内容
1) int read( );
2) int read( char [ ]cbuf );
3) int read( char [ ]cbuf, int off, int len ); //将字符读入数组的一部分 cbuf目标缓冲区 off开始存储字符的偏移量 len要读取的最大字符数
4) int available( );
5) close( );
import java.io.FileReader;
import java.io.IOException; public class TestFileReader {
public static void main(String[] args) throws IOException {
//(1)搭桥
FileReader reader=new FileReader("D:\\test.txt");
//(2)读取
//int b=reader.read(); //读到的字符的int类型数据
//System.out.println((char)b);
/*int b=0;//用于存储每次读到的字符数据的整数值
while((b=reader.read())!=-1){
System.out.println((char)b);
}*/
char [] cbuf=new char[1024];
int len=0;//用于存储读到的字符的个数
while((len=reader.read(cbuf))!=-1){
System.out.println(new String(cbuf,0,len));
}
//(3)关闭
reader.close();
}
}
使用 Writer 写内容到文件
1) void write( int c );
2) void write( char[]cbuf);
3) abstract void write( char [ ]cbuf, int off, int len ); //cbuf缓冲区 off从中开始编写字符的偏移量 要写入的 len数
4) void write(String str); //直接把字符串str写入
5) abstract void flush( ); //刷新缓冲区
6) void close( );
import java.io.FileWriter;
import java.io.IOException; public class TestWriter {
public static void main(String[] args) {
//创建对象
FileWriter writer=null;
try {
writer = new FileWriter("D:\\b.txt");
//写数据
writer.write("你好吗?");//写到了缓冲区中，
writer.flush(); //刷新缓冲区，如不刷新则需关闭才能写入
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
//关闭
try {
if(writer!=null){
writer.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
缓冲字节流
BufferedInputStream / BufferedOutputStream
FileInputStream 和 FileOutputStream 是节点流
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException; public class Filecopy { public static void main(String[] args) throws IOException {
//数据源
FileInputStream fis = new FileInputStream("F:\\java学习\\【API】jdk api 1.8_google.CHM");
//目的地
FileOutputStream fos = new FileOutputStream("F:\\java学习\\【API】jdk api 1.8_google2.CHM");
//读数据和写数据
long start = System.currentTimeMillis();
byte [] buf = new byte[1024];//中转站
int len = 0;
while( (len = fis.read(buf)) != -1) {
fos.write(buf, 0, len);
fos.flush();//手动刷新缓冲区
}
long end = System.currentTimeMillis();
System.out.println("文件复制一共用了"+(end-start)+"毫秒");//文件复制一共用了1143毫秒
//关闭
fos.close();
fis.close();
}
}
文件大小41M，用节点流在本机(机子性能较差)跑为1143毫秒。
BufferedInputStream 和 BufferedOutputStream 是处理流（包装
流）
1) 读文件和写文件都使用了缓冲区，减少了读写次数，从而
提高了效率
2) 当创建这两个缓冲流的对象时时，会创建了内部缓冲数组，
缺省使用 32 字节大小的缓冲区.
3) 当读取数据时，数据按块读入缓冲区，其后的读操作则直
接访问缓冲区
4) 当写入数据时，首先写入缓冲区，当缓冲区满时，其中的
数据写入所连接的输出流。使用方法 flush()可以强制将缓
冲区的内容全部写入输出流
5) 关闭流的顺序和打开流的顺序相反.只要关闭高层流即可，
关闭高层流其实关闭的底层节点流
6) Flush 的使用：手动将 buffer 中内容写入文件
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException; public class TestCopy { public static void main(String[] args) throws IOException {
//数据源
FileInputStream fis = new FileInputStream("F:\\java学习\\【API】jdk api 1.8_google.CHM");
//目的地
FileOutputStream fos = new FileOutputStream("F:\\java学习\\【API】jdk api 1.8_google2.CHM"); /*
* 使用缓冲流
*/
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos); //读数据和写数据
long start = System.currentTimeMillis();
byte [] buf = new byte[1024];//中转站
int len = 0;
while( (len = bis.read(buf)) != -1) {
bos.write(buf, 0, len);
bos.flush();//手动刷新缓冲区
}
long end = System.currentTimeMillis();
System.out.println("文件复制一共用了"+(end-start)+"毫秒");//文件复制一共用了863毫秒
//关闭
bos.close();
bis.close();
}
}
同样的文件用缓冲流(处理流)时间为863
缓冲字符流
BufferedReader
readLine() 读取一个文本行的数据
BufferedWriter
newLine()；写入一个行分隔符。
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException; public class TestBuffered { public static void main(String[] args) {
//缓冲字符流
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new FileReader("D:\\a.txt"));
bw = new BufferedWriter(new FileWriter("D:\\copya.txt"));
String line = null;//用于存储读到的字符串
while( (line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
} catch (FileNotFoundException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
try {
if(bw != null) {
bw.close();
}
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
try {
if(br != null) {
br.close();
}
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
}
纯文本使用字符流，提高读取效率和写入效率使用缓冲字符流，其他情况都可使用字节流来完成