黑马程序员JAVA编程阶梯：基础篇之第二十三章

【济南中心】JAVA编程阶梯：基础篇之第二十三章

?

File类递归练习（统计该文件夹大小）

从键盘接收一个文件夹路径,统计该文件夹大小 [Java] 纯文本查看 复制代码 ? 01 /**

02 * 从键盘接收一个文件夹路径,统计该文件夹大小 03 *

04 * @author Somnus 05 * 06 */

07 public class Demo { 08

09 public static void main(String[] args) {

10 System.out.println(\输入需要查看文件大小的路径\11 Scanner sc = new Scanner(System.in); 12 String file = sc.nextLine(); 13 sc.close();

14 long folderSize = getFolderSize(new File(file)); 15 System.out.println(\文件大小：\字节\16 }

黑马程序员济南中心 编著

17 18 /**

19 * 获取文件夹大小 20 *

21 * @param file 22 * File实例 23 * @return long 24 */

25 public static long getFolderSize(File file) { 26 long size = 0; 27 try {

28 File[] fileList = file.listFiles();

29 for (int i = 0; i < fileList.length; i++) { 30 if (fileList.isDirectory()) {

31 size = size + getFolderSize(fileList); 32

33 } else {

34 size = size + fileList.length(); 35 } 36 }

37 } catch (Exception e) { 38 e.printStackTrace();

黑马程序员济南中心 编著

39 }

40 return size; 41 } 42 }

?

File类递归练习(删除该文件夹)

从键盘接收一个文件夹路径,删除该文件夹 [Java] 纯文本查看 复制代码 ? 01 /**

02 * 删除一个带有内容的目录 03 *

04 * @author Somnus 05 * 06 */

07 public class Demo { 08

09 public static void main(String[] args) { 10 /*

11 * 思路: 1，删除一个带有内容的目录原理；必须从里往外删。 2，到底有多级目录不确定，递归12 */

黑马程序员济南中心 编著

13 System.out.println(\输入需要删除在文件目录\14 Scanner sc = new Scanner(System.in); 15 String file = sc.nextLine(); 16 sc.close();

17 File dir = new File(file); 18 removeDir(dir); 19 } 20 21 /**

22 * 删除一个目录。 23 */

24 public static void removeDir(File dir) { 25

26 // 1,列出当前目录下的文件以及文件夹File[]

27 File[] files = dir.listFiles();// 如果目录是系统级文件夹，java没有访问权限，那么会返回null数28 最好加入判断。

29 if (files != null) { 30 for (File file : files) {

31 // 2,对遍历到的file对象判断是否是目录。 32 if (file.isDirectory()) { 33 removeDir(file); 34 } else {

黑马程序员济南中心 编著

35 System.out.println(file + \删除文件。用打印语句验证是否删36 成功，是否出现了误删操作。 37 } 38 } 39 }

40 System.out.println(dir + \ } }

?

File类递归练习

从键盘接收两个文件夹路径,把其中一个文件夹中(包含内容)拷贝到另一个文件夹中 [Java] 纯文本查看 复制代码 ? 01 /**

02 * 从键盘接收两个文件夹路径,把其中一个文件夹中(包含内容)拷贝到另一个文件夹中 03 *

04 * 复制文件夹,首先需要想到递归.因为文件夹是一个层次目录. 1.需要判断是文件夹还是文件.是文件夹就递归05 文件就用流读写.

06 * 2.文件夹的命名和文件的命名两者都需要在旧文件名称和新文件路径命名

07 * .我们需要知道,当旧文件夹通过listFiles获得下一级文件时候,这时候,我们就要想到, 新文件夹和旧文件夹的08 径已经相差一级了. 09 * 10 *

黑马程序员济南中心 编著

11 * */

12 public class Demo {

13 private static Scanner sc; 14

15 public static void main(String[] args) throws IOException { 16 sc = new Scanner(System.in);

17 System.out.println(\请输入一个源文件夹路径\18 String str_oldFile = sc.nextLine();

19 System.out.println(\请输入一个目的文件夹路径\20 String str_newFile = sc.nextLine(); 21 sc.close();

22 File oldFile = new File(str_oldFile); 23 File newFile = new File(str_newFile); 24 MyCopy(oldFile, newFile); 25 } 26

27 public static void MyCopy(File oldFile, File newFile) throws IOException { 28 if (!oldFile.exists()) // 判断源文件是不是存在,如果不存在,声明. 29 {

30 System.out.println(\文件不存在\31 }

32 // 新的目录,加上旧的文件名.就成了一个新的文件.但是此时还没有具体文件.

黑马程序员济南中心 编著

33 File f = new File(newFile.getPath() + \34 System.out.println(\

35 f.mkdir(); // 创建新的文件夹 &&&重要的一部分.这里是建立一个具体的文件夹,此时新旧文件夹36 相同了.

37 File[] files = oldFile.listFiles(); // 列出旧文件夹里的所有文件. 38 for (File file : files) // 遍历这个文件夹里面的文件.. 39 {

40 if (file.isDirectory()) // 如果还是文件夹,就递归. 41 {

42 MyCopy(file, f);

43 } else // 否则就可以,用IO流来读写文件了. 44 {

45 BufferedInputStream bis = new BufferedInputStream( 46 new FileInputStream(file));

47 BufferedOutputStream bos = new BufferedOutputStream( 48 new FileOutputStream(f.getPath() + \49 + file.getName())); 50 int b = 0;

51 while ((b = bis.read()) != -1) { 52 bos.write(b); 53 }

54 bis.close();

黑马程序员济南中心 编著

55 bos.close();

56 System.out.println(file.getName() + \拷贝完成!\57 } } } }

?

File类递归练习(按层级打印)

从键盘接收一个文件夹路径,把文件夹中的所有文件以及文件夹的名字按层级打印, [Java] 纯文本查看 复制代码 ? 01 /**

02 * 从键盘接受一个字符串,这个字符串是一个文件目录. 将该目录中所有的文件打印在控制台上. 03 * 思路: 1.从键盘录入,得到一个字符串, 04 * 2.通过该字符串,创建一个文件夹,

05 * 3.将该文件夹进行遍历,如果是一个文件夹,那么就进行递归, 否则,就将文件名称打印在控制台. 06 * 07 * */

08 public class Demo {

09 public static void main(String[] args) { 10 SystemInFileName();

黑马程序员济南中心 编著

11 } 12

13 public static void SystemInFileName() { 14 Scanner sc = new Scanner(System.in); 15 while (true) {

16 System.out.println(\输入文件夹路径，注意不能是盘符根目录\17 String str = sc.nextLine(); 18 File fi = new File(str);

19 if (!fi.exists() && !fi.isDirectory()) {

20 System.out.println(\请输入正确的路径文件夹路径\21 } else {

22 System.out.println(\路径：\23 ListFile(fi); 24 } 25 } 26 } 27

28 public static void ListFile(File fi) { 29

30 File[] ff = fi.listFiles(); 31 for (File f : ff) {

32 if (f.isDirectory()) {

黑马程序员济南中心 编著

33 System.out.println(\文件夹：\34 ListFile(f); 35 } else {

36 System.out.println(f.getName()); 37 } 38 } 39 } 40 }

?

递归练习(斐波那契数列)

[Java] 纯文本查看 复制代码 ? 01 /**

02 * 假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对03 一年内没有发生死亡

04 * ， 问：一对刚出生的兔子，一年内繁殖成多少对兔子? 1 1 2 3 5 8 13 05 *

06 * @author Somnus 07 * 08 */

09 public class Demo {

黑马程序员济南中心 编著

10

11 private static int getFibo(int i) { 12 if (i == 1 || i == 2) 13 return 1; 14 else

15 return getFibo(i - 1) + getFibo(i - 2); 16 } 17

18 public static void main(String[] args) {

19 System.out.println(\一年内繁殖的兔子数：\20 for (int j = 1; j <= 12; j++) {

21 System.out.print(getFibo(j) + \22 if (j % 5 == 0)

23 System.out.println(); 24 } 25 } }

?

递归练习(1000的阶乘所有零和尾部零的个数)

需求:求出1000的阶乘所有零和尾部零的个数,不用递归做 [Java] 纯文本查看 复制代码 ?

黑马程序员济南中心 编著

01 /**

02 * 求出1000的阶乘所有零和尾部零的个数,不用递归做 因为1000的阶乘远远超出了int的取值范围所以要03 到大整数 04 *

05 * @author Somnus 06 * 07 */

08 public class Demo { 09

10 public static void main(String[] args) { 11 demo1();// 求1000的阶乘中所有的零 12 demo2();// 获取1000的阶乘尾部有多少个零 13 } 14

15 public static void demo1() {

16 BigInteger bigger1 = new BigInteger(\17 for (int i = 1; i <= 1000; i++) {

18 BigInteger bigger2 = new BigInteger(i + \

19 bigger1 = bigger1.multiply(bigger2); // 将bigger1与bigger2相乘的结果赋值给bigg20 }

21 String str = bigger1.toString(); // 获取字符串表现形式 22 int count = 0;

黑马程序员济南中心 编著

23 for (int i = 0; i < str.length(); i++) {

24 if ('0' == str.charAt(i)) { // 如果字符串中出现了0字符 25 count++; // 计数器加1 26 } 27 }

28 System.out.println(count); 29 } 30

31 public static void demo2() {

32 BigInteger bigger1 = new BigInteger(\33 for (int i = 1; i <= 1000; i++) {

34 BigInteger bigger2 = new BigInteger(i + \35 bigger1 = bigger1.multiply(bigger2); 36 }

37 String str = bigger1.toString();

38 StringBuilder sb = new StringBuilder(str); 39 str = sb.reverse().toString(); 40

41 int count = 0; // 定义计数器 42 for (int i = 0; i < str.length(); i++) { 43 if ('0' != str.charAt(i)) { 44 break;

黑马程序员济南中心 编著

45 } else { 46 count++; 47 } 48 } 49

50 System.out.println(count); 51 } }

?

递归练习(1000的阶乘尾部零的个数)

需求:求出1000的阶乘尾部零的个数,用递归做 [Java] 纯文本查看 复制代码 ? 01 /**

02 * 求出1000的阶乘尾部零的个数,用递归做 03 *

04 * @author Somnus 05 * 06 */

07 public class Demo { 08

黑马程序员济南中心 编著

09 public static void main(String[] args) {

10 System.out.println(getLastCount(getSum(1000))); 11 } 12

13 public static BigInteger getSum(int n) { 14 if (n == 1) {

15 return new BigInteger(\16 } else { 17

18 BigInteger sum = new BigInteger(n + \19 return sum.multiply(getSum(n - 1)); 20 } 21 } 22

23 public static int getLastCount(BigInteger sum) { 24 int count = 0;

25 String s = sum.toString();

26 StringBuffer sb = new StringBuffer(s); 27 String s1 = sb.reverse().toString(); 28 for (int i = 0; i < s1.length(); i++) { 29 if ('0' == s1.charAt(i)) { 30 count++;

黑马程序员济南中心 编著

31 } else { 32 break; 33 } 34 }

35 return count; 36 } 37 }

?

集合练习(约瑟夫环)

有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？ [Java] 纯文本查看 复制代码 ? 01 /**

02 * 分析： 有100个人围成一个圈，从1开始报数，报到14的这个人就要退出 然后其他人重新开始，从1报03 到14退出 04 *

05 * 思路:1.定义一个计数器每计数到14就删除掉报数的那个角标所对应的值,并把计数器值恢复初始值

06 * 2.接着还是在被删除的角标位置开始循环，为了还是在该角标循环那么可以将现在循环到的角标-1处理，它07 会在下次循环中+1，那么下次的 08 * 循环也就是在当前循环角标位置开始

黑马程序员济南中心 编著

09 * 3.因为是围成一个圈报数，所以当循环到末尾时又要从0角标开始，那么当报数到最后一个角标时，先处理10 有可能的删除动作然后判断

11 * 当前角标是否为最后一个角标，是的话赋值为-1，它还会在下次循环中+1，那么下次的 循环也就是0角标12 标位置又开始循环

13 * 4.最后还要判断集合的长度是否为1，因为要留最后一个人，这个人不能删，只要满足条件则结束循环并打14 集合中仅有的一个元素

15 * 那么该元素也就是100人当中的最后一个人 16 */

17 public class Demo { 18

19 public static void main(String[] args) { 20 // 集合里只能存储Integer类型数据

21 List al = new ArrayList(); 22 // 通过循环添加100个元素 23 for (int i = 1; i <= 100; i++) { 24 al.add(i); 25 } 26

27 // 定义一个计数器，这里赋值为1是为了记录0角标从1开始报数 28 int num = 1;

29 for (int y = 0; y < al.size(); y++) {

30 // 当计数器满足了14，即该角标就是报数为14的那个角标，然后删除该角标所对应的元素

黑马程序员济南中心 编著

31 if (num == 14) { 32 al.remove(y);

33 // 删除角标后计数器恢复到初始值 34 num = 1;

35 // 下一次内循环从当前角标开始 36 y = y - 1; 37 } else {

38 // 如果没有报数到14则加1让下一个元素接着报数 39 num++; 40 }

41 // 有剩下的人还是围成一个圈报数，报到最后一个人则下一个报数的应该是第一个人

42 // 那么报到最后一个人后，应该把循环角标再次调为0，这里赋值-1在上边会进行+1处理43 if (y == (al.size() - 1)) 44 y = -1;

45 // 如果参与报数的人剩下一个了那么就不用再去参与循环报数了，他就是最后剩下的那个人46 if (al.size() == 1) break; }

System.out.println(\最后剩下人的是100人中的第\个人\ } }

黑马程序员济南中心 编著

本文来源：https://www.bwwdw.com/article/28i5.html