图片是转载的

字节流和字符流的区别：
读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。

1.字节流，单个字节

private static void method1() {
        // 普通字节流 /单个字节复制写入
        FileInputStream fi = null;
        FileOutputStream fo = null;
        try {
            fi = new FileInputStream("a.txt");
            fo = new FileOutputStream("b.txt");
            int n = 0;
            while ((n = fi.read()) != -1) {
                fo.write(n);
                fo.flush();
            }
            fi.close();
            fo.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

2.字节流，字节数组

private static void method2() {
        // 普通字节流 /字节数组方式复制写入
        FileInputStream fi = null;
        FileOutputStream fo = null;
        try {
            fi = new FileInputStream("a.txt");
            fo = new FileOutputStream("b.txt");
            byte[] by = new byte[1024];
            int len = 0;
            while ((len = fi.read(by)) != -1) {
                fo.write(by, 0, len);
                fo.flush();
            }
            fi.close();
            fo.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

3.缓冲字节流，单个字节

private static void method3() {
        // 高效字节流/单字节方式复制写入
        BufferedInputStream bi = null;
        BufferedOutputStream bo = null;
        try {
            bi = new BufferedInputStream(new FileInputStream("a.txt"));
            bo = new BufferedOutputStream(new FileOutputStream("b.txt"));
            int n = 0;
            while ((n = bi.read()) != -1) {
                bo.write(n);
                bo.flush();
            }
            bi.close();
            bo.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

4.缓冲字节流，字节数组

private static void method4() {
        // 高效字节流/字节数组方式复制写入
        BufferedInputStream bi = null;
        BufferedOutputStream bo = null;
        try {
            bo = new BufferedOutputStream(new FileOutputStream("b.txt"));
            bi = new BufferedInputStream(new FileInputStream("a.txt"));
            byte[] by = new byte[1024];
            int len = 0;
            while ((len = bi.read(by)) != -1) {
                bo.write(by, 0, len);
                bo.flush();
            }
            bi.close();
            bo.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

5.字符流，单个字符

private static void method5() {
        // 普通字符流/单字符方式复制写入
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("a.txt");
            fw = new FileWriter("b.txt");
            int n = 0;
            while ((n = fr.read()) != -1) {
                fw.write(n);
                fw.flush();
            }
            fr.close();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

6.字符流，字符数组

private static void method6() {
        // 普通字符流/字符数组方式复制写入
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("a.txt");
            fw = new FileWriter("b.txt");
            char[] ch = new char[1024];
            int len = 0;
            while ((len = fr.read(ch)) != -1) {
                fw.write(ch, 0, len);
                fw.flush();
            }
            fr.close();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

7.缓冲字符流，单个字符

private static void method7() {
        // 高效字符流/单字符方式复制写入
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("a.txt"));
            bw = new BufferedWriter(new FileWriter("b.txt"));
            int n = 0;
            while ((n = br.read()) != -1) {
                bw.write(n);
                bw.flush();
            }
            bw.close();
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

8.缓冲字符流，字符数组

private static void method8() {
        // 高效字符流/字符数组方式复制写入
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("a.txt"));
            bw = new BufferedWriter(new FileWriter("b.txt"));
 
            char[] ch = new char[1024];
            int n = 0;
            while ((n = br.read(ch)) != -1) {
                bw.write(ch, 0, n);
                bw.flush();
            }
            bw.close();
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

9.缓冲字符流，按行读取

private static void method9() {
        // 高效字符流/特殊方式复制写入
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("a.txt"));
            bw = new BufferedWriter(new FileWriter("b.txt"));
            String s = null;
            while ((s = br.readLine()) != null) {
                bw.write(s);
                bw.newLine();
                bw.flush();
            }
            br.close();
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

10.转换流

InputStreamReader 字节流转字符流
OutputStreamWriter 字符流转字节流

10.1 字节转字符流并用缓冲流包装加快效率

public static void readTest() throws IOException{
    InputStream in = System.in; //获取了标准的输入流。
//      System.out.println("读到 的字符："+ (char)in.read());  //read()一次只能读取一个字节。
        //需要把字节流转换成字符流。
        InputStreamReader inputStreamReader = new InputStreamReader(in);
        //使用字符流的缓冲类
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String line = null;
        while((line = bufferedReader.readLine())!=null){
            System.out.println("内容："+ line);
        }
    }

实战示例：
inputStreamReader将字节流转换为字符流进行读取，若要加快效率，可以用bufferReader包装类进行包装。
outptStreamWriter将字符流转换为字节流进行输出，若要加快效率，可以用bufferWriter包装类进行包装。

package com.app;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

public class A5 {

    public static void main(String[] args) {
        String filePath = "F:/123.txt" ;
        String filePath2 = "F:/abc.txt" ;
        File file = new File( filePath ) ;
        File file2 = new File( filePath2 ) ;
        copyFile( file , file2 );

    }

    private static void copyFile( File oldFile , File newFile ){
        InputStream inputStream = null ;
        InputStreamReader inputStreamReader = null ;

        OutputStream outputStream = null ;
        OutputStreamWriter outputStreamWriter = null ;

        try {
            inputStream = new FileInputStream( oldFile ) ; //创建输入流
            inputStreamReader = new InputStreamReader( inputStream ) ; //创建转换输入流

            outputStream = new FileOutputStream( newFile ) ; //创建输出流
            outputStreamWriter = new OutputStreamWriter( outputStream ) ; //创建转换输出流

            int result = 0 ;

            while( (result = inputStreamReader.read()) != -1){  //一次只读一个字符
                outputStreamWriter.write( result ); //一次只写一个字符
            }

            outputStreamWriter.flush();  //强制把缓冲写入文件

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally{

            if ( outputStreamWriter != null) {
                try {
                    outputStreamWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if ( inputStreamReader != null ) {
                try {
                    inputStreamReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

END，差不多基本够用了~