java中OutputStream字节流与字符流InputStreamReader 每一种基本IO流BufferedOutputStream，FileInputStream，FileOutputStream，BufferedInputStream，BufferedReader，BufferedWriter，FileInputStream，FileReader，FileWriter，InputStr

BufferedOutputStream，FileInputStream，FileOutputStream，BufferedInputStream，BufferedReader，BufferedWriter，FileInputStream，FileReader，FileWriter，InputStreamReader
每一种流都介绍到了，详细一目了然的详细

下面是字节流常见操作的四种方式：

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

 /*
  * 四种方式实现大文件数据的读取写入--->复制
  * 1.基本字节流一次读取一个字节
  * 2.基本字节流一次读取一个字节数组
  * 3.高效字节流一次读取一个字节
  * 4.高校字节流一次读取一个字节数组
  *
  */
 public class Test2 {
     public static void main(String[] args) throws IOException {
         long start = System.currentTimeMillis();

         // method1("E:\\b.txt", "c.txt");    //基本字节流一次一个字节
         // method2("E:\\b.txt", "c.txt");    //一次一个字节数组
         // method3("E:\\b.txt", "c.txt");    //高效字节流一次一个字节
         method4("E:\\b.txt", "c.txt");       //高效字节流一次一个字节数组

         long end = System.currentTimeMillis();
         System.out.println("共耗时： " + (end - start) + "毫秒");
     }

     // 1.基本方法字节流一次读取一个字节
     public static void method1(String srcPath, String destPath)
             throws IOException {
         // 读取数据对象
         FileInputStream fis = new FileInputStream(srcPath);
         // 写入数据目标文件路径
         FileOutputStream fos = new FileOutputStream(destPath);
         // 数据读写
         // 直接以单字节读取
         int by = 0;
         while ((by = fis.read()) != -1) {
             fos.write(by);
         }
         // 关闭流
         fos.close();
         fis.close();
     }

     // 2.基本字节读取一次读取一个数组
     public static void method2(String srcPath, String destPath)
             throws IOException {
         // 数据读取的对象封装
         FileInputStream fis = new FileInputStream(srcPath);
         // 数据写入对象封装
         FileOutputStream fos = new FileOutputStream(destPath);
         // 数据的读写
         byte[] bys = new byte[1024];
         int len = 0;
         while ((len = fis.read(bys)) != -1) {
             fos.write(bys, 0, len);
         }
         // 关闭流
         fis.close();
         fos.close();
     }

     // 3.高效字节流一次读取一个字节
     public static void method3(String srcPath, String destPath)
             throws IOException {
         // 数据读取对象封装
         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                 srcPath));
         // 数据写入对象封装
         BufferedOutputStream bos = new BufferedOutputStream(
                 new FileOutputStream(destPath));

         // 数据读写操作
         int by = 0;
         while ((by = bis.read()) != -1) {
             bos.write(by);
         }

         // 关闭流
         bos.close();
         bis.close();
     }

     // 4.高效字节流读取一个字节数组
     public static void method4(String srcPath, String destPath)
             throws IOException {
         // 数据读取对象封装
         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                 srcPath));
         // 数据写入对象
         BufferedOutputStream bos = new BufferedOutputStream(
                 new FileOutputStream(destPath));

         // 数据读写操作
         byte[] bys = new byte[1024];
         int len = 0;
         while ((len = bis.read(bys)) != -1) {
             bos.write(bys, 0, len);
         }

         // 关闭流
         bos.close();
         bis.close();
     }
 }

下面是字符流常见操作的四种方式：

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileInputStream;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;

 /*
  * 需求：复制文本文件
  *     分析：如果使用Windows记事本打开之后能读懂就是用字符流，显然此处使用字符流
  *     字符流有五种方式:尤其是第五种字符高效流的特殊方式
  *     数据源的地址以及目标地址也应该用String封装
  */
 public class CopyFileDemo {
     public static void main(String[] args) throws IOException {
         // 字符流读取源文件对象
         // method1(); // 普通方法的单字节读取
         // method2(); //普通的字符数组
　　　　　　　//method3();  //高效的字节数组
         method4();   //高效的字节数组
         method5();    //按行读取写入  ，这个很常用！！
     }

     private static void method1() throws IOException {
         // 源文件对象，读取数据
         // InputStreamReader isr = new InputStreamReader(new FileInputStream(
         // "c:\\a.txt"));
         FileReader fr = new FileReader("c:\\a.txt");
         // 目标文件对象，写入数据
         FileWriter fw = new FileWriter("dest.txt");

         // 数据的复制
         int ch = 0;
         while ((ch = fr.read()) != -1) {
             fw.write(ch);
         }

         // 释放资源
         fr.close();
         fw.close();
     }

     // 字符数组读取复制文件
     private static void method2() throws IOException {
         // 数据源文件对象，读取数据
         FileReader fr = new FileReader("c:\\a.txt");
         // 目标文件对象，写入数据
         FileWriter fw = new FileWriter("dest.txt");

         // 数据复制
         char[] chs = new char[1024];
         int len = 0;
         while ((len = fr.read(chs)) != -1) {
             fw.write(chs, 0, len);
             fw.flush(); // 字符流在写入数据时一定记得刷新！
         }

         // 释放资源
         fr.close();
         fw.close();
     }

     // 高效字符数组复制文件--->单字符模式
     public static void method3() throws IOException {
         // 数据源文件对象，读取数据
         BufferedReader br = new BufferedReader(new FileReader("c:\\a.txt"));
         // 目标文件对象，写入数据
         BufferedWriter bw = new BufferedWriter(new FileWriter("dest1"));

         // 文件的复制
         int ch = 0;
         while ((ch = br.read()) != -1) {
             bw.write(ch);
         }

         // 释放资源
         bw.close();
         br.close();
     }

     // 高效字符数组复制文本文件--->字符数组模式
     private static void method4() throws IOException {
         // 数据源文件对象，读取数据
         BufferedReader br = new BufferedReader(new FileReader("c:\\a.txt"));
         // 目标文件对象，写入数据
         BufferedWriter bw = new BufferedWriter(new FileWriter("dest1.txt"));

         // 数据复制
         char[] chs = new char[1024];
         int len = 0;
         while ((len = br.read(chs)) != -1) {
             bw.write(chs);
             bw.flush();
         }

         // 释放资源
         br.close();
         bw.close();
     }

     // 高效字符流的特殊方法--->按行读取写入~！这个是狠狠常用的
     private static void method5() throws IOException {
         // 数据源文件对象，读取数据
         BufferedReader br = new BufferedReader(new FileReader("c:\\a.txt"));
         // 目标文件对象，写入数据
         BufferedWriter bw = new BufferedWriter(new FileWriter("dest.txt"));

         // 数据复制操作
         String line = null;
         while ((line = br.readLine()) != null) {
             bw.write(line);
             bw.newLine();
             bw.flush();
         }

         // 释放资源
         br.close();
         bw.close();
     }
 }