字节流，字符流文件复制总结，包含9种方法，都是标准写法

package cn.itcast_03;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Demo03 {

    public static void main(String[] args) {
        multi_byte_excute("123.mp4", "332.mp4");
    }

    // 字节流操作
    // 单字节文件复制（FileInputStreams,FileOutputStreams），适合文件的操作，即不用拿来看的，速度快，因为没有编码的操作，纯粹字节码
    public static void single_byte_excute(String infile, String outfile) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(infile);
            fos = new FileOutputStream(outfile);
            int by = 0;
            while ((by = fis.read()) != -1) {
                fos.write(by);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    // 字节数组文件复制（FileInputStreams,FileOutputStreams），适合文件的操作，即不用拿来看的，速度快，因为没有编码的操作，纯粹字节码
    public static void multi_byte_excute(String infile, String outfile) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(infile);
            fos = new FileOutputStream(outfile);
            int len = 0;
            byte[] bys = new byte[1024];
            while ((len = fis.read(bys, 0, bys.length)) != -1) {
                fos.write(bys, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 高效单字节文件复制（BufferedInputStreams,BufferedOutputStreams），增加了缓冲区，减少多次IO操作，IO操作消耗很大，有缓冲区能够增加效率，适合文件的操作，即不用拿来看的，速度快，因为没有编码的操作，纯粹字节码
    public static void buffer_single_byte_excute(String infile, String outfile) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream(infile));
            bos = new BufferedOutputStream(new FileOutputStream(outfile));
            int by = 0;
            while ((by = bis.read()) != -1) {
                bos.write(by);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 高效字节数组文件复制（BufferedInputStreams,BufferedOutputStreams），增加了缓冲区，减少多次IO操作，IO操作消耗很大，有缓冲区能够增加效率，适合文件的操作，即不用拿来看的，速度快，因为没有编码的操作，纯粹字节码
    public static void buffer_multi_byte_excute(String infile, String outfile) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream(infile));
            bos = new BufferedOutputStream(new FileOutputStream(outfile));
            int len = 0;
            byte[] array = new byte[1024];
            while ((len = bis.read(array, 0, array.length)) != -1) {
                bos.write(array, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // ------------------------------------------------------------------------
    // 字符流操作
    // 单个字符操作（OutputStreamWriter，称为字符流转字节流,InputStreamReader，称为字节流转字符流）适合文本文件
    public static void sinle_char_excute(String infile, String outfile) {
        OutputStreamWriter osw = null;
        InputStreamReader isr = null;

        try {
            osw = new OutputStreamWriter(new FileOutputStream(outfile));
            isr = new InputStreamReader(new FileInputStream(infile));
            int ch = 0;
            while ((ch = isr.read()) != -1) {
                osw.write(ch);
                osw.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (osw != null) {
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (isr != null) {
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 字符数组操作（OutputStreamWriter，称为字符流转字节流,InputStreamReader，称为字节流转字符流）适合文本文
    public static void multi_char_excute(String infile, String outfile) {
        OutputStreamWriter osw = null;
        InputStreamReader isr = null;
        try {
            osw = new OutputStreamWriter(new FileOutputStream(outfile));
            isr = new InputStreamReader(new FileInputStream(infile));
            int len = 0;
            char[] chs = new char[1024];
            while ((len = isr.read(chs, 0, chs.length)) != -1) {
                osw.write(chs, 0, len);
                osw.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (osw != null) {
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (isr != null) {
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 简便字符操作包装类，单字符输入输出复制（FileWriter，FileReader）
    public static void simple_single_char_excute(String infile, String outfile) {
        FileWriter fw = null;
        FileReader fr = null;
        try {
            fw = new FileWriter(outfile);
            fr = new FileReader(infile);
            int ch = 0;
            while ((ch = fr.read()) != -1) {
                fw.write(ch);
                fw.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 简便字符操作包装类，字符数组输入输出复制（FileWriter，FileReader）
    public static void simple_multi_char_excute(String infile, String outfile) {
        FileWriter fw = null;
        FileReader fr = null;
        try {
            fw = new FileWriter(outfile);
            fr = new FileReader(infile);
            int len = 0;
            char[] chs = new char[1024];
            while ((len = fr.read(chs, 0, chs.length)) != -1) {
                fw.write(chs, 0, len);
                fw.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 高效单字符缓冲流复制操作
    public static void buffer_single_char_excute(String infile, String outfile) {
        BufferedWriter bw = null;
        BufferedReader br = null;
        try {
            // bw = new BufferedWriter(new OutputStreamWriter(new
            // FileOutputStream(outfile)));
            bw = new BufferedWriter(new FileWriter(outfile));
            // br = new BufferedReader(new InputStreamReader(new
            // FileInputStream(infile)));
            br = new BufferedReader(new FileReader(infile));

            int ch = 0;
            while ((ch = br.read()) != -1) {
                bw.write(ch);
                bw.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 高效字符数组缓冲流复制操作
    public static void buffer_multi_char_excute(String infile, String outfile) {
        BufferedWriter bw = null;
        BufferedReader br = null;
        try {
            // bw = new BufferedWriter(new OutputStreamWriter(new
            // FileOutputStream(outfile)));
            bw = new BufferedWriter(new FileWriter(outfile));
            // br = new BufferedReader(new InputStreamReader(new
            // FileInputStream(infile)));
            br = new BufferedReader(new FileReader(infile));
            int len = 0;
            char[] chs = new char[1024];
            while ((len = br.read(chs, 0, chs.length)) != -1) {
                bw.write(chs, 0, len);
                bw.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 高效缓冲字符流特有功能进行文本文件复制操作,读行写行操作
    public static void buffer_special_char_file_copy(String infile, String outfile) {
        BufferedWriter bw = null;
        BufferedReader br = null;
        try {
            bw = new BufferedWriter(new FileWriter(outfile));
            br = new BufferedReader(new FileReader(infile));
            String str = null;
            //默认br.readLine()只读该行内容，不会读取该行的换行符
            while ((str = br.readLine()) != null) {
                bw.write(str);
                bw.newLine();
                bw.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}