java 文件字节和字符流 缓冲流

流的原理

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();
             }
         }
     }
 }

纯文本使用字符流，提高读取效率和写入效率使用缓冲字符流，其他情况都可使用字节流来完成