2019 . 05.29 23：36
23.01_File类递归练习(统计该文件夹大小)
需求:1,从键盘接收一个文件夹路径,统计该文件夹大小
需求:从键盘接收一个文件夹路径，统计文件夹大小 *从键盘接收一个文件夹路径 *1，创建键盘录入对象 *2，定义一个无限循环 *3，将键盘录入结果存储并封装为一个File对象 *4，对File对象判断 *5，将文件夹路径对象返回 *统计文件夹大小 *1，定义一个求和变量 *2，获取文件夹下的所有文件和文件夹listFiles() *3，遍历File数组 *4，判断是文件就计算大小并累加 *5，判断是文件夹，递归调用 ###23.02_File类递归练习(删除该文件夹)
package com.heima.test;
import java.io.File;
import java.util.Scanner;
public class File_Size {
public static void main(String[] args) {
File dir = getDir();
long len = getSize(dir);
System.out.println("文件夹的大小为：" + len);
}
public static File getDir()
{ //1，创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件夹路径：");
//2，定义一个无限循环
while(true) {
//3，将键盘录入结果存储并封装位一个File对象
String line = sc.nextLine();
File dir = new File(line);
if(!dir.exists()) {
System.out.println("您录入的路径不存在！");
}else if(dir.isFile()) {
System.out.println("您录入的是文件路径！");
}else {
return dir;
}
}
}
public static long getSize(File dir)
{ //1，定义一个求和变量
long len = 0;
//2，获取文件夹下的所有文件和文件夹listFiles()
File subFiles[] = dir.listFiles();
//3，遍历File数组
for (File subFile : subFiles) {
if(subFile.isFile()) {
//4，判断是文件就计算大小并累加
len = len + dir.length();
}else {
//5，判断是文件夹，递归调用
len = len + getSize(subFile);
}
}
return len;
}
}
需求:2,从键盘接收一个文件夹路径,删除该文件夹
需求，从键盘接收一个文件路径，删除文件夹 删除文件夹： 分析：返回类型void 参数列表File dir 1,获取该文件夹下的所有的文件和文件夹 2，遍历文件数组 3，判断是文件就直接删除 4，如果是文件就递归调用 5，循环结束后，把空文件夹删除
package com.heima.test;
import java.io.File;
/*
* 需求，从键盘接收一个文件路径，删除文件夹
*
* 删除文件夹：
* 分析：返回类型void 参数列表File dir
* 1,获取该文件夹下的所有的文件和文件夹
* 2，遍历文件数组
* 3，判断是文件就直接删除
* 4，如果是文件就递归调用
* 5，循环结束后，把空文件夹删除
*/
public class test2 {
public static void main(String[] args) {
File dir = File_Size.getDir(); //获取文件夹路径
deleteFile(dir);
}
public static void deleteFile(File file) {
//1,获取该文件夹下的所有文件和文件夹
File[] subFiles = file.listFiles();
//2，遍历数组
for (File file2 : subFiles) {
//3，判断是文件就直接删除
if(file2.isFile()) {
file2.delete();
//4，如果是文件就递归调用
}else {
deleteFile(file2);
}
}
//5，循环结束后，把空文件夹删除
file.delete();
}
}
23.03_File类递归练习(拷贝)
需求:3,从键盘接收两个文件夹路径,把其中一个文件夹中(包含内容)拷贝到另一个文件夹中
package com.heima.test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
需求:3,从键盘接收两个文件夹路径,把其中一个文件夹中(包含内容)拷贝到另一个文件夹中
从键盘接收两个文件夹路径
1,键盘录入源文件夹路径喝目标文件夹路径（test01中的方法）
2,判断两个文件夹是否相同,相同则违反文件系统规则,不是则调用复制函数
3,获取源文件夹中所有的文件和文件夹
4,将其存储到file数组中
5,遍历数组
6,如果是文件就用io流读写文件（i o流只能读写文件）
7,如果是文件夹就递归调用复制函数
*/
public class test03 {
public static void main(String[] args) throws IOException {
// 1,键盘录入源文件夹路径喝目标文件夹路径（test01中的方法）
System.out.println("请输入一个源文件夹路径：");
File src = File_Size.getDir();
System.out.println("请输入一个目标文件夹路径：");
File dest = File_Size.getDir();
if(src.equals(dest)) {
System.out.println("源文件夹和目标文件夹一样，输入错误！");
}else {
copy(src,dest);
}
}
/*
* copy函数：将一个源文件中的所有文件夹和内容拷贝到另外一个文件夹中
1,在目标文件中创建源文件夹
2,获取源文件夹中所有的文件和文件夹，存储在FIle数组中
3,遍历数组
4,如果是文件则进行拷贝,是文件夹则进行递归调用
5,
*/
private static void copy(File src, File dest) throws IOException {
//1,在目标文件中创建源文件夹
File newDir = new File(dest,src.getName());
newDir.mkdir();
//2,获取源文件夹中所有的文件和文件夹，存储在FIle数组中
File[] subFile = src.listFiles();
//3,遍历数组
for (File file : subFile) {
//4,如果是文件则进行拷贝
if(file.isFile()) {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
BufferedOutputStream bos =
new BufferedOutputStream(new FileOutputStream(new File(newDir,file.getName())));
int b ;
while((b = bis.read())!= -1) {
bos.write(b);
}
bis.close();
bos.close();
//是文件夹则进行递归调用
} else {
copy(file,newDir);
}
}
}
}
###23.04_File类递归练习(按层级打印)
需求:4,从键盘接收一个文件夹路径,把文件夹中的所有文件以及文件夹的名字按层级打印, 例如: aaa是文件夹,里面有bbb.txt,ccc.txt,ddd.txt这些文件,有eee这样的文件夹,eee中有fff.txt和ggg.txt,打印出层级来 aaa bbb.txt ccc.txt ddd.txt
eee
fff.txt
ggg.txt
package com.heima.test;
import java.io.File;
/*
需求：从键盘接收一个文件夹路径,把文件夹中的所有文件以及文件夹的名字按层级打印
分析：
1，调用text1中的getDir()方法
2，获取文件夹的所有的子文件和文件夹到一个File数组
3，遍历数组，输出元素的路径名字
4，如果是文件夹就递归调用
*/
public class test04 {
public static void main(String[] args) {
// 1，调用text1中的getDir()方法
File dir = File_Size.getDir();
//调用print函数进行打印文件路径名
print(dir,0);
}
public static void print(File dir,int lev) {
//2，获取文件夹的所有的子文件和文件夹到一个File数组
File[] subFiles = dir.listFiles();
// 3，遍历数组，输出元素的路径名字
for (File subfile : subFiles) {
for(int i = 0 ; i <= lev; i++) {
System.out.print("\t");
}
System.out.println(subfile);
if(subfile.isDirectory()) {
print(subfile, lev+1);
}
}
}
}
结果图：print(subfile, lev+1);
结果图：print(subfile, lev++); 因为lev++修改了lev 这个变量lev本身
23.05_递归练习(斐波那契数列)
不死神兔故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契。在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，一年内没有发生死亡，问：一对刚出生的兔子，一年内繁殖成多少对兔子?1 1 2 3 5 8 13第一个月一对小兔子 1第二个月一对大兔子 1第三个月一对大兔子生了一对小兔子 2第四个月一对大兔子生了一对小兔子 一对小兔子长成大兔子 3
第五个月两对大兔子生两对小兔子 一对小兔子长成大兔子 5
package com.heima.test;
import java.util.Scanner;
/*
需求：不死神兔:斐波那契数列
数组实现：
1，arr[0] = 1 arr[1] = 1 arr[2] = 2
2,if(i >=2) arr[i] = arr[i-1] + arr[i-2],else arr[i] = 1
递归实现
1，if fun(i) 中 i==1 或者i==2 ,return 1
2，else return fun(i-1) + fun(i-2)
*/
public class test05 {
public static void main(String[] args) {
//demo1();
int num;
System.out.println("请输入月份：");
Scanner sc = new Scanner(System.in);
num = sc.nextInt();
int result = fun(num);
System.out.println(result);
}
public static int fun(int i) {
if(i == 1 || i==2) {
return 1;
}else {
return fun(i-1) + fun(i-2);
}
}
private static void demo1() {
int[] arr = new int[12];
arr[0] = 1;
arr[2] = 1;
for(int i = 2 ; i < arr.length; i++) {
arr[i] = arr[i-1] + arr[i-2];
}
for (int i : arr) {
System.out.print(i + " ");
}
}
}
23.06_递归练习(1000的阶乘所有零和尾部零的个数)
需求:求出1000的阶乘所有零和尾部零的个数,不用递归做
package com.heima.test;
import java.math.BigInteger;
/*
需求:求出1000的阶乘所有零和尾部零的个数,不用递归做
1，用int进行递归不行，则会溢出
2，用bigInteger 接收字符串
*/
public class test06 {
public static void main(String[] args) {
demo1();
//阶层的结束是1
BigInteger bi1 = new BigInteger("1");
for(int i = 1; i <= 1000; i++) {
BigInteger bi2 = new BigInteger(i + "");
bi1 = bi1.multiply(bi2);
}
//获取结果的的字符串形式
String s = bi1.toString();
StringBuilder sb = new StringBuilder(s);
s = sb.reverse().toString();
int count = 0;
for(int i = 0; i < s.length();i++) {
if('0'!=s.charAt(i))
break;
count++;
}
System.out.println("count2 = "+ count);
}
private static void demo1() {
//阶层的结束是1
BigInteger bi1 = new BigInteger("1");
for(int i = 1; i <= 1000; i++) {
BigInteger bi2 = new BigInteger(i + "");
bi1 = bi1.multiply(bi2);
}
//获取结果的的字符串形式
String s = bi1.toString();
int count = 0;
for(int i = 0; i < s.length();i++) {
if('0'==s.charAt(i))
count++;
}
System.out.println("count1 = "+ count);
}
}
23.07_递归练习(1000的阶乘尾部零的个数)
需求:求出1000的阶乘尾部零的个数,用递归做
package com.heima.test;
import java.util.Scanner;
/*
需求:求出1000的阶乘尾部零的个数,用递归做
1, 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 ....10000
一个5的倍数乘以一个偶数会出现一个0 1000 / 5 = 200
2, 25 50 75 100 125 150 ...
在这两百个特殊的数上每5个数再乘以一个偶数会出现两个0 200 / 5 = 40
3， 125 250 375 500 625 ...
在这40个特殊数上的每5个数再乘以一个偶数，会出现三个0 40 / 5 = 8
4，625 在这8个特殊数上的每5个数再乘以一个偶数 ，会出现四个0 8 / 5 = 1
设计递归函数：fun
返回值类型：int
参数：整型的 number
1,if number > 0 && number < 5 返回0 结束函数
2，else return number / 5 + fun(number /5) 执行递归调用
*/
public class text07 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("please in an Integer betweem 0 to 32767 :");
int number = sc.nextInt();
System.out.println("the number of zero of Integer is ：" + fun(number));
}
private static int fun(int number) {
if(number > 0 && number < 5) {
return 0;
}else {
return number / 5 + fun(number / 5);
}
}
}
23.08_集合练习(约瑟夫环)
幸运数字`package com.heima.test;
import java.util.ArrayList; import java.util.Scanner;
/*
约瑟夫杯 ： 幸运数字 （让一群人围成一个圈，从第一个人开始数，遇到3的倍数就杀掉一个人，剩下的最后一个人的位置就是幸运数字） 1,返回类型 int 2，参数： 一个 int 参数 3，先根据参数将多个数组添加到list容器中 4，从第一个位置（小标0）开始遍历 for循环 5，遇到3的倍数的位置就删除这个元素，将后续的元素往前移动一位，并将循环变量-1 6,继续数，直到 list中的元素只剩一个就结束循环 7，返回幸运数字 */ public class test08 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.print(“please in an Integer betweem 0 to 32767 :”); int number = sc.nextInt(); System.out.println(“the number of ziro of Integer is ：” + getLucklyNumber(number)); }
private static int getLucklyNumber(int number) { ArrayList list = new ArrayList<>(); //创建list对象 for(int i = 1; i <= number; i++) { list.add(i); } int count = 1; for(int i = 0 ; list.size() != 1; i++) { //只要集合中超过两个人就继续杀人 if(i==list.size()) { //实现围成一个圈 i = 0; } if(count % 3 == 0) { list.remove(i–); //将后续元素往前移动一位后要把计数位置往前移动一位 } count ++; } return list.get(0); } } `
