目录
异常
异常体系介绍
异常代表程序出现的问题
学习异常的目的：程序出现异常后该如何处理
例如：
-
异常的体系
这里Error是错误，而Exception才是异常 -
Error：
代表的系统级别的错误（属于严重问题）
系统一旦出现问题，sun公司会把这些错误封装成Error对象，
开发人员不用管 -
Exception：
叫做异常，代表程序可能出现的问题
我们通常会用Exception以及他的子类来封装程序出现的问题
RuntimeException：运行时异常，编译阶段不会有提醒，运行时才会有
编译时异常：编译阶段有提醒
- 小结：
编译时异常和运行时异常
- 编译时异常
public static void main(String[] args)throws ParseException {
//下面这段代码如果不在上面的主方法上添加throws ParseException 就会报错
String time="2023-5-9";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Date d=sdf.parse(time);
System.out.println(d);
}
-
运行时异常
-
编译阶段
java文件到字节码文件
这是编译阶段
编译时异常主要是提醒程序员检查本地信息 -
运行阶段
从字节码文件到运行结果时运行阶段
运行时异常主要是代码出错导致的问题
扩展：编译时java不会运行代码，只会检查语法是否错误，或者做一些性能的优化
所有的异常都可以在api文档里找到
- 小结
异常的作用
作用一：异常是用来查询bug的关键信息
作用二：异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况
作用一的实现：
public static void main(String[] args) throws ParseException {
student []s=new student[3];
String name=s[0].getName();
System.out.println(name);
}
//报错信息
Exception in thread "main" //这一句表示异常在main中
java.lang.NullPointerException: //空指针异常
Cannot invoke "student.getName()" because "s[0]" is null
//不能运行student.getName()语句，因为s[0]不存在
at testOne.main(testOne.java:6)//异常所在代码的位置
注意：在看异常代码时，要从下往上看
作用二的实现：
- 不使用异常返回报错信息时
public void setAge(int age) {
if (age<18||age>30){
System.out.println("年龄过大");
}else {
this.age = age;
}
}
这时调用方法处执行代码后不会得到代码的执行情况，报错的信息在控制台输出
- 使用异常后
public void setAge(int age) {
if (age<18||age>30){
//这里的throw是抛出
throw new RuntimeException();
}else {
this.age = age;
}
}
public static void main(String[] args) throws ParseException {
student s=new student();
s.setAge(50);
}
//报错信息
Exception in thread "main" java.lang.RuntimeException
at student.setAge(student.java:49)
at testOne.main(testOne.java:6)
这时调用方法处执行代码后会得到代码的执行情况
异常的处理方式
有三种：
1.JVM默认处理
2.自己处理
3.抛出异常（交给调用者自己处理）
JVM默认处理
把异常的名称，异常原因，以及异常出现的位置输出在控制台
程序停止执行，下面的代码不会再执行了
public static void main(String[] args) throws ParseException {
System.out.println("111");
System.out.println(2/0);//会输出算数异常ArithmeticException
System.out.println("111");
System.out.println("111");
/* 输出结果
111
Exception in thread "main" java.lang.ArithmeticException: / by zero
at testOne.main(testOne.java:6)
* */
}
可以看到，异常后的程序都没有运行
自己处理（捕获异常）
捕获（核心思想）：不让程序停止
-
自己处理（捕获异常）的好处就是：
当代码出现异常时，可以让程序继续往下执行
-
格式：
try{
可能出现的异常代码
}catch(异常类名 变量名){
异常的处理代码(错误输出语句打印到控制台等)
}
例如
public static void main(String[] args) throws ParseException {
int []arr={1,2,3,4,5};
try{
System.out.println(arr[10]);
//代码执行过程
//上面的代码出现异常，创建一个ArrayIndexOutOfBoundsException对象
//然后catch会拿着这个对象与括号里的参数进行对比
//如果相同，就代表该异常可以被接收，代码被捕获，执行catch的代码
//catch代码执行完毕后，再执行后续代码
}catch (ArrayIndexOutOfBoundsException e){
System.out.println("索引越界异常");
}
System.out.println(111);
}
//控制台
索引越界异常
111
可以看到，catch里的代码执行，而且异常后的代码继续向下执行
捕获异常的一些问题
-
第一个问题：
如果try中没有异常（问题），怎么执行代码？
解答：
会把try中的代码全部执行，不执行catch中的代码，然后执行后续代码注意：只有出现异常才会执行catch的代码
public static void main(String[] args) throws ParseException {
int []arr={1,2,3,4,5};
try{
System.out.println(arr[0]);
}catch (ArrayIndexOutOfBoundsException e){
System.out.println("索引越界异常");
}
System.out.println(111);
}
//控制台输出
1
111
-
第二个问题
如果try中可能会遇到多个问题，怎么执行代码？
解答：
如果try中可能会遇到多个问题，那么就写多个对应的catch对应多个异常注意：如果捕获多个异常，且某些异常存在父子关系，那么，父类对应的catch一定要在最下面
public static void main(String[] args) throws ParseException {
int []arr={1,2,3,4,5};
try{
System.out.println(arr[10]);
System.out.println(2/0);
String s=null;
System.out.println(s.equals("abc"));
}catch (ArrayIndexOutOfBoundsException e){
System.out.println("索引越界异常");
}catch(ArithmeticException e){
System.out.println("算数异常");
}catch(NullPointerException e){
System.out.println("空指针异常");
}catch(Exception e){
System.out.println("父类异常在最下面");
}
}
jdk7以后，可以在catch中捕获多个异常，这些异常用
|隔开，不能用||，
这种处理方式表示：如果出现A和B异常的话，采取同一种处理方案
-
第三个问题
如果try中遇到的问题没有被捕获，怎么执行代码？
例如：public static void main(String[] args) throws ParseException { int []arr={1,2,3,4,5}; try{ System.out.println(arr[10]); }catch (NullPointerException e){//这里是空指针异常，与try里的异常不符合，所以没有捕获 System.out.println("索引越界异常"); } } //Exception in thread "main" //java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 5 //at testOne.main(testOne.java:7)解答：
还是返回到虚拟机处理，相当于自己处理的代码没用，返回到默认处理 -
第四个问题
如果try遇到了问题，那么try下面的其他代码还会执行吗？解答：
try中出问题下面的代码就不会执行了，会直接跳转到对应的catch中，执行catch里面的语句体，但是如果没有对应的catch对应，还是会交给虚拟机处理public static void main(String[] args) throws ParseException { int []arr={1,2,3,4,5}; try{ System.out.println(arr[10]); System.out.println("111");//这句就不会执行了 }catch (ArrayIndexOutOfBoundsException e){ System.out.println("索引越界异常"); } //输出结果 //索引越界异常 } -
小结
抛出处理（自己处理）
抛出（核心思想）：告诉调用者出错了
有两个关键字
throws和throw
-
throws:
写在方法定义处，表示声明一个异常。告诉调用者，使用本方法可能会有哪些异常格式：
public void 方法()throws 异常类名1，异常类名2...{ ... }注意：如果是编译时异常，必须要写上，如果是运行时异常，可以不写
-
throw
写在方法内，结束方法，手动抛出异常对象，交给调用者，方法中下面的代码不在执行了格式：
public void 方法(){ throw new 异常类名(); sout("111");//这句代码不执行 } -
例子：
public static void main(String[] args){ int []arr=null; //由于throw和throws会返回调用者，所以可以在这里进行捕获 try { System.out.println(getMax(arr)); } catch (NullPointerException e) { throw new RuntimeException(e); } catch (ArrayIndexOutOfBoundsException e) { throw new RuntimeException(e); } //但是下面求最大值的方法有个弊端，即当数组为null时， //数组没有元素，此时就会有异常 } public static int getMax(int []arr) throws NullPointerException,ArrayIndexOutOfBoundsException{ //throw if(arr==null){ //手动创建一个异常对象，并把这个异常交给方法的调用者进行处理 //此时方法就会结束，下面的代码就不会运行了 throw new NullPointerException(); } if(arr.length==0){ //手动创建一个异常对象，并把这个异常交给方法的调用者进行处理 //此时方法就会结束，下面的代码就不会运行了 throw new ArrayIndexOutOfBoundsException(); } System.out.println("我没运行"); int max=arr[0]; for (int i = 1; i < arr.length; i++) { if(max<arr[i]){ max=arr[i]; } } return max; } -
异常处理小结
异常的常见方法
Throwable的成员方法
| 方法名 | 说明 |
|---|---|
public String getMessage() | 返回throwable的详细信息字符串 |
public String toString() | 返回此可抛出的简短描述 |
public void printStackTrace() | 把异常的错误信息输出在控制台（以红色的字体） |
前两个不常用，了解就行，主要是第三个
ctrl+alt+t：可以选择语句块包裹着选中的代码
- getMessage
public static void main(String[] args){
int []arr={1,2,3,4,5};
try{
System.out.println(arr[10]);
}catch (ArrayIndexOutOfBoundsException e){
String message = e.getMessage();
System.out.println(message);
//Index 10 out of bounds for length 5
//1111
}
System.out.println("1111");
}
- toString
public static void main(String[] args){
int []arr={1,2,3,4,5};
try{
System.out.println(arr[10]);
}catch (ArrayIndexOutOfBoundsException e){
String message = e.toString();
System.out.println(message);
//java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 5
}
System.out.println("1111");
}
- printStackTrace
public static void main(String[] args){
int []arr={1,2,3,4,5};
try {
System.out.println(arr[10]);
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
}
System.out.println("你是？");
}
//你是？
//java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 5
// at testOne.main(testOne.java:5)
注意：printStackTrace会输出跟虚拟机一样的语句，但是不会停止虚拟机
java输出语句分为两种
输出正确的
System.out.println
输出错误的
System.err.println
输出错误的输出语句会在控制台将输出的字体改为红色
异常练习
抛出（核心思想）：告诉调用者出错了
捕获（核心思想）：不让程序停止
//GrilFriend类
//用来抛出
public void setName(String name)throws RuntimeException {
int len=name.length();
if(len<3||len>10){
throw new RuntimeException();
}
this.name = name;
}
public void setAge(int age) throws RuntimeException{
if(age<18||age>30){
throw new RuntimeException();
}
this.age = age;
}
//测试类
//用来捕获
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
GridFriend gf=new GridFriend();
while (true) {
try {
System.out.println("请输入姓名");
String name=sc.nextLine();
gf.setName(name);
System.out.println("请输入年龄");
String i=sc.nextLine();
int age = Integer.parseInt(i);
gf.setAge(age);
break;
}catch (NumberFormatException e){
System.out.println("输入的年龄格式有问题");
}catch (RuntimeException e) {
System.out.println("输入的名字或年龄超出范围");
}
}
System.out.println(gf);
}
自定义异常
- 自定义异常分为四步：
1.定义异常类：类名见名知意
2.写继承关系：编译异常直接继承Exception，运行异常继承RuntimeException
3.空参构造
4.带参构造
异常起名的技巧：
例如：NameFormatException
NameFormat：当前异常的名字，表示姓名格式化问题
Exception：表示当前类是一个异常类
- NameFormatException
public class NameFormatException extends RuntimeException {
public NameFormatException() {//空参构造
}
public NameFormatException(String message) {//带参构造
super(message);
}
}
- AgeOutOfBoundsException
public class AgeOutOfBoundsException extends RuntimeException{
public AgeOutOfBoundsException() {
}
public AgeOutOfBoundsException(String message) {
super(message);
}
}
- 上面练习的改进
//GrilFriend类
//用来抛出
public void setName(String name)throws RuntimeException {
int len=name.length();
if(len<3||len>10){
throw new NameFormatException(name+"：姓名出现问题");
}
this.name = name;
}
public void setAge(int age) throws RuntimeException{
if(age<18||age>30){
throw new AgeOutOfBoundsException(age+"：年龄范围出现问题");
}
this.age = age;
}
//测试类
//用来捕获
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
GridFriend gf=new GridFriend();
while (true) {
try {
System.out.println("请输入姓名");
String name=sc.nextLine();
gf.setName(name);
System.out.println("请输入年龄");
String i=sc.nextLine();
int age = Integer.parseInt(i);
gf.setAge(age);
break;
}catch (NumberFormatException e){
e.printStackTrace();
}catch (NameFormatException e) {
e.printStackTrace();
}catch (AgeOutOfBoundsException e){
e.printStackTrace();
}
}
System.out.println(gf);
}
//输出结果
/*NameFormatException: eeeeeeeeeee：姓名出现问题
at GridFriend.setName(GridFriend.java:28)
at testTwo.main(testTwo.java:12)*/
File
File的概念和构造方法
File：文件保存的路径，将文件保存在Flie所在的路径中，数据的传输用IO流
注意，File类只能对文件本身进行操作，不能读写文件里的数据
路径：
分为两种
- 相对路径（不带盘符）：a.txt 或abc\a.txt
- 绝对路径（带盘符）：C:\a.txt或C:\abc\a.txt
File：
-
File对象就表示一个路径，可以是文件的路径，也可以是文件夹的路径
-
这个路径是可以存在的，也可以不存在
-
常见的创建路径对象的方法：
| 方法名 | 说明 |
|---|---|
| public File(String pathname) | 根据文件路径创建文件对象 |
| public File(String parent,String child) | 根据父路径名字符串和子路径名字符串创建文件对象 |
| public File(File parent,String child) | 根据父路径对应文件对象和子路径名字符串创建文件对象 |
第二种和第三种方法就是把父级路径和子级路径进行拼接得到新的文件对象
父路径：父级路径，子路径：子级路径
例如：D:\\我的世界\\a1.txt,D:\我的世界 是 a1.txt 的父级路径
public static void main(String[] args) {
//File(String pathname)
String file="D:\\我的世界\\a1.txt";
File f1=new File(file);
System.out.println(f1);//这里的f1就是文件对象
///D:\我的世界\a1.txt
//File(String parent,String child)
String s1="D:\\我的世界";
String s2="a1.txt";
File f2=new File(s1,s2);
System.out.println(f2);
//D:\我的世界\a1.txt
//File(File parent,String child)
File f3=new File(s1);
File f4=new File(f3,s2);
System.out.println(f4);
//D:\我的世界\a1.txt
}
- 小结
Flie中常见的成员方法
跟判断和获取相关的方法
| 方法名 | 说明 |
|---|---|
| public boolean isDirectory() | 判断此路径名表示的File是否为文件夹 |
| public boolean isFile() | 判断此路径名表示的File是否为文件 |
| public boolean exists() | 判断此路径名表示的File是否存在 |
| public long length() | 返回文件的大小（字节数量） |
| public String getAbsolutePath() | 返回文件的绝对路径 |
| public String getPath() | 返回定义文件时使用的路径 |
| public String getName() | 返回文件的名称，带后缀 |
| public long lastModified() | 返回文件的最后修改时间（时间为毫秒值） |
- 判断的方法
//判断的方法
public static void main(String[] args) {
//对一个文件的路径进行判断
File f1=new File("D:\\我的世界\\a1.txt");
System.out.println(f1.isDirectory());
System.out.println(f1.isFile());
System.out.println(f1.exists());
//false
//true
//true
//对一个文件夹的路径进行判断
File f2=new File("D:\\我的世界\\one");
System.out.println(f2.isDirectory());
System.out.println(f2.isFile());
System.out.println(f2.exists());
//true
//false
//true
//对一个不存在的路径进行判断
File f3=new File("D:\\我的世界\\one.txt");
System.out.println(f3.isDirectory());
System.out.println(f3.isFile());
System.out.println(f3.exists());
//false
//false
//false
}
- 获取的方法
import java.io.File;
public class testThree {
public static void main(String[] args) {
//length，获取文件长度
//注意：这个方法只能获取文件的字节大小，无法获取文件夹的字节大小
//如果单位时M或G，可以把获取的字节大小不断的除以1024，
//如果想要获取文件夹的字节大小，需要把这个文件夹里的所以文件大小都加在一起
File f1=new File("D:\\我的世界\\a1.txt");
System.out.println(f1.length());//42
//getAbsolutePath,获取绝对路径
System.out.println(f1.getAbsolutePath());//D:\我的世界\a1.txt
File f2=new File("basic-code\\a.txt");
System.out.println(f2.getAbsolutePath());
//C:\Users\86158\IdeaProjects\basic-code\basic-code\a.txt
//getPath,返回定义文件对象时的路径
System.out.println(f1.getPath());
File f3=new File("basic-code\\a.txt");
System.out.println(f3.getPath());
//D:\我的世界\a1.txt
//basic-code\a.txt
//getName。获取名字
//注意：调用者如果是文件，那么就返回文件名加扩展后缀名，
// 调用者如果是文件夹，那么就返回文件夹名
System.out.println(f1.getName());
File f4=new File("D:\\我的世界\\one");
System.out.println(f4.getName());
//a1.txt
//one
//lastModified 返回文件的最后修改时间（时间为毫秒值）
System.out.println(f1.lastModified());
}
}
跟创建和删除相关的方法
| 方法名 | 说明 |
|---|---|
| public boolean createNewFile() | 创建一个空的文件 |
| public boolean mkdir() | 创建单级文件夹 |
| public boolean mkdirs() | 创建多级文件夹 |
| public boolean delete() | 删除文件，空文件夹 |
注意：delete方法默认只能删除文件和空文件夹，delete方法删除不经过回收站，直接删除
public static void main(String[] args) throws IOException {
//createNewFile,创建一个空的文件
//注意：如果当前路径表示的文件是不存在的，创建才会成功，方法返回true
// 如果当前路径表示的文件是存在的，创建会失败，方法返回false
// 如果父级路径是不存在的，那么方法会有异常IOException
// createNewFile方法创建的一定是文件，如果路径的文件中没有后缀名，就会创建一个没有后缀的文件
// 注意，使用
File f1=new File("D:\\我的世界\\a2.txt");
System.out.println(f1.createNewFile());//这里我的世界文件夹中没有a2.txt这个文件，所以会创建一个a2.txt
//运行一次后，再运行就会返回false
File f2=new File("D:\\我的世界\\a3");
//如果是不带后缀的，就会创建一个没有后缀的文件
System.out.println(f2.createNewFile());
//mkdir,创建文件夹
//注意：window中路径是唯一的，如果要创建的路径已经存在，则创建失败，返回false
//mkdir方法只能创建单级文件夹，不能创建多级文件夹
File f3=new File("D:\\我的世界\\abc");
System.out.println(f3.mkdir());
//mkdirs,创建多级文件夹
//mkdirs既可以创建单级文件夹，也可以创建多级文件夹
//所以，以后使用直接使用mkdirs就行了
File f4=new File("D:\\我的世界\\acc\\acd");
File f5=new File("D:\\我的世界\\tre");
System.out.println(f4.mkdirs());
System.out.println(f5.mkdirs());
//delete, 删除
//注意：如果删除的是文件和文件夹，直接就删除，且不经过回收站
//如果删除的是有内容的文件夹，则无法删除
f4.delete();//false
f5.delete();//true
}
跟获取和遍历相关的方法
只需要掌握下面这一个就行，其他的了解。
| 方法名 | 说明 |
|---|---|
| public File[ ] listFiles() | 获取当前路径下的所有内容，并放到一个数组中返回 |
liseFiles的注意事项：
- 当调用者File表示的路径不存在时，返回null
- 当调用者File表示的路径是文件而不是文件夹时，返回null
- 当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组
- 当调用者File表示的路径是一个有内容的文件夹时，将里面所有的文件和文件夹的路径放在File数组中返回
- 当调用者File表示的路径是一个有隐藏内容的文件夹时，将里面所有的文件和文件夹的路径放在File数组中返回，包含隐藏文件
- 当调用者File表示的路径是需要权限才能访问的文件夹时，返回null
public static void main(String[] args) {
File f=new File("D:\\我的世界\\abc");
File[] files = f.listFiles();
for (File file : files) {
System.out.println(file);
}
//D:\我的世界\abc\a1.bmp
//D:\我的世界\abc\a1.txt
//D:\我的世界\abc\a2.txt
//D:\我的世界\abc\a3
}
了解
| 方法名 | 说明 |
|---|---|
| public static File[ ] listRoots() | 列出可用的文件系统根 |
| public String[ ] list() | 获取当前该路径下的所有内容 |
| public String[ ] list(FilenameFilter filter) | 利用文件名过滤器获取当前该路径下的所有内容 |
| public File[ ] listFiles(FileFilter filter) | 利用文件名过滤器获取当前该路径下的所有内容 |
| public File[ ] listFiles(FilenameFilter filter) | 利用文件名过滤器获取当前该路径下的所有内容 |
import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;
public class testSix {
public static void main(String[] args) {
//listRoots,获取系统中所有的盘符，是静态方法，直接用类名调用
File[] files = File.listRoots();
System.out.println(Arrays.toString(files));
//[C:\, D:\]
//list.获取当前该路径下的所有内容，只能获取内容的名字
//如果获取的是文件，就获取文件名.后缀名
//如果获取的是文件夹，那么就获取文件夹的名字
File f1=new File("D:\\我的世界");
String[] list = f1.list();
for (String s : list) {
System.out.println(s);
}
//a1.bmp
//a1.txt
//a2.txt
//a3
//abc
//acc
//one
//list(FilenameFilter filter) 利用文件过滤器获取当前该路径下的所有内容
//这里list的参数FilenameFilter filter是一个函数式接口，可以用匿名内部类或lambda表达式的形式
File f2=new File("D:\\我的世界");
String[] list1 = f2.list(new FilenameFilter() {
@Override
//accept方法的形参，依次表示``我的世界``文件夹里每一个文件或文件夹的路径
//参数1：父级路径
//参数2：子级路径
//返回值：如果返回值为true，就表示当前路径保留
// 如果返回值为false，就表示当前路径舍弃不要
//所以是一个文件过滤器
//list方法返回值还是一个数组
public boolean accept(File dir, String name) {
return true;
}
});
System.out.println(Arrays.toString(list1));
//当accept返回值为false时，结果为[]
//当accept返回值为true时，结果为[a1.bmp, a1.txt, a2.txt, a3, abc, acc, one]
//需求：返回所有txt文件的名称
File f3=new File("D:\\我的世界");
String[] list2 = f3.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
File f = new File(dir, name);
if (f.isFile() && name.endsWith(".txt")) {
return true;
} else {
return false;
}
//上面的if语句可以写成
//return f.isFile()&&name.endsWith(".txt")
}
});
System.out.println(Arrays.toString(list2));//[a1.txt, a2.txt]
//listFiles(FilenameFilter filter)
//和listFiles(FileFilter filter)的使用
//与list(FilenameFilter filter)没什么不同，
//只是返回值由字符串的数组变成了File类型的数组
//listFiles(FilenameFilter filter)
//和listFiles(FileFilter filter)的区别
//他们匿名内部类里方法的参数不同，
// listFiles(FileFilter filter)匿名内部类中
//accept参数是pathname，是一条完整的路径
// listFiles(FilenameFilter filter)匿名内部类
//accept的参数跟list(FilenameFilter filter)
//一样，都是public boolean accept(File dir, String name)
//第一个参数表示父级路径，第二个参数表示子级路径
}
}
综合练习
public static void main(String[] args) throws IOException {
File f1 = new File("basic-code\\aaa");
f1.mkdirs();
File f2=new File(f1,"a.txt");
if(f2.createNewFile()){
System.out.println("创建成功");
}else{
System.out.println("创建失败");
}
}
public static void main(String[] args) {
File f1=new File("D:\\我的世界\\abc");
System.out.println(getMovie(f1));;
}
public static boolean getMovie(File file){
File[] files = file.listFiles();
for (File file1 : files) {
if(file1.getName().endsWith(".avi")){
return true;
}
}
return false;
}
核心思想：把大问题拆分成小问题，即，递归
public static void main(String[] args) {
//四步：1.进入文件夹 2.遍历数组 3.判断 4.判断
File file=new File("D:\\");
getAVI(file);
}
public static void getAVI(File file){
File[] files = file.listFiles();
if(files!=null){
for (File file1 : files) {
//判断，如果是文件，就直接判断
if(file1.isFile()){
if(file1.getName().endsWith(".avi")){
System.out.println(file1);
}
}else {//如果不是文件，进行递归
getAVI(file1);
}
}
}
}
public static void main(String[] args) {
File file=new File("D:\\我的世界\\abc");
Delete(file);
}
public static void Delete(File file){
File[] files = file.listFiles();
if(files!=null){
for (File file1 : files) {
// System.out.println(file1);
if(file1.isFile()){
System.out.println(file1.delete());;
}else{
Delete(file1);
}
}
}
file.delete();
}
public static void main(String[] args) {
File file=new File("D:\\我的世界");
System.out.println(getBit(file));
}
public static long getBit(File file){
File[] files = file.listFiles();
long sun=0;
if(files!=null){
for (File file1 : files) {
if(file1.isFile()){
sun=file1.length()+sun;
}else {
sun=sun+getBit(file1);//这句代码要注意
}
}
}
return sun;
}
public static void main(String[] args) {
File file=new File("D:\\我的世界");
System.out.println(getCount(file));;
}
public static HashMap<String,Integer> getCount(File file){
HashMap<String,Integer>hm=new HashMap<>();
File[] files = file.listFiles();
for (File file1 : files) {
if(file1.isFile()){
String[] split = file1.getName().split("\\.");
if(split.length>=2){
String s=split[split.length-1];
if(hm.containsKey(s)){
int count= hm.get(s);
count++;
hm.put(s,count);
}else{
hm.put(s,1);
}
}
}else {
HashMap<String, Integer> map = getCount(file1);
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
String key = entry.getKey();
Integer value = entry.getValue();
if(hm.containsKey(key)){
Integer value1 = hm.get(key);
value1=value1+value;
hm.put(key,value1);
}else{
hm.put(key,value);
}
}
}
}
return hm;
}
2342
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
