（十二）例子:
                (1) 复制文本文件
                          
                          分析：
                                        字符流的5种方式实现。
                          数据源：
                                        c:\\a.txt -- FileReader -- BufferdReader
                          目的地：
                                        d:\\b.txt -- FileWriter -- BufferedWriter
        代码实现:
                public class CopyFileDemo {
                        public static void main(String[] args) throws IOException {
                                String srcString = "c:\\a.txt";
                                String destString = "d:\\b.txt";
                                // method1(srcString, destString);
                                // method2(srcString, destString);
                                // method3(srcString, destString);
                                // method4(srcString, destString);
                                method5(srcString, destString);
                        }
                        // 字符缓冲流一次读写一个字符串
                        private static void method5(String srcString, String destString)
                                        throws IOException {
                                BufferedReader br = new BufferedReader(new FileReader(srcString));
                                BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

                                String line = null;
                                while ((line = br.readLine()) != null) {
                                        bw.write(line);
                                        bw.newLine();
                                        bw.flush();
                                }

                                bw.close();
                                br.close();
                        }
                        // 字符缓冲流一次读写一个字符数组
                        private static void method4(String srcString, String destString)
                                        throws IOException {
                                BufferedReader br = new BufferedReader(new FileReader(srcString));
                                BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
                                char[] chs = new char[1024];
                                int len = 0;
                                while ((len = br.read(chs)) != -1) {
                                        bw.write(chs, 0, len);
                                }
                                bw.close();
                                br.close();
                        }
                        // 字符缓冲流一次读写一个字符
                        private static void method3(String srcString, String destString)
                                        throws IOException {
                                BufferedReader br = new BufferedReader(new FileReader(srcString));
                                BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
                                int ch = 0;
                                while ((ch = br.read()) != -1) {
                                        bw.write(ch);
                                }
                                bw.close();
                                br.close();
                        }
                        // 基本字符流一次读写一个字符数组
                        private static void method2(String srcString, String destString)
                                        throws IOException {
                                FileReader fr = new FileReader(srcString);
                                FileWriter fw = new FileWriter(destString);
                                char[] chs = new char[1024];
                                int len = 0;
                                while ((len = fr.read(chs)) != -1) {
                                        fw.write(chs, 0, len);
                                }
                                fw.close();
                                fr.close();
                        }
                        // 基本字符流一次读写一个字符
                        private static void method1(String srcString, String destString)
                                        throws IOException {
                                FileReader fr = new FileReader(srcString);
                                FileWriter fw = new FileWriter(destString);

                                int ch = 0;
                                while ((ch = fr.read()) != -1) {
                                        fw.write(ch);
                                }
                                fw.close();
                                fr.close();
                        }
                }
        （2）复制图片
                        分析：
                                用字节流的4种方式实现。
                          数据源：
                                        c:\\a.jpg -- FileInputStream -- BufferedInputStream
                          目的地：
                                        d:\\b.jpg -- FileOutputStream -- BufferedOutputStream
        代码实现:
                public class CopyImageDemo {
                        public static void main(String[] args) throws IOException {
                                // 使用File对象做为参数
                                File srcFile = new File("c:\\a.jpg");
                                File destFile = new File("d:\\b.jpg");
                                // method1(srcFile, destFile);
                                // method2(srcFile, destFile);
                                // method3(srcFile, destFile);
                                method4(srcFile, destFile);
                        }
                        // 字节缓冲流一次读写一个字节数组
                        private static void method4(File srcFile, File destFile) throws IOException {
                                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                                                srcFile));
                                BufferedOutputStream bos = new BufferedOutputStream(
                                                new FileOutputStream(destFile));
                                byte[] bys = new byte[1024];
                                int len = 0;
                                while ((len = bis.read(bys)) != -1) {
                                        bos.write(bys, 0, len);
                                }
                                bos.close();
                                bis.close();
                        }
                        // 字节缓冲流一次读写一个字节
                        private static void method3(File srcFile, File destFile) throws IOException {
                                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                                                srcFile));
                                BufferedOutputStream bos = new BufferedOutputStream(
                                                new FileOutputStream(destFile));
                                int by = 0;
                                while ((by = bis.read()) != -1) {
                                        bos.write(by);
                                }
                                bos.close();
                                bis.close();
                        }
                        // 基本字节流一次读写一个字节数组
                        private static void method2(File srcFile, File destFile) throws IOException {
                                FileInputStream fis = new FileInputStream(srcFile);
                                FileOutputStream fos = new FileOutputStream(destFile);
                                byte[] bys = new byte[1024];
                                int len = 0;
                                while ((len = fis.read(bys)) != -1) {
                                        fos.write(bys, 0, len);
                                }
                                fos.close();
                                fis.close();
                        }
                        // 基本字节流一次读写一个字节
                        private static void method1(File srcFile, File destFile) throws IOException {
                                FileInputStream fis = new FileInputStream(srcFile);
                                FileOutputStream fos = new FileOutputStream(destFile);
                                int by = 0;
                                while ((by = fis.read()) != -1) {
                                        fos.write(by);
                                }
                                fos.close();
                                fis.close();
                        }
                }
        （3）需求：把ArrayList集合中的字符串数据存储到文本文件
                          
                          分析：
                                          通过题目的意思我们可以知道如下的一些内容，
                                                  ArrayList集合里存储的是字符串。
                                                  遍历ArrayList集合，把数据获取到。
                                                  然后存储到文本文件中。
                                                  文本文件说明使用字符流。                          
                          数据源：
                                          ArrayList<String> -- 遍历得到每一个字符串数据
                          目的地：
                                          a.txt -- FileWriter -- BufferedWriter
        代码实现:                 
                public class ArrayListToFileDemo {
                        public static void main(String[] args) throws IOException {
                                // 封装数据与(创建集合对象)
                                ArrayList<String> array = new ArrayList<String>();
                                array.add("hello");
                                array.add("world");
                                array.add("java");
                                // 封装目的地
                                BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
                                // 遍历集合
                                for (String s : array) {
                                        // 写数据
                                        bw.write(s);
                                        bw.newLine();
                                        bw.flush();
                                }
                                // 释放资源
                                bw.close();
                        }
                }

谢谢分享