IO流

* 查看FileOutputStream的构造方法：
*
* FileOutputStream(File file)
* FileOutputStream(String name)
*
* 字节输出流操作步骤：
* A:创建字节输出流对象
* B:写数据
* C:释放资源

        // 创建字节输出流对象
        // FileOutputStream(File file)
        // File file = new File("fos.txt");
        // FileOutputStream fos = new FileOutputStream(file);
        // FileOutputStream(String name)
        FileOutputStream fos = new FileOutputStream("fos.txt");
        /*
         * 创建字节输出流对象了做了几件事情：
         * A:调用系统功能去创建文件
         * B:创建fos对象
         * C:把fos对象指向这个文件
         */
        
        //写数据
        fos.write("hello,IO".getBytes());
        fos.write("java".getBytes());
        
        //释放资源
        //关闭此文件输出流并释放与此流有关的所有系统资源。
        fos.close();
        /*
         * 为什么一定要close()呢?
         * A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
         * B:通知系统去释放跟该文件相关的资源
         */
        //java.io.IOException: Stream Closed
        //fos.write("java".getBytes());

* 字节输出流操作步骤：
* A:创建字节输出流对象
* B:调用write()方法
* C:释放资源
*
* public void write(int b):写一个字节
* public void write(byte[] b):写一个字节数组
* public void write(byte[] b,int off,int len):写一个字节数组的一部分

        // 创建字节输出流对象
        // OutputStream os = new FileOutputStream("fos2.txt"); // 多态
        FileOutputStream fos = new FileOutputStream("fos2.txt");

        // 调用write()方法
        //fos.write(97); //97 -- 底层二进制数据    -- 通过记事本打开 -- 找97对应的字符值 -- a
        // fos.write(57);
        // fos.write(55);
        
        //public void write(byte[] b):写一个字节数组
        byte[] bys={97,98,99,100,101};
        fos.write(bys);
        
        //public void write(byte[] b,int off,int len):写一个字节数组的一部分
        fos.write(bys,1,3);
        
        //释放资源
        fos.close();

* 如何实现数据的换行?
* 为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
* 如何实现呢?写入换行符号即可呗。
* 刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
* 因为不同的系统针对不同的换行符号识别是不一样的?
* windows:
* linux:
* Mac:
* 而一些常见的个高级记事本，是可以识别任意换行符号的。
*
* 如何实现数据的追加写入?
* 用构造方法带第二个参数是true的情况即可

        // 创建字节输出流对象
        // FileOutputStream fos = new FileOutputStream("fos3.txt");
        // 创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
        FileOutputStream fos = new FileOutputStream("fos3.txt", true);

        // 写数据
        for (int x = 0; x < 10; x++) {
            fos.write(("hello" + x).getBytes());
            fos.write("
".getBytes());
        }

        // 释放资源
        fos.close();

FileOutPutStream写出数据加入异常处理：

        // 改进版
        // 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
        FileOutputStream fos = null;
        try {
            // fos = new FileOutputStream("z:\fos4.txt");
            fos = new FileOutputStream("fos4.txt");
            fos.write("java".getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 如果fos不是null，才需要close()
            if (fos != null) {
                // 为了保证close()一定会执行，就放到这里了
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

* 字节输入流操作步骤：
* A:创建字节输入流对象
* B:调用read()方法读取数据，并把数据显示在控制台
* C:释放资源
*
* 读取数据的方式：
* A:int read():一次读取一个字节
* B:int read(byte[] b):一次读取一个字节数组

        FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");

        // 最终版代码
        int by = 0;
        // 读取，赋值，判断
        while ((by = fis.read()) != -1) {
            System.out.print((char) by);
        }

        // 释放资源
        fis.close();

* 一次读取一个字节数组：int read(byte[] b)
* 返回值其实是实际读取的字节个数。

        // 创建字节输入流对象
        FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");

        // 最终版代码
        // 数组的长度一般是1024或者1024的整数倍
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len));
        }

        // 释放资源
        fis.close();

* 计算机是如何识别什么时候该把两个字节转换为一个中文呢?
* 在计算机中中文的存储分两个字节：
* 第一个字节肯定是负数。
* 第二个字节常见的是负数，可能有正数。但是没影响。

        String s = "我爱你中国";
        // [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]

        byte[] bys = s.getBytes();
        System.out.println(Arrays.toString(bys));

* 通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
* 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
* 这种类被称为：缓冲区类(高效类)
* 写数据：BufferedOutputStream
* 读数据：BufferedInputStream
*
* 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
*
* 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
* 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。

        // BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                "bos.txt"));

        // 读取数据
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len));
        }

        // 释放资源
        bis.close();

        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("bos.txt"));

        // 写数据
        bos.write("hello".getBytes());

        // 释放资源
        bos.close();

* 字节流四种方式复制文件：
* 基本字节流一次读写一个字节： 共耗时：117235毫秒
* 基本字节流一次读写一个字节数组： 共耗时：156毫秒
* 高效字节流一次读写一个字节： 共耗时：1141毫秒
* 高效字节流一次读写一个字节数组： 共耗时：47毫秒

    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        // method1("e:\哥有老婆.mp4", "copy1.mp4");
        // method2("e:\哥有老婆.mp4", "copy2.mp4");
        // method3("e:\哥有老婆.mp4", "copy3.mp4");
        method4("e:\哥有老婆.mp4", "copy4.mp4");
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }

    // 高效字节流一次读写一个字节数组：
    public static void method4(String srcString, String destString)
            throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcString));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destString));

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }

    // 高效字节流一次读写一个字节：
    public static void method3(String srcString, String destString)
            throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcString));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destString));

        int by = 0;
        while ((by = bis.read()) != -1) {
            bos.write(by);

        }

        bos.close();
        bis.close();
    }

    // 基本字节流一次读写一个字节数组
    public static void method2(String srcString, String destString)
            throws IOException {
        FileInputStream fis = new FileInputStream(srcString);
        FileOutputStream fos = new FileOutputStream(destString);

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }

        fos.close();
        fis.close();
    }

    // 基本字节流一次读写一个字节
    public static void method1(String srcString, String destString)
            throws IOException {
        FileInputStream fis = new FileInputStream(srcString);
        FileOutputStream fos = new FileOutputStream(destString);

        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }

        fos.close();
        fis.close();
    }

* 复制文本文件
*
* 分析：
* 复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
* 通过该原理，我们知道我们应该采用字符流更方便一些。
* 而字符流有5种方式，所以做这个题目我们有5种方式。推荐掌握第5种。
* 数据源：
* c:\a.txt -- FileReader -- BufferdReader
* 目的地：
* d:\b.txt -- FileWriter -- BufferedWriter

    // 字符缓冲流一次读写一个字符串
    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();
    }

* 复制图片
*
* 分析：
* 复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
* 通过该原理，我们知道我们应该采用字节流。
* 而字节流有4种方式，所以做这个题目我们有4种方式。推荐掌握第4种。
*
* 数据源：
* c:\a.jpg -- FileInputStream -- BufferedInputStream
* 目的地：
* d:\b.jpg -- FileOutputStream -- BufferedOutputStream

    // 字节缓冲流一次读写一个字节数组
    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();
    }

 * 需求：把ArrayList集合中的字符串数据存储到文本文件

        // 封装数据与(创建集合对象)
        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();

 * 需求：从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合

        // 封装数据源
        BufferedReader br = new BufferedReader(new FileReader("b.txt"));
        // 封装目的地(创建集合对象)
        ArrayList<String> array = new ArrayList<String>();

        // 读取数据存储到集合中
        String line = null;
        while ((line = br.readLine()) != null) {
            array.add(line);
        }

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

        // 遍历集合
        for (String s : array) {
            System.out.println(s);
        }

* 需求：复制指定目录下的指定文件，并修改后缀名。
* 指定的文件是：.java文件。
* 指定的后缀名是：.jad
* 指定的目录是：jad

        // 封装目录
        File srcFolder = new File("e:\java");
        // 封装目的地
        File destFolder = new File("e:\jad");
        // 如果目的地目录不存在，就创建
        if (!destFolder.exists()) {
            destFolder.mkdir();
        }

        // 获取该目录下的java文件的File数组
        File[] fileArray = srcFolder.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir, name).isFile() && name.endsWith(".java");
            }
        });

        // 遍历该File数组，得到每一个File对象
        for (File file : fileArray) {
            // System.out.println(file);
            // 数据源：e:javaDataTypeDemo.java
            // 目的地：e:\jadDataTypeDemo.java
            String name = file.getName();
            File newFile = new File(destFolder, name);
            copyFile(file, newFile);
        }

        // 在目的地目录下改名
        File[] destFileArray = destFolder.listFiles();
        for (File destFile : destFileArray) {
            // System.out.println(destFile);
            // e:jadDataTypeDemo.java
            // e:\jad\DataTypeDemo.jad
            String name =destFile.getName(); //DataTypeDemo.java
            String newName = name.replace(".java", ".jad");//DataTypeDemo.jad
            
            File newFile = new File(destFolder,newName);
            destFile.renameTo(newFile);
        }
    }

    private static void copyFile(File file, File newFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                file));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(newFile));

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }

 * 需求：复制多极文件夹

    public static void main(String[] args) throws IOException {
        // 封装数据源File
        File srcFile = new File("E:\JavaSE\day21\code\demos");
        // 封装目的地File
        File destFile = new File("E:\");

        // 复制文件夹的功能
        copyFolder(srcFile, destFile);
    }

    private static void copyFolder(File srcFile, File destFile)
            throws IOException {
        // 判断该File是文件夹还是文件
        if (srcFile.isDirectory()) {
            // 文件夹
            File newFolder = new File(destFile, srcFile.getName());
            newFolder.mkdir();

            // 获取该File对象下的所有文件或者文件夹File对象
            File[] fileArray = srcFile.listFiles();
            for (File file : fileArray) {
                copyFolder(file, newFolder);
            }
        } else {
            // 文件
            File newFile = new File(destFile, srcFile.getName());
            copyFile(srcFile, newFile);
        }
    }

    private static void copyFile(File srcFile, File newFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(newFile));

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }

* 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低存入文本文件
*
* 分析：
* A:创建学生类
* B:创建集合对象
* TreeSet<Student>
* C:键盘录入学生信息存储到集合
* D:遍历集合，把数据写到文本文件

    public static void main(String[] args) throws IOException {
        // 创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s2.getSum() - s1.getSum();
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;
                int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName())
                        : num4;
                return num5;
            }
        });

        // 键盘录入学生信息存储到集合
        for (int x = 1; x <= 5; x++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第" + x + "个的学习信息");
            System.out.println("姓名：");
            String name = sc.nextLine();
            System.out.println("语文成绩：");
            int chinese = sc.nextInt();
            System.out.println("数学成绩：");
            int math = sc.nextInt();
            System.out.println("英语成绩：");
            int english = sc.nextInt();

            // 创建学生对象
            Student s = new Student();
            s.setName(name);
            s.setChinese(chinese);
            s.setMath(math);
            s.setEnglish(english);

            // 把学生信息添加到集合
            ts.add(s);
        }

        // 遍历集合，把数据写到文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt"));
        bw.write("学生信息如下：");
        bw.newLine();
        bw.flush();
        bw.write("姓名,语文成绩,数学成绩,英语成绩");
        bw.newLine();
        bw.flush();
        for (Student s : ts) {
            StringBuilder sb = new StringBuilder();
            sb.append(s.getName()).append(",").append(s.getChinese())
                    .append(",").append(s.getMath()).append(",")
                    .append(s.getEnglish());
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        // 释放资源
        bw.close();
        System.out.println("学习信息存储完毕");
    }

* 用Reader模拟BufferedReader的readLine()功能
*
* readLine():一次读取一行，根据换行符判断是否结束，只返回内容，不返回换行符

public class MyBufferedReader {
    private Reader r;

    public MyBufferedReader(Reader r) {
        this.r = r;
    }

    /*
     * 思考：写一个方法，返回值是一个字符串。
     */
    public String readLine() throws IOException {
        /*
         * 我要返回一个字符串，我该怎么办呢? 我们必须去看看r对象能够读取什么东西呢? 两个读取方法，一次读取一个字符或者一次读取一个字符数组
         * 那么，我们要返回一个字符串，用哪个方法比较好呢? 我们很容易想到字符数组比较好，但是问题来了，就是这个数组的长度是多长呢?
         * 根本就没有办法定义数组的长度，你定义多长都不合适。 所以，只能选择一次读取一个字符。
         * 但是呢，这种方式的时候，我们再读取下一个字符的时候，上一个字符就丢失了 所以，我们又应该定义一个临时存储空间把读取过的字符给存储起来。
         * 这个用谁比较和是呢?数组，集合，字符串缓冲区三个可供选择。
         * 经过简单的分析，最终选择使用字符串缓冲区对象。并且使用的是StringBuilder
         */
        StringBuilder sb = new StringBuilder();

        // 做这个读取最麻烦的是判断结束，但是在结束之前应该是一直读取，直到-1
        
        
        /*
        hello
        world
        java    
        
        104101108108111
        119111114108100
        1069711897
         */
        
        int ch = 0;
        while ((ch = r.read()) != -1) { //104,101,108,108,111
            if (ch == '
') {
                continue;
            }

            if (ch == '
') {
                return sb.toString(); //hello
            } else {
                sb.append((char)ch); //hello
            }
        }

        // 为了防止数据丢失，判断sb的长度不能大于0.就是怕最后一行没有换行,那就没有换行符.
        if (sb.length() > 0) {
            return sb.toString();
        }

        return null;
    }

    /*
     * 先写一个关闭方法
     */
    public void close() throws IOException {
        this.r.close();
    }
}

* 测试MyBufferedReader的时候，你就把它当作BufferedReader一样的使用

public class MyBufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        MyBufferedReader mbr = new MyBufferedReader(new FileReader("my.txt"));

        String line = null;
        while ((line = mbr.readLine()) != null) {
            System.out.println(line);
        }

        mbr.close();
    }
}

* BufferedReader
*　　 |--LineNumberReader
* 　　　　 public int getLineNumber()获得当前行号。
* 　　　　 public void setLineNumber(int lineNumber)

        LineNumberReader lnr = new LineNumberReader(new FileReader("my.txt"));

        // 从10开始才比较好
        // lnr.setLineNumber(10);

        // System.out.println(lnr.getLineNumber());
        // System.out.println(lnr.getLineNumber());
        // System.out.println(lnr.getLineNumber());

        String line = null;
        while ((line = lnr.readLine()) != null) {
            System.out.println(lnr.getLineNumber() + ":" + line);
        }

        lnr.close();

自定义LineNumberReader:

public class MyLineNumberReader {
    private Reader r;
    private int lineNumber = 0;

    public MyLineNumberReader(Reader r) {
        this.r = r;
    }

    public int getLineNumber() {
        // lineNumber++;
        return lineNumber;
    }

    public void setLineNumber(int lineNumber) {
        this.lineNumber = lineNumber;
    }

    public String readLine() throws IOException {
        lineNumber++;

        StringBuilder sb = new StringBuilder();

        int ch = 0;
        while ((ch = r.read()) != -1) {
            if (ch == '
') {
                continue;
            }

            if (ch == '
') {
                return sb.toString();
            } else {
                sb.append((char) ch);
            }
        }

        if (sb.length() > 0) {
            return sb.toString();
        }

        return null;
    }

    public void close() throws IOException {
        this.r.close();
    }
}

或者:

public class MyLineNumberReader2 extends MyBufferedReader {
    private Reader r;

    private int lineNumber = 0;

    public MyLineNumberReader2(Reader r) {
        super(r);
    }

    public int getLineNumber() {
        return lineNumber;
    }

    public void setLineNumber(int lineNumber) {
        this.lineNumber = lineNumber;
    }

    @Override
    public String readLine() throws IOException {
        lineNumber++;
        return super.readLine();
    }
}