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

 1 package cn.itcast_02;
 2 
 3 /*
 4  * 需求：请用代码实现求5的阶乘。
 5  * 下面的知识要知道：
 6  *         5! = 1*2*3*4*5
 7  *         5! = 5*4!
 8  * 
 9  * 有几种方案实现呢?
10  *         A:循环实现
11  *         B:递归实现
12  *             a:做递归要写一个方法
13  *             b:出口条件(就是已知的条件，比如题目所给的条件或者自然定理、常识等)
14  *             c:规律
15  */
16 public class DiGuiDemo {
17     public static void main(String[] args) {
18         // 循环实现
19         int jc = 1;
20         for (int x = 2; x <= 5; x++) {
21             jc *= x;
22         }
23         System.out.println("5的阶乘是：" + jc);
24 
25         // 递归实现
26         System.out.println("5的阶乘是：" + jieCheng(5));
27     }
28     
29     /*
30      * 做递归要写一个方法:
31      *         返回值类型：int
32      *         参数列表：int n
33      * 出口条件:(就是已知的条件，比如题目所给的条件或者自然定理、常识等)
34      *         if (n == 1) {
35      *             return 1;
36      *         }
37      * 规律:
38      *         if (n != 1) {
39      *             return n*方法名(n-1);
40      *         }
41      */
42     // 递归实现
43     public static int jieCheng(int n) {
44         if (n == 1) {
45             return 1;
46         } else {
47             return n * jieCheng(n - 1);
48         }
49     }
50 }

 1 package cn.itcast_02;
 2 
 3 /*
 4  * 不死神兔问题(裴波那切数列问题)
 5  * 
 6  * 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
 7  * 
 8  * 分析：我们要想办法找规律
 9  * 
10  *             兔子对数
11  * 第一个月：     1
12  * 第二个月：    1
13  * 第三个月：    2    (老兔子生了一对兔子)
14  * 第四个月：    3    (老兔子又生了一对兔子)
15  * 第五个月：    5    (老兔子又又生了一对兔子，小兔子生了一对兔子)
16  * 第六个月：    8   (老兔子又又又生了一对兔子，小兔子又生了一对兔子)
17  * ......
18  * 
19  * 由此可见兔子对象的数据是：
20  *         1,1,2,3,5,8......
21  * 规律：
22  *         A:从第三项开始，每一项是前两项之和。
23  *         B:说明前两项是已知的。
24  * 
25  * 如何实现这个程序呢?有三种方式：
26  *         A:数组实现
27  *         B:变量的变化实现
28  *         C:递归实现
29  * 
30  * 假如相邻的两个月的兔子对数是a,b
31  *         第一个相邻的数据：a=1,b=1
32  *         第二个相邻的数据：a=1,b=2
33  *         第三个相邻的数据：a=2,b=3
34  *         第四个相邻的数据：a=3,b=5
35  *         第五个相邻的数据：a=5,b=8
36  *         ......
37  * 规律：
38  *         下一次的a是以前的b，下一次的b是以前的a+b    
39  */
40 public class DiGuiDemo2 {
41     public static void main(String[] args) {
42         // 数组实现
43         // 定义一个数组
44         int[] arr = new int[20];
45         // 前两项是已知的
46         arr[0] = 1;
47         arr[1] = 1;
48         // 从第三项开始，每一项是前两项之和。
49         // arr[2] = arr[0] + arr[1];
50         // arr[3] = arr[1] + arr[2];
51         // ......
52         for (int x = 2; x < arr.length; x++) {
53             arr[x] = arr[x - 2] + arr[x - 1];
54         }
55         System.out.println(arr[19]); // 6765
56         System.out.println("----------------");
57 
58         // 变量的变化实现
59         int a = 1;
60         int b = 1;
61         for (int x = 0; x < 18; x++) { // 这里的循环只控制次数，变量x不参与运算。循环1次得到的b是2(相当于第三个月)，循环2次得到的b是3(相当于第四个月)......循环18次得到的b是6765(相当于第二十个月)
62             // 临时变量存储上一次的a
63             int temp = a;
64             a = b; // 下一次的a是以前的b
65             b = temp + b; // 下一次的b是以前的a+b
66         }
67         System.out.println(b); // 6765
68         System.out.println("----------------");
69 
70         // 递归实现
71         System.out.println(fib(20));
72     }
73 
74     /*
75      * 方法： 返回值类型：int 参数列表：int n 
76      * 出口条件： 第一个月是1，第二个月是1 
77      * 规律： 从第三个月开始，每一个月是前两个月之和
78      */
79     public static int fib(int n) {
80         if (n == 1 || n == 2) {
81             return 1;
82         } else {
83             return fib(n - 1) + fib(n - 2);
84         }
85     }
86 }

 1 package cn.itcast_03;
 2 
 3 import java.io.File;
 4 
 5 /*
 6  * 需求：请大家把E:\JavaSE目录下所有的以java结尾的文件的绝对路径给输出在控制台。
 7  * 
 8  * 分析：
 9  *         A:把 E:\\JavaSE 封装成一个File对象
10  *         B:获取该目录下所有文件或者文件夹的File数组
11  *         C:遍历该File数组，得到每一个File对象
12  *         D:判断该File对象是否是文件夹
13  *             是：回到B(递归)
14  *             否：继续判断是否以.java结尾
15  *                 是：就输出该文件的绝对路径
16  *                 否：不搭理它
17  */
18 public class FilePathDemo {
19     public static void main(String[] args) {
20         // 把 E:\\JavaSE 封装成一个File对象
21         File srcFolder = new File("E:\\JavaSE");
22 
23         // 递归功能实现
24         getAllJavaFilePaths(srcFolder);
25     }
26 
27     private static void getAllJavaFilePaths(File srcFolder) {
28         // 获取该目录下所有文件或者文件夹的File数组
29         File[] fileArray = srcFolder.listFiles();
30 
31         // 遍历该File数组，得到每一个File对象
32         for (File file : fileArray) {
33             // 判断该File对象是否是文件夹
34             if (file.isDirectory()) {
35                 // 是：回到B(递归)
36                 getAllJavaFilePaths(file);
37             } else {
38                 // 继续判断是否以.java结尾
39                 if (file.getName().endsWith(".java")) {
40                     // 是：就输出该文件的绝对路径
41                     System.out.println(file.getAbsolutePath());
42                 }
43             }
44         }
45     }
46     
47 }

 1 package cn.itcast_03;
 2 
 3 import java.io.File;
 4 
 5 /*
 6  * 需求：递归删除带内容的目录
 7  * 
 8  * 目录我已经给定：demo
 9  * 
10  * 分析：
11  *         A:把 demo 封装成一个File对象
12  *         B:获取该目录下的所有文件或者文件夹的File数组
13  *         C:遍历该File数组，得到每一个File对象
14  *         D:判断该File对象是否是文件夹
15  *             是：回到B
16  *             否：就删除
17  */
18 public class FileDeleteDemo {
19     public static void main(String[] args) {
20         // 把 demo 封装成一个File对象
21         File srcFolder = new File("demo");
22         // 递归实现
23         deleteFolder(srcFolder);
24     }
25 
26     private static void deleteFolder(File srcFolder) {
27         // 获取该目录下的所有文件或者文件夹的File数组
28         File[] fileArray = srcFolder.listFiles();
29 
30         if (fileArray != null) { // 增强for的目标fileArray不能为null，否则会抛出空指针异常，那么我们加一个判断即可。
31             // 删文件
32             // 遍历该File数组，得到每一个File对象
33             for (File file : fileArray) {
34                 // 判断该File对象是否是文件夹
35                 if (file.isDirectory()) {
36                     // 是：回到B(递归)
37                     deleteFolder(file);
38                 } else {
39                     System.out.println(file.getName() + "---" + file.delete());
40                 }
41             }
42 
43             // 删文件夹，srcFolder最开始是aaa，之后是bbb，之后是demo
44             System.out.println(srcFolder.getName() + "---" + srcFolder.delete());
45         }
46     }
47 }

 1 package cn.itcast_06;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.FileInputStream;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 
 9 /*
10  * 需求：把 e:\\哥有老婆.mp4 复制到 当前项目目录下的copy.mp4 中
11  * 
12  * 字节流四种方式复制文件：
13  *         基本字节流一次读写一个字节            共耗时：117235毫秒
14  *         基本字节流一次读写一个字节数组        共耗时：156毫秒
15  *         高效字节流一次读写一个字节            共耗时：1141毫秒
16  *         高效字节流一次读写一个字节数组        共耗时：47毫秒
17  */
18 public class CopyMp4Demo {
19     public static void main(String[] args) throws IOException {
20         long start = System.currentTimeMillis();
21         // method1("e:\\哥有老婆.mp4", "copy1.mp4");
22         // method2("e:\\哥有老婆.mp4", "copy2.mp4");
23         // method3("e:\\哥有老婆.mp4", "copy3.mp4");
24         method4("e:\\哥有老婆.mp4", "copy4.mp4");
25         long end = System.currentTimeMillis();
26         System.out.println("共耗时：" + (end - start) + "毫秒");
27     }
28 
29     // 高效字节流一次读写一个字节数组
30     public static void method4(String srcString, String destString) throws IOException {
31         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcString));
32         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString));
33 
34         byte[] bys = new byte[1024];
35         int len = 0;
36         while ((len = bis.read(bys)) != -1) {
37             bos.write(bys, 0, len);
38         }
39 
40         bos.close();
41         bis.close();
42     }
43 
44     // 高效字节流一次读写一个字节
45     public static void method3(String srcString, String destString) throws IOException {
46         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcString));
47         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString));
48 
49         int by = 0;
50         while ((by = bis.read()) != -1) {
51             bos.write(by);
52 
53         }
54 
55         bos.close();
56         bis.close();
57     }
58 
59     // 基本字节流一次读写一个字节数组
60     public static void method2(String srcString, String destString) throws IOException {
61         FileInputStream fis = new FileInputStream(srcString);
62         FileOutputStream fos = new FileOutputStream(destString);
63 
64         byte[] bys = new byte[1024];
65         int len = 0;
66         while ((len = fis.read(bys)) != -1) {
67             fos.write(bys, 0, len);
68         }
69 
70         fos.close();
71         fis.close();
72     }
73 
74     // 基本字节流一次读写一个字节
75     public static void method1(String srcString, String destString) throws IOException {
76         FileInputStream fis = new FileInputStream(srcString);
77         FileOutputStream fos = new FileOutputStream(destString);
78 
79         int by = 0;
80         while ((by = fis.read()) != -1) {
81             fos.write(by);
82         }
83 
84         fos.close();
85         fis.close();
86     }
87 }