java基础学习_IO流02_递归、IO流字节流、IO流字符流(自学)_day20总结

java基础学习_IO流02_递归、IO流字节流、IO流字符流(自学)_day20总结

=============================================================================
=============================================================================
涉及到的知识点有：
　　 1:递归(理解)
        (1)递归的概述
        (2)递归的注意事项
        (3)递归的案例
    2:IO流字节流(掌握)
        (1)IO流概述
        (2)IO流的分类
        (3)FileOutputStream写出数据(字节输出流)
            A:字节输出流的操作步骤
            B:代码体现
            C:要注意的问题?
            D:字节流写数据的方式
            E:字节流写数据加入异常处理
        (4)FileInputStream读取数据(字节输入流)
            A:字节输入流的操作步骤
            B:代码体现
            C:要注意的问题?
            D:字节流读取数据的方式
        (5)案例：2种方式实现
        (6)字节缓冲区流
        (7)案例：4种方式实现
    3:IO流字符流(自学)
=============================================================================
=============================================================================
1:递归(理解)
    (1)递归的概述
        方法定义中调用方法本身的现象
        举例：
            从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事
                ......
                    庙挂了或者山崩了
            学编程 -- 高薪就业 -- 挣钱 -- 娶媳妇 -- 生娃娃 -- 放羊 -- 挣学费
                ......
                    娶不到媳妇或者生不了娃娃
    (2)递归的注意事项
        A:递归一定要有出口，否则就是死递归。
        B:递归的次数不能太多，否则就内存溢出。
        C:构造方法不能递归使用。
    (3)递归的案例
        A:递归求阶乘

package cn.itcast_02;

/*
 * 需求：请用代码实现求5的阶乘。
 * 下面的知识要知道：
 *         5! = 1*2*3*4*5
 *         5! = 5*4!
 * 
 * 有几种方案实现呢?
 *         A:循环实现
 *         B:递归实现
 *             a:做递归要写一个方法
 *             b:出口条件(就是已知的条件，比如题目所给的条件或者自然定理、常识等)
 *             c:规律
 */
public class DiGuiDemo {
    public static void main(String[] args) {
        // 循环实现
        int jc = 1;
        for (int x = 2; x <= 5; x++) {
            jc *= x;
        }
        System.out.println("5的阶乘是：" + jc);

        // 递归实现
        System.out.println("5的阶乘是：" + jieCheng(5));
    }
    
    /*
     * 做递归要写一个方法:
     *         返回值类型：int
     *         参数列表：int n
     * 出口条件:(就是已知的条件，比如题目所给的条件或者自然定理、常识等)
     *         if (n == 1) {
     *             return 1;
     *         }
     * 规律:
     *         if (n != 1) {
     *             return n*方法名(n-1);
     *         }
     */
    // 递归实现
    public static int jieCheng(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * jieCheng(n - 1);
        }
    }
}

        B:不死神兔问题(裴波那切数列问题)

package cn.itcast_02;

/*
 * 不死神兔问题(裴波那切数列问题)
 * 
 * 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
 * 
 * 分析：我们要想办法找规律
 * 
 *             兔子对数
 * 第一个月：     1
 * 第二个月：    1
 * 第三个月：    2    (老兔子生了一对兔子)
 * 第四个月：    3    (老兔子又生了一对兔子)
 * 第五个月：    5    (老兔子又又生了一对兔子，小兔子生了一对兔子)
 * 第六个月：    8   (老兔子又又又生了一对兔子，小兔子又生了一对兔子)
 * ......
 * 
 * 由此可见兔子对象的数据是：
 *         1,1,2,3,5,8......
 * 规律：
 *         A:从第三项开始，每一项是前两项之和。
 *         B:说明前两项是已知的。
 * 
 * 如何实现这个程序呢?有三种方式：
 *         A:数组实现
 *         B:变量的变化实现
 *         C:递归实现
 * 
 * 假如相邻的两个月的兔子对数是a,b
 *         第一个相邻的数据：a=1,b=1
 *         第二个相邻的数据：a=1,b=2
 *         第三个相邻的数据：a=2,b=3
 *         第四个相邻的数据：a=3,b=5
 *         第五个相邻的数据：a=5,b=8
 *         ......
 * 规律：
 *         下一次的a是以前的b，下一次的b是以前的a+b    
 */
public class DiGuiDemo2 {
    public static void main(String[] args) {
        // 数组实现
        // 定义一个数组
        int[] arr = new int[20];
        // 前两项是已知的
        arr[0] = 1;
        arr[1] = 1;
        // 从第三项开始，每一项是前两项之和。
        // arr[2] = arr[0] + arr[1];
        // arr[3] = arr[1] + arr[2];
        // ......
        for (int x = 2; x < arr.length; x++) {
            arr[x] = arr[x - 2] + arr[x - 1];
        }
        System.out.println(arr[19]); // 6765
        System.out.println("----------------");

        // 变量的变化实现
        int a = 1;
        int b = 1;
        for (int x = 0; x < 18; x++) { // 这里的循环只控制次数，变量x不参与运算。循环1次得到的b是2(相当于第三个月)，循环2次得到的b是3(相当于第四个月)......循环18次得到的b是6765(相当于第二十个月)
            // 临时变量存储上一次的a
            int temp = a;
            a = b; // 下一次的a是以前的b
            b = temp + b; // 下一次的b是以前的a+b
        }
        System.out.println(b); // 6765
        System.out.println("----------------");

        // 递归实现
        System.out.println(fib(20));
    }

    /*
     * 方法： 返回值类型：int 参数列表：int n 
     * 出口条件： 第一个月是1，第二个月是1 
     * 规律： 从第三个月开始，每一个月是前两个月之和
     */
    public static int fib(int n) {
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return fib(n - 1) + fib(n - 2);
        }
    }
}

        C:递归遍历输出指定目录下所有指定后缀名的文件的绝对路径

package cn.itcast_03;

import java.io.File;

/*
 * 需求：请大家把E:JavaSE目录下所有的以java结尾的文件的绝对路径给输出在控制台。
 * 
 * 分析：
 *         A:把 E:\JavaSE 封装成一个File对象
 *         B:获取该目录下所有文件或者文件夹的File数组
 *         C:遍历该File数组，得到每一个File对象
 *         D:判断该File对象是否是文件夹
 *             是：回到B(递归)
 *             否：继续判断是否以.java结尾
 *                 是：就输出该文件的绝对路径
 *                 否：不搭理它
 */
public class FilePathDemo {
    public static void main(String[] args) {
        // 把 E:\JavaSE 封装成一个File对象
        File srcFolder = new File("E:\JavaSE");

        // 递归功能实现
        getAllJavaFilePaths(srcFolder);
    }

    private static void getAllJavaFilePaths(File srcFolder) {
        // 获取该目录下所有文件或者文件夹的File数组
        File[] fileArray = srcFolder.listFiles();

        // 遍历该File数组，得到每一个File对象
        for (File file : fileArray) {
            // 判断该File对象是否是文件夹
            if (file.isDirectory()) {
                // 是：回到B(递归)
                getAllJavaFilePaths(file);
            } else {
                // 继续判断是否以.java结尾
                if (file.getName().endsWith(".java")) {
                    // 是：就输出该文件的绝对路径
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
    
}

        D:递归删除带内容的目录(小心使用)

package cn.itcast_03;

import java.io.File;

/*
 * 需求：递归删除带内容的目录
 * 
 * 目录我已经给定：demo
 * 
 * 分析：
 *         A:把 demo 封装成一个File对象
 *         B:获取该目录下的所有文件或者文件夹的File数组
 *         C:遍历该File数组，得到每一个File对象
 *         D:判断该File对象是否是文件夹
 *             是：回到B
 *             否：就删除
 */
public class FileDeleteDemo {
    public static void main(String[] args) {
        // 把 demo 封装成一个File对象
        File srcFolder = new File("demo");
        // 递归实现
        deleteFolder(srcFolder);
    }

    private static void deleteFolder(File srcFolder) {
        // 获取该目录下的所有文件或者文件夹的File数组
        File[] fileArray = srcFolder.listFiles();

        if (fileArray != null) { // 增强for的目标fileArray不能为null，否则会抛出空指针异常，那么我们加一个判断即可。
            // 删文件
            // 遍历该File数组，得到每一个File对象
            for (File file : fileArray) {
                // 判断该File对象是否是文件夹
                if (file.isDirectory()) {
                    // 是：回到B(递归)
                    deleteFolder(file);
                } else {
                    System.out.println(file.getName() + "---" + file.delete());
                }
            }

            // 删文件夹，srcFolder最开始是aaa，之后是bbb，之后是demo
            System.out.println(srcFolder.getName() + "---" + srcFolder.delete());
        }
    }
}

-----------------------------------------------------------------------------
2:IO流字节流(掌握)
    (1)IO流概述
        IO流用来处理设备之间的数据传输。
            上传文件和下载文件
        Java对数据的操作是通过流的方式。
        Java用于操作流的对象都在java.io包中。
    (2)IO流的分类
        A:按照数据流向分(以java程序为参考)
            输入流    读取数据    
            输出流    写出数据    
        B:按照数据类型为
            字节流    
                字节输入流        InputStream(抽象类)
                字节输出流        OutputStream(抽象类)
            字符流(为了方便操作文本数据)
                字符输入流        Reader(抽象类)
                字符输出流        Writer(抽象类)
        注意：
            a:如果我们没有明确说明按照什么分，默认按照数据类型分。
            b:除非文件用windows自带的记事本打开我们能够读懂，才采用字符流，否则建议使用字节流。
            c:如果你什么都不知道，就用字节流。
---------------------------------------
    (3)FileOutputStream写出数据(字节输出流)
        A:字节输出流的操作步骤
            a:创建字节输出流对象
            b:调用write()方法，写出数据
            c:释放资源
            
        B:代码体现：
            FileOutputStream fos = new FileOutputStream("fos.txt"); // 该构造方法会抛出一个异常 FileNotFoundException，上课为了代码一致性，throws抛给main函数了。
            
            fos.write("hello".getBytes()); // 该write()方法会抛出一个异常 IOException，上课为了代码一致性，throws抛给main函数了。
            
            fos.close(); // 该close()方法会抛出一个异常 IOException，上课为了代码一致性，throws抛给main函数了。

        C:要注意的问题?
            a:创建字节输出流对象做了几件事情？
                1:调用系统功能去创建文件。
                2:创建字节输出流对象。
                3:把字节输出流对象指向这个文件。
                
            b:为什么一定要close()？
                1:让流对象变成垃圾，这样就可以被垃圾回收器回收了。
                2:通知系统去释放跟该文件相关的资源。(很重要)
                
            c:如何实现数据的换行？
                不同的系统针的换行符号是不一样的！
                    windows系统:

                    linux系统:

                    Mac系统:

                而一些常见的高级记事本，是可以自动识别任意换行符号的。
                
            d:如何实现数据的追加写入？
                使FileOutputStream类的构造方法的第二个参数为true即可。
                    FileOutputStream fos = new FileOutputStream("fos3.txt", true);
                    
                注意：
                    // 下面两句代码等价，常用第一种方式。
                    FileOutputStream fos = new FileOutputStream("fos3.txt");
                    FileOutputStream fos = new FileOutputStream("fos3.txt", false);
                    
        D:字节流写数据的方式
            public void write(int b) 一次写一个字节
            public void write(byte[] b) 一次写一个字节数组
            public void write(byte[] b, int off, int len) 一次写一个字节数组的一部分
        E:字节流写数据加入异常处理
            示例代码如下：

package cn.itcast_01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 加入异常处理的字节输出流操作
 */
public class FileOutputStreamDemo4 {
    public static void main(String[] args) {
        // 分开做异常处理，代码的可读性差
//        FileOutputStream fos = null; // 局部变量，引用数据类型，需要初始化为null。为什么呢？按理说 fos = new FileOutputStream("fos4.txt"); 这一句就可以初始化了啊？
//        try { // 编译期异常，因为编译的时候，我不知道try里面有什么语句(编译只检查语法)，只有运行的时候才知道try里面有什么，如果这句前面有一句抛出异常，则就不会执行到这一句了。fos 就不能初始化了。
//            fos = new FileOutputStream("fos4.txt"); 
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        }
//        
//        try {
//            fos.write("java".getBytes());
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//
//        try {
//            fos.close();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

        // 一起做异常处理，代码的可读性增强了
//        try {
//            FileOutputStream fos = new FileOutputStream("fos4.txt");
//            fos.write("java".getBytes());
//            fos.close();
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

        // 改进版
        // 上面的close()方法可能会执行不到，所以把close()方法放在finally里面
        // 为了在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()；fos是null，说明该对象没有new成功，你还close()谁啊！！！
            if (fos != null) {
                // 为了保证close()一定会执行，就放到这里了
                try {
                    fos.close(); // 该close()方法也会抛出一个异常 IOException
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }
}

---------------------------------------
    (4)FileInputStream读取数据(字节输入流)
        A:字节输入流的操作步骤
            a:创建字节输入流对象
            b:调用read()方法，读取数据
            c:释放资源
            
        B:代码体现：
            FileInputStream fis = new FileInputStream("fos.txt"); // 该构造方法会抛出一个异常 FileNotFoundException，上课为了代码一致性，throws抛给main函数了。
            
            // 方式1
            int by = 0; // 这个赋值为0可要可不要 
            while ((by = fis.read()) != -1) {
                System.out.print((char) by); // 把int值转为字符(char)
            }
            
            // 方式2
            // 数组的长度一般是1024或者1024的整数倍
            byte[] bys = new byte[1024];
            int len = 0; // 这个赋值为0可要可不要
            while ((len = fis.read(bys)) != -1) {
                System.out.print(new String(bys, 0, len)); // 把一个字节数组的一部分转成字符串
            }
            
            fis.close(); // 该close()方法会抛出一个异常 IOException，上课为了代码一致性，throws抛给main函数了。
            
            注意：虽然我们有两种方式可以读取数据，但是，请注意，这两种方式在一个代码中针对同一个对象只能使用一种方式。
        
        C:要注意的问题?
            a:由上面方式一可知：如果使用字节输入流读取的文件中有中文字符，那么读取到文件就会出现乱码，为什么呢？
                因为我们把每一个读取到的中文都人为地转成一个char(字符)了。而输出的时候也是一个一个字节的输出(不会默认的做转换)，所以就出现了乱码。
                
            b:计算机是如何识别什么时候该把两个字节转换为一个中文呢?(windows默认GBK编码)
                在计算机中中文的存储分两个字节：
                    第一个字节肯定是负数。
                    第二个字节常见的是负数，可能有正数。但是没影响。
                    
                UTF-8编码：最多用三个字节来表示一个字符。
                GBK编码：一个中文二个字节表示。
                
        D:字节流读取数据的方式
            public int read()    一次读取一个字节
                返回值是下一个数据字节，如果已到文件末尾，则返回-1。
            public int read(byte[] b) 一次读取一个字节数组
                返回值是实际读取的字节个数，如果已到文件末尾，则返回-1。
---------------------------------------
    (5)案例：2种方式实现
        A:复制文本文件
            把 c盘下的a.txt 的内容复制到 d盘下的b.txt 中
        B:复制图片
            把 e:\林青霞.jpg 复制到 当前项目目录下的mn.jpg 中
        C:复制视频
            把 e:\哥有老婆.mp4 复制到 当前项目目录下的copy.mp4 中
    (6)字节缓冲区流
        字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果。
        java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流。
        也即带缓冲区的字节类，这种类被称为：缓冲区类(高效类)。
        java.lang.Object
            |--java.io.OutputStream(抽象类：输出流)
                |--java.io.FilterOutputStream(具体类：过滤输出流)
                    |--java.io.BufferedOutputStream(具体类：字节缓冲输出流)
            A:字节缓冲输出流(写出数据)
                BufferedOutputStream
            B:字节缓冲输入流(读取数据)
                BufferedInputStream
        注意事项：
            a:缓冲区类的构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认的缓冲区大小就足够了。
                public BufferedOutputStream(OutputStream out)
                public BufferedOutputStream(OutputStream out, int size)
            b:为什么构造方法不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
                原因很简单，字节缓冲区流仅仅提供缓冲区的作用，为高效而设计的。但是呢，到底我的这个缓冲区作用能否发挥出来，真正的读写操作还得靠基本的流对象来实现。
                即：到底我的这个缓冲区作用能否发挥出来，还得靠基本的流对象来实现。
                也即：BufferedOutputStream是水杯，OutputStream是水(抽象的水)，水有很多种：可乐、雪碧、矿泉水等。
            c:虽然我们有两种方式可以读取数据，但是，请注意，这两种方式在一个代码中针对同一个对象只能使用一种方式。
---------------------------------------
    (7)案例：4种方式实现
        A:复制文本文件
　　　　　　  把 c盘下的a.txt 的内容复制到 d盘下的b.txt 中
        B:复制图片
　　　　　　  把 e:\林青霞.jpg 复制到 当前项目目录下的mn.jpg 中
        C:复制视频
　　　　　　  把 e:\哥有老婆.mp4 复制到 当前项目目录下的copy.mp4 中

package cn.itcast_06;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把 e:\哥有老婆.mp4 复制到 当前项目目录下的copy.mp4 中
 * 
 * 字节流四种方式复制文件：
 *         基本字节流一次读写一个字节            共耗时：117235毫秒
 *         基本字节流一次读写一个字节数组        共耗时：156毫秒
 *         高效字节流一次读写一个字节            共耗时：1141毫秒
 *         高效字节流一次读写一个字节数组        共耗时：47毫秒
 */
public class CopyMp4Demo {
    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();
    }
}

-----------------------------------------------------------------------------        
3:IO流字符流(自学)

　　IO流分类：(抽象类的有标注)
　　　　字节流：
　　　　　　InputStream(抽象类)
　　　　　　　　|--FilterInputStream(字节过滤输入流)
　　　　　　　　　　|--BufferedInputStream(字节缓冲区输入流)
　　　　　　　　|--FileInputStream(字节输入流)
　　　　　　OutputStream(抽象类)
　　　　　　　　|--FilterOutputStream(字节过滤输出流)
　　　　　　　　　　|--BufferedOutputStream(字节缓冲区输出流)
　　　　　　　　|--FileOutputStream(字节输出流)

　　　　字符流：
　　　　　　Reader(抽象类)
　　　　　　　　|--FilterReader(抽象类:字符过滤输入流)
　　　　　　　　|--InputStreamReader(字符转换输入流)
　　　　　　　　　　|--FileReader(字符转换输入流的简化写法)
　　　　　　　　|--BufferedReader(字符缓冲区输入流)
　　　　　　Writer(抽象类)
　　　　　　　　|--FilterWriter(抽象类:字符过滤输出流)
　　　　　　　　|--OutputStreamWriter(字符转换输出流)
　　　　　　　　　　|--FileWriter(字符转换输出流的简化写法)
　　　　　　　　|--BufferedWriter(字符缓冲区输出流)

　　　　名称的变化：字符转换流(=字符流=转换流) ==> 字符转换简化流 ==> 字符流

=============================================================================