IO-5

浅浅的花香味﹌ 2022-07-29 10:53 159阅读 0赞

**IO-5**

**01\_File类递归练习(统计该文件夹大小)**

\* 需求:1,从键盘接收一个文件夹路径,统计该文件夹大小

public class Test1 \{

\* 从键盘接收一个文件夹路径

\* 1,创建键盘录入对象

\* 2,定义一个无限循环

\* 3,将键盘录入的结果存储并封装成File对象

\* 4,对File对象判断

\* 5,将文件夹路径对象返回

\* 统计该文件夹大小

\* 1,定义一个求和变量

\* 2,获取该文件夹下所有的文件和文件夹listFiles();

\* 3,遍历数组

\* 4,判断是文件就计算大小并累加

\* 5,判断是文件夹,递归调用

publicstatic void main(String\[\] args) \{

//Filedir = new File("F:\\\\day06");

//System.out.println(dir.length());  //直接获取文件夹的结果是0

Filedir = getDir();

System.out.println(getFileLength(dir));

\* 从键盘接收一个文件夹路径

\* 1,返回值类型File

\* 2,参数列表无

publicstatic File getDir() \{

//1,创建键盘录入对象

Scannersc = new Scanner(System.in);

System.out.println("请输入一个文件夹路径:");

//2,定义一个无限循环

while(true)\{

//3,将键盘录入的结果存储并封装成File对象

Stringline = sc.nextLine();

File dir = new File(line);

//4,对File对象判断

if(!dir.exists())\{

System.out.println("您录入的文件夹路径不存在,请输入一个文件夹路径:");

\}elseif(dir.isFile()) \{

System.out.println("您录入的是文件路径,请输入一个文件夹路径:");

\}else\{

//5,将文件夹路径对象返回

returndir;

\}                 \}        \}

\* 统计该文件夹大小

\* 1,返回值类型long

\* 2,参数列表File dir

publicstatic long getFileLength(File dir) \{        //dir= F:\\day06\\day07

//1,定义一个求和变量

longlen = 0;

//2,获取该文件夹下所有的文件和文件夹listFiles();

File\[\]subFiles = dir.listFiles();   //day07Demo1\_Student.clas Demo1\_Student.java

//3,遍历数组

for(File subFile : subFiles) \{

//4,判断是文件就计算大小并累加

if(subFile.isFile())\{

len= len + subFile.length();

//5,判断是文件夹,递归调用

\}else\{

len= len + getFileLength(subFile);

returnlen;

**02\_File类递归练习(删除该文件夹)**

\* 需求:2,从键盘接收一个文件夹路径,删除该文件夹

public class Test2 \{

\* 分析:

\* 1,获取该文件夹下的所有的文件和文件夹

\* 2,遍历数组

\* 3,判断是文件直接删除

\* 4,如果是文件夹,递归调用

\* 5,循环结束后,把空文件夹删掉

publicstatic void main(String\[\] args) \{

Filedir = Test1.getDir();  //获取文件夹路径,注意点!!!

deleteFile(dir);   //注意:无返回值类型只能单独调用,不能赋值调用!!!

if(!dir.exists()) \{

System.out.println("删除成功!");

\* 删除该文件夹

\* 1,返回值类型 void

\* 2,参数列表File dir

publicstatic void deleteFile(File dir) \{

//1,获取该文件夹下的所有的文件和文件夹

File\[\]subFiles = dir.listFiles();

//2,遍历数组

for(File subFile : subFiles) \{

//3,判断是文件直接删除

if(subFile.isFile())\{

subFile.delete();

//4,如果是文件夹,递归调用

\}else\{

deleteFile(subFile);

//5,循环结束后,把空文件夹删掉

dir.delete();

\}     \}

**03 File类递归练习(拷贝)**

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

public class Test3 \{

\* 分析:

\* 1,在目标文件夹中创建原文件夹

\* 2,获取原文件夹中所有的文件和文件夹,存储在File数组中

\* 3,遍历数组

\* 4,如果是文件就用io流读写

\* 5,如果是文件夹就递归调用

publicstatic void main(String\[\] args) throws IOException \{

Filesrc = Test1.getDir();

File dest = Test1.getDir();

if(src.equals(dest))\{

System.out.println("目标文件夹是源文件夹的子文件夹");

\}else\{

copy(src,dest);

\* 把其中一个文件夹中(包含内容)拷贝到另一个文件夹中

\* 1,返回值类型void

\* 2,参数列表File src,Filedest

publicstatic void copy(File src, File dest) throws IOException \{

//1,在目标文件夹中创建原文件夹

FilenewDir = new File(dest, src.getName());

newDir.mkdir();

//2,获取原文件夹中所有的文件和文件夹,存储在File数组中

File\[\]subFiles = src.listFiles();

//3,遍历数组

for(File subFile : subFiles) \{

//4,如果是文件就用io流读写

if(subFile.isFile())\{

BufferedInputStreambis = new BufferedInputStream(new FileInputStream(subFile));

BufferedOutputStreambos =

newBufferedOutputStream(new FileOutputStream(new File(newDir,subFile.getName())));

intb;

while((b= bis.read()) != -1) \{

bos.write(b);

bis.close();

bos.close();

//5,如果是文件夹就递归调用

\}else\{

copy(subFile,newDir);

\}    \}   \}   \}

**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

public class Test4 \{

\* 分析:

\* 1,获取所有文件和文件夹,返回的File数组

\* 2,遍历数组

\* 3,无论是文件还是文件夹,都需要直接打印

\* 4,如果是文件夹,递归调用

publicstatic void main(String\[\] args) \{

Filedir = Test1.getDir();                              //获取文件夹路径

printLev(dir,0);

publicstatic void printLev(File dir,int lev) \{

//1,把文件夹中的所有文件以及文件夹的名字按层级打印

File\[\]subFiles = dir.listFiles();

//2,遍历数组

for(File subFile : subFiles) \{

for(inti = 0; i <= lev; i++) \{

System.out.print("\\t");

//3,无论是文件还是文件夹,都需要直接打印

System.out.println(subFile);

//4,如果是文件夹,递归调用

if(subFile.isDirectory())\{

//printLev(subFile,lev+ 1);

printLev(subFile,++lev);  //不能用++lev或lev++!!!

\}  \} \}  \}

**05\_递归练习(斐波那契数列)**

\* 不死神兔

\* 故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契。

\* 在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，一年内没有发生死亡，

\* 问：一对刚出生的兔子，一年内繁殖成多少对兔子?

\* 1 1 2 3 5 8 13

\* 第一个月一对小兔子                                               1

\* 第二个月一对大兔子                                               1

\* 第三个月一对大兔子生了一对小兔子              2

\* 第四个月一对大兔子生了一对小兔子

\*                一对小兔子长成大兔子                          3

\* 第五个月两对大兔子生两对小兔子

\*                一对小兔子长成大兔子                          5

public class Test5 \{

\*1 = fun(1)

\*1 = fun(2)

\*2 = fun(1) + fun(2)

\*3 = fun(2) + fun(3)

publicstatic void main(String\[\] args) \{

//demo1();

System.out.println(fun(8));

publicstatic void demo1() \{

//用数组做不死神兔

int\[\]arr = new int\[8\];

//数组中第一个元素和第二个元素都为1

arr\[0\]= 1;

arr\[1\]= 1;

//遍历数组对其他元素赋值

for(inti = 2; i < arr.length; i++) \{

arr\[i\]= arr\[i - 2\] + arr\[i - 1\];

//如何获取最后一个数

System.out.println(arr\[arr.length- 1\]);

\* 用递归求斐波那契数列

publicstatic int fun(int num) \{

if(num== 1 || num == 2) \{

return1;

\}else\{

returnfun(num - 2) + fun(num - 1);

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

\* 需求:求出1000的阶乘所有零和尾部零的个数,不用递归做

public class Test6 \{

\*  需求:求出1000的阶乘所有零和尾部零的个数,不用递归做

publicstatic void main(String\[\] args) \{

/\*intresult = 1;

for(inti = 1; i <= 1000; i++) \{

result= result \* i;

System.out.println(result);               //因为1000的阶乘远远超出了int的取值范围

\*/

//demo1();

demo2();

publicstatic void demo2() \{               //获取1000的阶乘尾部有多少个零

BigIntegerbi1 = new BigInteger("1");

for(inti = 1; i <= 1000; i++) \{

BigIntegerbi2 = new BigInteger(i+"");

bi1= bi1.multiply(bi2);     //将bi1与bi2相乘的结果赋值给bi1

Stringstr = bi1.toString();        //获取字符串表现形式

StringBuildersb = new StringBuilder(str);

str= sb.reverse().toString();   //链式编程

intcount = 0;                                         //定义计数器

for(inti = 0; i < str.length(); i++) \{

if('0'!= str.charAt(i)) \{

break;

\}else\{

count++;

System.out.println(count);

publicstatic void demo1() \{               //求1000的阶乘中所有的零

BigIntegerbi1 = new BigInteger("1");

for(inti = 1; i <= 1000; i++) \{

BigIntegerbi2 = new BigInteger(i+"");

bi1= bi1.multiply(bi2);     //将bi1与bi2相乘的结果赋值给bi1

Stringstr = bi1.toString();        //获取字符串表现形式

intcount = 0;

for(inti = 0; i < str.length(); i++) \{

if('0'== str.charAt(i)) \{      //如果字符串中出现了0字符

count++;                              //计数器加1

System.out.println(count);

\-------------------------------------------------------------------------------------------------

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

BigIntegerbi1 = new BigInteger("1");

for(inti = 1; i <= 1000; i++) \{

BigIntegerbi2 = new BigInteger(i+"");

bi1= bi1.multiply(bi2);     //将bi1与bi2相乘的结果赋值给bi1

Stringstr = bi1.toString();        //获取字符串表现形式

char\[\] ch =str.toCharArray();

intcount = 0;

\*//1000的阶乘共有多少0!!!

/\*for(inti = 0; i < ch.length; i++) \{

if('0'== ch\[i\]) \{  //如果字符串中出现了0字符

count++;                              //计数器加1

System.out.println(count);\*/

\*//1000的阶乘尾部共有多少个0!!!

for(inti = ch.length-1; i >=0; i--) \{

if('0'== ch\[i\]) \{  //如果字符串中出现了0字符

count++;                              //计数器加1

\}else\{

break;

System.out.println(count);

**07\_递归练习(1000的阶乘尾部零的个数)**

\* 需求:求出1000的阶乘尾部零的个数,用递归做

public class Test7 \{

publicstatic void main(String\[\] args) \{

System.out.println(fun(1000));

publicstatic int fun(int num) \{

if(num> 0 && num < 5) \{

return0;

\}else\{

returnnum / 5 + fun(num / 5);

**08\_集合练习(约瑟夫环)**

\* 幸运数字

public class Test8 \{

publicstatic void main(String\[\] args) \{

System.out.println(getLucklyNum(8));

\* 获取幸运数字

\* 1,返回值类型int

\* 2,参数列表int num

publicstatic int getLucklyNum(int num) \{

ArrayList<Integer>list = new ArrayList<>();     //创建集合存储1到num的对象

for(inti = 1; i <= num; i++) \{

list.add(i);                  //将1到num存储在集合中

intcount = 1;             //用来数数的,只要是3的倍数就杀人

for(inti = 0; list.size() != 1; i++) \{               //只要集合中人数超过1,就要不断的杀

if(i== list.size()) \{               //如果i增长到集合最大的索引+1时

i= 0;                   //重新归零

if(count% 3 == 0) \{     //如果是3的倍数

list.remove(i--);        //就杀人

count++;

returnlist.get(0);

IO-5

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 ios入门5_循环

相关 ios传值给js_iOS h5和iOS原生交互,h5和iOS互相传值

相关 IO-5

相关 5种IO模型、阻塞IO和非阻塞IO、同步IO和异步IO

相关 iOS5 Automatic Reference Counting

相关 Linux5大IO模型

相关 5-01 Java IO编程

相关 IOS 5 ARC机制（三）

相关 iOS国际化(Xcode5)

相关 Commons IO 2.5-IOUtils