* 集合
        * 概念: 集合本身不是一个类, 是一些容器类的统称.
        * 特点: 长度可变
        * ArrayList类
                * 构造方法:
                        * `ArrayList<E> ArrayList()`
                                * `<E>`: 泛型, 作用是约束集合中元素的数据类型, 只能写引用数据类型
                                * 示例: `ArrayList<Student> array = new ArrayList<Student>();`
                * 成员方法
                        * 增加:
                                * `boolean add(E e)`: 添加一个对象到集合的末尾
                                * `void add(int index, E e)`: 在指定索引上添加一个元素, 如果已有元素, 则从该元素开始会向后移动
                        * 删除
                                * `boolean remove(Object o)`: 直接删除一个元素
                                * `E remove(int index)`: 删除指定索引位置的元素, 返回被删除的元素
                        * 修改
                                * `E set(int index, E e)`: 将指定索引位置的元素修改为新的元素, 返回被替换的元素
                        * 查询
                                * `E get(int index)`: 获取指定索引上的元素
                        * 获取长度
                                * `int size()`: 获取集合的长度
                * 集合的遍历:
                        * for循环配合集合的size()方法和get()方法遍历
* 对象数组
        * 数组中也可以存储自定义对象
        * 对象数组中存储的是对象的地址值


IO流
        * IO: In输入, Out输出, 输入输出流
        * IO的作用: 读写磁盘上的文件
        * 分类:
                * 按方向分:
                        * 输入流
                        * 输出流
                * 按照数据分
                        * 字节流
                        * 字符流(今天所讲): 都是文本
        * 注意IO的方向: 都是相对于我们的Java程序来判断
        * 相关的类
                * 基本输入输出流
                        * `FileReader`: 文件字符输入流
                                * 构造方法: `FileReader(String filePath)`
                                * 成员方法:
                                        * `int read()`: 读取一个字符
                                        * `int read(char[] buf)`: 读取一个字符数组的数据, 并返回数据的长度
                                        * `close()`: 释放资源
                        * `FileWriter`: 文件字符输出流
                                * 构造方法: `FileWriter(String filePath)`
                                * 成员方法:
                                        * `write(String s)`: 写入一个字符串
                                        * `write(int ch)`: 写入一个字符
                                        * `write(char[] buf, int offset, int length)`: 写入数组中指定索引开始的指定长度的字符
                                        * `flush()`: 刷新数据
                                        * `close()`: 刷新数据, 并释放资源
                * 缓冲输入输出流
                        * `BufferedReader`: 缓冲字符输入流
                                * 构造方法: `BufferedReader(FileReader reader)`
                                * 成员方法:
                                        * `int read()`: 读一个字符
                                        * `int read(char[] buf)`: 读取一个字符数组的数据, 并返回数据的长度
                                        * `String readLine()`: 读取一行数据, 不包含换行符
                                        * `close()`: 释放资源
                        * `BufferedWriter`: 缓冲字符输出流
                                * 构造方法: `BufferedWriter(FileWriter writer)`
                                * 成员方法:
                                        * `write(String s)`: 写一个字符串
                                        * `write(int ch)`: 写一个字符
                                        * `write(char[] buf, int offset, int length)`: 写入数组中指定索引开始的指定长度的字符
                                        * `newLine()`: 写入一个换行符, 换行符由系统确认
                                        * `flush()`: 刷新数据
                                        * `close()`: 刷新数据并释放资源
* 重点: 5种复制文件的代码, 最好全背写出来. 至少要会newLine()这种
        * 基本流一次读写一个字符
        * 基本流一次读写一个字符数组
        * 缓冲流一次读写一个字符
        * 缓冲流一次读写一个字符数组
        * 缓冲流一次读写一行
/*
针对每种复制文件的方式单独定义一个方法
利用基本流一次读写一个字符
利用基本流一次读写一个字符数组
利用缓冲流一次读写一个字符
利用缓冲流一次读写一个字符数组
利用缓冲流的特有方法一次读写一个字符串
*/
public class Test {

        public static void main(String[] args) throws IOException {
                String srcFileName = "Test.java";
                String destFileName = "Copy.java";
               
                // 测试
                method1(srcFileName, destFileName);
                method2(srcFileName, destFileName);
                method3(srcFileName, destFileName);
                method4(srcFileName, destFileName);
                method5(srcFileName, destFileName);
        }
        
        // 缓冲流的特有方法一次读写一个字符串
        public static void method5(String srcFileName, String destFileName) throws IOException {
                // 创建缓冲输入流对象
                BufferedReader br = new BufferedReader(new FileReader(srcFileName));
                // 创建缓冲输出流对象
                BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
               
                // 缓冲流的特有方法一次读写一个字符串
                String line;
                while ((line = br.readLine()) != null) {
                        bw.write(line);
                        bw.newLine();
                        //bw.flush();  // 可选
                }
               
                // 释放资源
                bw.close();
                br.close();
        }
        
        // 缓冲流一次读写一个字符数组
        public static void method4(String srcFileName, String destFileName) throws IOException {
                // 创建缓冲输入流对象
                BufferedReader br = new BufferedReader(new FileReader(srcFileName));
                // 创建缓冲输出流对象
                BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
               
                // 一次读写一个字符数组
                char[] buf = new char[1024];
                int len;
                while ((len = br.read(buf)) != -1) {
                        bw.write(buf, 0, len);
                }
               
                // 释放资源
                bw.close();
                br.close();
        }
        
        // 缓冲流一次读写一个字符
        public static void method3(String srcFileName, String destFileName) throws IOException {
                // 创建缓冲输入流对象
                BufferedReader br = new BufferedReader(new FileReader(srcFileName));
                // 创建缓冲输出流对象
                BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
               
                // 一次读写一个字符
                int ch;
                while ((ch = br.read()) != -1) {
                        bw.write(ch);
                }
               
                // 释放资源
                bw.close();
                br.close();
        }
        
        // 基本流一次读写一个字符数组
        public static void method2(String srcFileName, String destFileName) throws IOException {
                // 创建输入流对象
                FileReader fr = new FileReader(srcFileName);
                // 创建输出流对象
                FileWriter fw = new FileWriter(destFileName);
               
                // 一次读写一个字符数组
                char[] buf = new char[1024];
                int len;
                while ((len = fr.read(buf)) != -1) {
                        fw.write(buf, 0, len);
                }
               
                // 释放资源
                fw.close();
                fr.close();
        }
        
        // 基本流一次读写一个字符
        public static void method1(String srcFileName, String destFileName) throws IOException {
                // 创建输入流对象
                FileReader fr = new FileReader(srcFileName);
                // 创建输出流对象
                FileWriter fw = new FileWriter(destFileName);
               
                // 一次读写一个字符
                int ch;
                while ((ch = fr.read()) != -1) {
                        fw.write(ch);
                }
               
                // 释放资源
                fw.close();
                fr.close();
        }
}
```

加油