publicstaticvoidmain(String[] args) {
// 1.创建File对象(指定文件路径)// 路径写法// 反斜杠\ D:\360Downloads\modiloginbg.jpgFilef=newFile("D:\\360Downloads\\modiloginbg.jpg");
// 正斜杠/ D:/360Downloads/modiloginbg.jpg//        File f = new File("D:/360Downloads/modiloginbg.jpg");// API形式生成拼接符替代正(反)斜杠 File.separator 好处：跨平台，可以自动生成Windows、Linux等不同平台的拼接符//        File f = new File("D:" + File.separator + "360Downloads" + File.separator + "modiloginbg.jpg");longsize=f.length(); // 返回文件字节大小System.out.println(size); // 612265// 2.※File创建对象，支持绝对路径也支持相对路径// 绝对路径：从盘符开始Filef2=newFile("D:\\360Downloads\\214510.jpg");
System.out.println(f2.length()); // 363322// 相对路径：不带盘符，通常用来定义模块中的某个文件，相对于工程下的路径Filef3=newFile("day10_file_io_app\\src\\2055376.jpg");
System.out.println(f3.length()); // 777576// 3.File创建对象，可以是文件，也可以是文件夹Filef4=newFile("D:\\360Downloads");
//        System.out.println(f4.length()); // 一般不通过这种方式获取文件夹的大小System.out.println(f4.exists()); // true 判断该文件对象是否存在    }

publicstaticvoidmain(String[] args) throwsIOException {
Filef=newFile("day10_file_io_app\\src\\2055376.jpg");
//  1.public boolean createNewFile()    创建一个新的空的文件(几乎不用)System.out.println(f.createNewFile()); // falseFilef2=newFile("day10_file_io_app\\src\\2055376aaa.jpg");
System.out.println(f2.createNewFile()); // true//  2.public boolean mkdir()    只能创建一级文件夹Filef3=newFile("D:\\360Downloads\\abc");
System.out.println(f3.mkdir()); // trueFilef4=newFile("D:\\360Downloads\\abc\\def\\ghi");
System.out.println(f4.mkdir()); // false//  3.public boolean mkdirs()   可以创建多级文件夹Filef5=newFile("D:\\360Downloads\\abc\\def\\ghi");
System.out.println(f5.mkdirs()); // true//  4.public boolean delete ()  删除由此抽象路径名表示的文件或空文件夹(文件在被占用状态时也可以被删除)System.out.println(f2.delete()); // trueSystem.out.println(f3.delete()); // false 非空文件夹不可删除System.out.println(f5.delete()); // true 只能删除空文件夹    }

publicstaticvoidmain(String[] args) {
Filef1=newFile("D:\\360Downloads");
//  1.public String[] list()//  获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回String[] nameArray=f1.list();
System.out.println(Arrays.toString(nameArray));
// [2055376.jpg, 214510.jpg, abc, addlogin.jpg, bgpic5.jpg, loginbg.jpg, loginbg1.jpg, loginbg2.jpg, modiloginbg.jpg, Software, wpcache]//  2.public File[] listFiles()(常用)//  获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）File[] fileArray=f1.listFiles();
for (Filefile : fileArray) {
System.out.println(file.getAbsolutePath());
        }
/*D:\360Downloads\2055376.jpgD:\360Downloads\214510.jpgD:\360Downloads\abcD:\360Downloads\addlogin.jpgD:\360Downloads\bgpic5.jpgD:\360Downloads\loginbg.jpgD:\360Downloads\loginbg1.jpgD:\360Downloads\loginbg2.jpgD:\360Downloads\modiloginbg.jpgD:\360Downloads\SoftwareD:\360Downloads\wpcache*/    }

publicclassRecursionDemo1 {
publicstaticvoidmain(String[] args) {
// test(); // 进入死循环，栈内存溢出错误// test2(); // 进入死循环，栈内存溢出错误    }
// 直接递归publicstaticvoidtest() {
System.out.println("--------test执行--------");
test(); // 方法递归，直接递归    }
// 间接递归publicstaticvoidtest2() {
System.out.println("-------test2执行--------");
test3(); // 方法递归，间接递归    }
privatestaticvoidtest3() {
System.out.println("-------test3执行--------");
test2();
    }
}

publicclassRecursionDemo2 {
publicstaticvoidmain(String[] args) {
/*案例：递归案例导学-计算n的阶乘需求：计算n的阶乘的结果，使用递归思想解决，我们先从数学思维上理解递归的流程和核心点。分析：① 假如我们认为存在一个公式是 f(n) = 1*2*3*4*5*6*7*…(n-1)*n;② 那么公式等价形式就是： f(n) = f(n-1) *n③ 如果求的是 1-5的阶乘 的结果，手工应该应该如何应用上述公式计算。④ f(5) = f(4) * 5   f(4) = f(3) * 4 f(3) = f(2) * 3 f(2) = f(1) * 2 f(1) = 1*/System.out.println("5的阶乘是："+f(5)); // 5的阶乘是：120    }
publicstaticintf(intn) {
if (n==1) {
return1;
        } else {
returnf(n-1) *n;
        }
    }
}

publicclassRecursionDemo4 {
publicstaticvoidmain(String[] args) {
/*案例-猴子吃桃问题猴子第一天摘下若干桃子，当即吃了一半，觉得好不过瘾，于是又多吃了一个。第二天又吃了前天剩余桃子数量的一半，觉得好不过瘾，于是又多吃了一个。以后每天都是吃前天剩余桃子数量的一半，觉得好不过瘾，又多吃了一个。等到第10天的时候发现桃子只有1个了。 需求：请问猴子第一天摘了多少个桃子？ 分析：① 整体来看，每一天都是做同一个事件，典型的规律化问题，考虑递归三要素：② 递归公式：f(n) = 2 * (f(n + 1) + 1)③ 递归终结点：f(10) = 1④ 递归方向：n不断增大，向10靠拢，合理。*/System.out.println("第一天摘下"+eat(1) +"个桃子"); // 第一天摘下1534个桃子    }
publicstaticinteat(intn) {
if (n==10) {
return1;
        } else {
return (eat(n+1)  +1 ) *2;
        }
    }
}

publicclassRecursionDemo5 {
publicstaticvoidmain(String[] args) {
// 需求：去D盘搜索2055376.jpg文件searchFile(newFile("D:/"), "2055376.jpg");
/*文件存在，路径名称：D:\360Downloads\2055376.jpg文件存在，路径名称：D:\sss2055376.jpg*/    }
/*** create by: 全聚德在逃烤鸭、* description: 搜索某个目录下的所需文件* create time: 2022/6/3 0003 15:50** @param dir      查询目录* @param fileName 被搜索的文件名称* @return void*/publicstaticvoidsearchFile(Filedir, StringfileName) {
// 判断是否是文件夹if (dir!=nul&&dir.isDirectory()) {
File[] fileArray=dir.listFiles();
// 判断文件数组中是否不为null且有内容(数组为null时，增强for循环报错空值异常)if (fileArray!=nul&&fileArray.length>0) {
for (Filefile : fileArray) {
// 判断是否是文件if (file.isFile()) { // 是文件，判断是否是被搜索的文件if (file.getName().contains(fileName)) {
System.out.println("文件存在，路径名称："+file.getAbsolutePath());
                        }
                    } else { // 否则为文件夹，调用递归方法searchFile继续向下搜索searchFile(file, fileName);
                    }
                }
            }
        } else {
System.out.println("当前搜索的位置不是文件夹！");
        }
    }
}

publicclassRecursionDemo6 {
// 定义静态变量，代表买酒的数目，每轮买酒后增加publicstaticinttotalNumber;
publicstaticintlastBottleNumber; // 上轮剩余的空瓶数publicstaticintlastCoverNumber; // 上轮剩余的瓶盖数publicstaticvoidmain(String[] args) {
// 需求：需求：啤酒2元1瓶，4个盖子可以换一瓶，2个空瓶可以换一瓶，请问10元钱可以喝多少瓶酒，剩余多少空瓶和盖子// 答案：15瓶 3盖子 1瓶子buyBeer(10); // 可以喝15瓶酒，剩余1个空瓶，3个瓶盖    }
publicstaticvoidbuyBeer(intmoney) {
intbuyNumber=money/2;
// 判断剩余的钱是否可以买酒if (buyNumber==0) { // 若不能买酒，则退出并输出相应信息System.out.println("可以喝"+totalNumber+"瓶酒，剩余"+lastBottleNumber+"个空瓶，"+lastCoverNumber+"个瓶盖");
return;
        }
totalNumber+=buyNumber; // 更新买酒的数目// 统计本轮空瓶与瓶盖总数intbottleNumber=lastBottleNumber+buyNumber;
intcoverNumber=lastCoverNumber+buyNumber;
// 统计可以换算的用于买酒的钱intallMoney=money-buyNumber*2;
// 空瓶相当于1元一瓶，满两瓶可买一瓶啤酒，相当于2元allMoney+= (bottleNumber/2) *2; // 若不满2瓶，则无法购买，因此需要保留lastBottleNumber / 2lastBottleNumber=bottleNumber%2; // 更新本轮剩余空瓶数，用于下一轮买酒// 瓶盖相当于0.5元一个，满四个可买一瓶啤酒，相当于2元allMoney+= (coverNumber/4) *2; // 若不满4个，则无法购买，因此需要保留lastCoverNumber / 4lastCoverNumber=coverNumber%4; // 更新本轮剩余瓶盖瓶数，用于下一轮买酒// 调用递归方法，进行下一轮买酒buyBeer(allMoney);
    }
}

publicclassRecursionDemo7 {
// 定义静态变量，代表买酒的数目，每轮买酒后增加publicstaticinttotalNumber;
publicstaticvoidmain(String[] args) {
// 需求：需求：啤酒2元1瓶，4个盖子可以换一瓶，2个空瓶可以换一瓶，请问10元钱可以喝多少瓶酒，剩余多少空瓶和盖子// 答案：15瓶 3盖子 1瓶子buyBeer(10, 0, 0); // 可以喝15瓶酒，剩余1个空瓶，3个瓶盖    }
publicstaticvoidbuyBeer(intmoney, intlastBottleNumber, intlastCoverNumber) {
intbottleNumber=lastBottleNumber; // 本轮剩余空瓶数目intcoverNumber=lastCoverNumber; // 本轮剩余瓶盖数目// 金额足够用钱买酒，钱不够了用空瓶、瓶盖换酒// 判断剩余金额是否足够买酒if (money>=2) {
intbuyNumber=money/2;
totalNumber+=buyNumber; // 更新买酒的数目money-=buyNumber*2; // 更新剩余金额// 更新当前剩余空瓶、瓶盖数目bottleNumber+=buyNumber;
coverNumber+=buyNumber;
        } else {
if (bottleNumber>=2) {
intbuyNumber=bottleNumber/2; // 空瓶换购啤酒数目totalNumber+=buyNumber; // 更新买酒的数目// 更新当前剩余空瓶、瓶盖数目bottleNumber=bottleNumber%2+buyNumber;
coverNumber+=buyNumber;
            }
if (coverNumber>=4) {
intbuyNumber=coverNumber/4; // 瓶盖换购啤酒数目totalNumber+=buyNumber; // 更新买酒的数目// 更新当前剩余空瓶、瓶盖数目bottleNumber+=buyNumber;
coverNumber=coverNumber%4+buyNumber;
            }
        }
// 调用递归方法，进行下一轮买酒if (money>=2||bottleNumber>=2||coverNumber>=4) { // 若满足下一轮买酒条件则继续，否则结束买酒buyBeer(money, bottleNumber, coverNumber);
        } else {
System.out.println("可以喝"+totalNumber+"瓶酒，剩余"+bottleNumber+"个空瓶，"+coverNumber+"个瓶盖");
        }
    }
}

publicclassTest {
publicstaticvoidmain(String[] args) throwsUnsupportedEncodingException {
// 1.编码   把文字转换为字节(可以使用指定编码)Stringname="abc我爱你中国";
byte[] bytes=name.getBytes(); // 以当前代码默认字符集进行编码(当前默认UTF-8)// 英文、数字在UTF-8字符集中为正数，汉字为负数System.out.println(Arrays.toString(bytes)); // [97, 98, 99, -26, -120, -111, -25, -120, -79, -28, -67, -96, -28, -72, -83, -27, -101, -67]System.out.println(bytes.length); // 18// 指定编码(字符集)为GBKbyte[] bytes2=name.getBytes("GBK");
System.out.println(Arrays.toString(bytes2)); // [97, 98, 99, -50, -46, -80, -82, -60, -29, -42, -48, -71, -6]System.out.println(bytes2.length); // 13// 2.解码 把字节转换为文字(编码前和编码后的字符集必须一致，否则出现乱码)Stringrs=newString(bytes); // 以当前代码默认字符集进行解码(当前默认UTF-8)System.out.println(rs); // abc我爱你中国// 指定解码(字符集)为GBKStringrs2=newString(bytes2, "GBK");
System.out.println(rs2); // abc我爱你中国    }
}

publicstaticvoidmain(String[] args) throwsException {
// 1.创建一个文件字节输入流管道与源文件接通InputStreamis=newFileInputStream("day10_file_io_app\\src\\data.txt");
// 读取第一个字节返回intb1=is.read();
System.out.println(b1); // 97   字符编号System.out.println((char) b1); // a  转为字符型intb2=is.read();
System.out.println(b2); // 98System.out.println((char) b2); // bintb3=is.read();
System.out.println(b3); // 99System.out.println((char) b3); // c// 如果字节已经没有可读的返回-1intb4=is.read();
System.out.println(b4); // -1    }

publicstaticvoidmain(String[] args) throwsException {
// 1.创建一个文件字节输入流管道与源文件接通InputStreamis=newFileInputStream("day10_file_io_app\\src\\data2.txt");
// 2.定义一个字节数组，用于读取字节数组中的数据byte[] buffer=newbyte[3]; // 每次最多读取3B的数据intnumber=is.read(buffer);
System.out.println("读取了几个字节："+number); // 读取了几个字节：3// 解码 把字节转换为文字Stringrs=newString(buffer);
System.out.println(rs); // abcintnumber2=is.read(buffer);
System.out.println("读取了几个字节："+number2); // 读取了几个字节：3Stringrs2=newString(buffer);
System.out.println(rs2); // 我intnumber3=is.read(buffer);
System.out.println("读取了几个字节："+number3); // 读取了几个字节：2// String rs3 = new String(buffer);// System.out.println(rs3); // 12�/*第28行后，此时字节数组buffer没有清空，其中存储的是代表汉字"我"的三个字节，再次进行读取时，仅能读取2个字节，因此将"12"代表的2个字节存入至buffer的前2位中第3位仍为代表汉字"我"的3个字节中的第3位，因此乱码*/// 改进   读取多少数据，转换多少数据Stringrs3=newString(buffer, 0, number3); // 指定开始位置与解码长度System.out.println(rs3); // 12// 如果字节已经没有可读的返回-1intnumber4=is.read(buffer);
System.out.println("读取了几个字节："+number4); // 读取了几个字节：-1    }

publicstaticvoidmain(String[] args) throwsException {
Filef=newFile("day10_file_io_app\\src\\data3.txt");
InputStreamis=newFileInputStream(f);
// 获取文件大小并强转为int型intlength= (int) f.length();
byte[] buffer=newbyte[length];
intnumber=is.read(buffer);
System.out.println("读取了多少字节:"+number); // 读取了多少字节:139System.out.println("文件大小:"+f.length() +"字节"); // 文件大小:139字节Stringrs=newString(buffer);
System.out.println(rs);
/*abc我12dsadasd撒大声地所多sdggabc我12dsadasd撒大声地所多sdggabc我12dsadasd撒大声地所多s的dggsfSDAS是RQ示范法123*/    }

publicclassFileOutputStreamDemo4 {
publicstaticvoidmain(String[] args) throwsException {
// 1.创建一个文件字节输出流管道与目标文件接通//        OutputStream os = new FileOutputStream("day10_file_io_app\\output04.txt"); // 写路径，自动创建路径中的文件(会先清空之前的数据，再将新数据写入)OutputStreamos=newFileOutputStream("day10_file_io_app\\output04.txt", true); // 追加数据，不会先清空之前的数据//        public void write(int a)  写一个字节出去os.write('a');
os.write(98);
//        public void write(byte[] buffer)  写一个字节数组出去byte[] buffer= {'a', 97, 98};
os.write(buffer);
os.write("\r\n".getBytes()); // 换行byte[] buffer2="我爱你中国".getBytes();
os.write(buffer2);
//        public void write(byte[] buffer , int pos , int len)  写一个字节数组的一部分出去byte[] buffer3= {'d', 58, 28, 39};
os.write(buffer3, 0, 3); // 将buffer数组中第0位开始的前3位写入到文件中// 刷新流，写数据必须刷新数据os.flush();
// 用完后一定要关闭流，释放资源(关闭流中包含刷新流)os.close();
    }
}

publicclassFileCopyDemo05 {
publicstaticvoidmain(String[] args) {
try {
// 1.创建一个字节输入流管道与原文件接通InputStreamis=newFileInputStream("E:\\录屏\\学生作业相关知识学习.mp4");
// 2.创建一个字节输出流管道与目标文件接通OutputStreamos=newFileOutputStream("C:\\Users\\Administrator\\Desktop\\CopyMp4.mp4"); // 一定要加上目标文件名// 3.定义一个字节数组，用于文件复制byte[] buffer=newbyte[1024]; // 每次读取1kb的数据// 不能用此种方式，每次循环is.read(buffer)输入流执行了两次，需要定义变量来记录读取长度/* while (is.read(buffer) != -1) {os.write(buffer, 0, is.read(buffer)); // 读多少倒多少}*/// 定义变量记录读取的字节数intlen;
while ((len=is.read(buffer)) !=-1) {
os.write(buffer, 0, len); // 读多少倒多少            }
System.out.println("复制结束");
// 切记关闭流os.close(); // 一般从里向外关is.close();
        } catch (FileNotFoundExceptione) {
e.printStackTrace();
        } catch (IOExceptione) {
e.printStackTrace();
        }
    }
}

publicstaticvoidmain(String[] args) throwsException {
// 1.创建一个字符输入流管道与源文件接通Readerr=newFileReader("day10_file_io_app\\src\\data3.txt");
// 2.每次读取一个字符返回，如果字符已经没有可读的返回-1intcode=r.read();
// 打印第一个字符对应的字符集(UTF-8)编码System.out.println(code); // 25105// 将字符集(UTF-8)编码转换为对应的字符System.out.println((char) code); // 我    }

publicstaticvoidmain(String[] args) throwsException {
Readerr=newFileReader("day10_file_io_app\\src\\data3.txt");
char[] buffer=newchar[3]; // 每次读取三个字符intlen; // 定义变量记录读取字符数while ((len=r.read(buffer)) !=-1) {
// 将数组内容以字符串形式拼接起来System.out.print(newString(buffer, 0, len)); // 读取多少拼接多少        }
    }

publicstaticvoidmain(String[] args) {
// 创建一个文件字符输出流管道与目标文件接通try (
//                Writer w = new FileWriter("day10_file_io_app\\src\\data_out.txt")Writerw=newFileWriter("day10_file_io_app\\src\\data_out.txt", true); // 不清空原文件数据，在其基础上添加数据        ) {
w.write("\r\n"); // 换行// 1.void write(int c)  写一个字符w.write(97);
w.write('a');
w.write('中');
// 2.void write(char[] buffer)  写入一个字符数组char[] chars="abc我爱你北京".toCharArray();
w.write(chars);
// 3.void write(char[] buffer, int pos, int len)    写入字符数组的一部分w.write(chars, 1, 5); // len代表字符数// 4.void write(String str) 写一个字符串w.write("123我爱你中国");
// 5.void write(String str, int pos, int len)   写一个字符串的一部分w.write("123我爱你中国", 3, 5);
        } catch (IOExceptione) {
e.printStackTrace();
        }
    }