Day19JavaSE——IO概述&异常&File文件类

Day19JavaSE——IO概述&异常&File文件类

IO概述

A:IO流概述
		IO流用来处理设备之间的数据传输
		上传文件和下载文件
	B:IO流前奏
		讲解IO流之前为什么先讲解异常和File类呢?
		因为File表示的是IO流将来要操作的文件，所以我们需要学习File类。
		而常见操作文件无非就是上传文件和下载文件，在这个操作的过程中可能出现问题，
		出现问题后，我们需要对对应的代码进行处理。所以我们需要学习异常。

所以在学习文件IO之前首先需要学习File类和异常，以便于文件IO的操作

异常

概述&分类

:异常的继承体系
	异常的基类:	Throwable
		严重问题:	Error	不予处理,因为这种问题一般是很严重的问题,比如: 内存溢出
		非严重问题:	Exception
						编译时异常:	非RuntimeException
						运行时异常:	RuntimeException

JVM默认处理异常的方式

JVM默认是如何处理异常的
	main函数收到这个问题时,有两种处理方式:
	a:自己将该问题处理,然后继续运行
	b:自己没有针对的处理方式,只有交给调用main的jvm来处理
	jvm有一个默认的异常处理机制,就将该异常进行处理.
	并将该异常的名称,异常的信息.异常出现的位置打印在了控制台上,同时将程序停止运行

public class Test1 {
    public static void main(String[] args) {
        //在Java中 对于遇到的问题，有一个类来描述，
        //Throwable 问题或错误的父类
        //Exception 描述一般性的问题异常
           /*   对于异常也分为两种
                      一种就是编译期异常，发生在编译期间，非RuntimeException,及其子类，我们必须解决，不解决程序无法运行
                      一种是运行期异常，发生在运行期间RuntimeException,及其子类属于运行期异常，对于运行期异常，可以选择解决，也可以不解决。*/

        //Error  错误，严重性问题我我们无法在代码中捕获处理 比如内存异常。
        System.out.println("============运行期异常不做处理============");
        //运行期异常，发生在运行期间RuntimeException
        //及其子类属于运行期异常，对于运行期异常，可以选择解决，也可以不解决。
        int a=10;
        int b=0;
        //ArithmeticException 运行期异常，算术异常
        System.out.println(a/b);
        //运行期异常，你可以选择处理，也可以选择不处理
        //若不处理异常，Java使用的就是默认处理方式
        //当遇到异常时JVM会打印异常的堆栈信息，并退出JVM
        System.out.println("后面代码");
        System.out.println("后面代码");
        System.out.println("后面代码");
        System.out.println("后面代码");
        System.out.println("后面代码");
        System.out.println("后面代码");
        //也就是说，Java虚拟机，默认处理运行期异常的方式，不够友好
        //如果你觉得这种默认的处理方式，不够友好的话，你可以自己去处理运行期异常。
    }
}

运行期异常

运行期异常，你可以选择处理，也可以选择不处理

public class Test2 {
    public static void main(String[] args) {
        System.out.println("============运行期异常做处理============");
        int a=10;
        int b=0;
        //ArithmeticException 运行期异常，算术异常
        //自己处理运行期异常，出现异常，可以自己提示异常信息
        //但是不退出虚拟机，让代码继续向下执行
        /*使用try-catch语句来捕获代码
        * try{
        * }catch(Exception e){
        * }*/
        /*其中常见的Exception类型见思维导图*/

        try{
            System.out.println(a/b);
        }catch(ArithmeticException e){
            System.out.println("除数b为0了");
        }
        System.out.println("后面代码");
        System.out.println("后面代码");
        System.out.println("后面代码");
        System.out.println("后面代码");
        System.out.println("后面代码");
        System.out.println("后面代码");
    }
}

try…catch的方式处理异常

public class Test3 {
    public static void main(String[] args) {
        int[] arr = {20, 30};
        int a = 10;
        int b = 0;
        //ArrayIndexOutOfBoundsException
        //ArithmeticException
        try {
            arr = null;
            System.out.println(arr[0]);
            System.out.println(a / b);
            System.out.println(arr[3]);
        }catch (ArrayIndexOutOfBoundsException e){
            //捕获异常时最好明确异常类型
            //要是直接使用Exception就会捕获所有的异常，不知道具体异常类型
            System.out.println("索引越界异常");
        }catch (ArithmeticException e){
            System.out.println("除数为0了");
        }catch (NullPointerException e){
            System.out.println("空指针异常");
        } catch (Exception e) {
            System.out.println("其他异常");
        }
        //注意：捕获多种异常，语法如上。需要注意的是，能明确的异常，尽量明确，不要拿一个最大的Exception一捕了之
        //捕获的多个异常中有父子继承关系，父类异常放到最后，并列关系的异常谁前谁后没关系
        //try里面放的是有可能出现问题的代码，对于没有可能出现问题的代码，就不要往里面放了

        System.out.println("后面的代码");
        System.out.println("后面的代码");
        System.out.println("后面的代码");
        System.out.println("后面的代码");
        System.out.println("后面的代码");
        System.out.println("后面的代码");
    }
}

捕获多种异常

public class Test4 {
    public static void main(String[] args) {
        //JDK1.7之后提供了一种捕获多种异常的语法
        int[] arr = {20, 30, 40};
        int a = 10;
        int b = 0;
        //ArrayIndexOutOfBoundsException
        //ArithmeticException
        try {
            //arr = null;
            System.out.println(a / b);
            System.out.println(arr[0]);

            System.out.println(arr[3]);
            //JDK1.7之后提供了一种捕获多种异常的语法 不推荐
        } catch (ArrayIndexOutOfBoundsException | NullPointerException | ArithmeticException e) {
            if (e instanceof ArrayIndexOutOfBoundsException) {
                System.out.println("索引越界异常");
            } else if (e instanceof NullPointerException) {
                System.out.println("空指针异常");
            } else if (e instanceof ArithmeticException) {
                System.out.println("数学异常");
            }
        }
        System.out.println("后面的代码");
        System.out.println("后面的代码");
        System.out.println("后面的代码");
        System.out.println("后面的代码");
        System.out.println("后面的代码");
        System.out.println("后面的代码");
    }
}

try–catch–finally用法

public class Test5 {
    public static void main(String[] args) {
        int a=10;
        int b=0;
        //ctrl+shift+上下方向键，可以上下挪动一样代码
        try{
            System.out.println(a/0);
        }catch(ArithmeticException e){
            System.out.println("除数为0了");
        }finally {
            //finally最后的，不管try里面的代码有没有异常，finally里面的代码都会执行
            //一般我们会在finally里面写善后收尾的代码 比如释放资源
            System.out.println("不管try里面的代码有没有遇到异常，finally里面的代码都会执行");
        }
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
    }
}

finally需要注意的问题

finally的特点
	被finally控制的语句体一定会执行(前提 jvm没有停止)
	特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))
B:finally的作用:	用于释放资源，在IO流操作和数据库操作中会见到

public class Test6 {
    public static void main(String[] args) {
        Scanner scanner = null;
        try{
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第一个整数");
            int oneIntNum=sc.nextInt();
            System.out.println("请输入第二个整数");
            int twoIntNum = sc.nextInt();
            System.out.println("请输入第三个整数");
            int threeIntNum = sc.nextInt();
            System.out.println(oneIntNum / twoIntNum);
        }catch(ArithmeticException e){
            System.out.println("除数为0");
        }finally{
            //释放资源
            System.out.println("释放资源");
            if(scanner!=null){
                scanner.close();
            }
        }
        System.out.println("下面的代码");
    }
}

finally关键字的面试题

public class Test7 {
    public static void main(String[] args) {
        /*  B:
        面试题2:
        如果catch里面有return语句，请问finally的代码还会执行吗 ? 如果会，请问是在return前还是return后。
        答：会执行, 在return前
        例子如下：*/
        try {
            System.out.println(23 / 0);
        } catch (Exception e) {
            System.out.println("哦,catch了...............");
            return;
            //System.exit(0);
        } finally {
            System.out.println("哦,被执行了..............");
        }
    }
}

编译期异常

public class Test1 {
    //向上抛出parse异常给调用者
    public static void main(String[] args) throws ParseException {
        //编译期异常：发生在编译期，非RuntimeExpection及其子类
        //编译期异常必须手动处理，不处理程序无法运行
        String dateStr="2020-5-22";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        //调用parse函数，会遇到一个编译期异常，编译期异常必须处理
        simpleDateFormat.parse(dateStr);
        //处理编译期异常，有两种方法
        //方式1：使用throws向上抛出，抛出给调用者去处理，谁调用谁处理，最终会抛给JVM处理
        //一般来说，不抛给JVM，只抛出到main方法，最终在main方法中进行捕获处理
    }
}

public class Test2 {
    public static void main(String[] args) {
        //方式2：使用try-catch自己捕获处理
        String dateStr1="2020-5-20";
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
        try {
            simpleDateFormat1.parse(dateStr1);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

public class Test3 {
    public static void main(String[] args) {
        String dateStr = "2020-02-====23";
        //一般来说，抛到main方法里面就不再抛出了，而是自己捕获处理，这种方式比较友好一些
        try {
            Date date = parseDateStr(dateStr);
        } catch (ParseException e) {
            System.out.println("解析失败");
        }
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
    }
    private static Date parseDateStr(String dateStr) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        //编译期异常。抛出抛给调用者，谁调用谁处理
        Date date = simpleDateFormat.parse(dateStr);
        return date;
    }
}

public class Test4 {
    public static void main(String[] args) {
        int a=10;
        int b=0;
        try {
            System.out.println(a / b);
        }catch (ArithmeticException e){
            //对于异常的处理，不要做空处理.哪怕只是一句输出语句的提示，都行
            //  System.out.println("除数为0了");
            e.printStackTrace();//打印异常的堆栈信息
            // System.out.println(e.getMessage());
            // System.out.println(e.toString());
        }
        System.out.println("下面的代码");
    }
}

public class Test5 {
    public static void main(String[] args) {
        // InputMismatchException
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个整数");
            if (sc.hasNextInt()) {
                int num = sc.nextInt();
                System.out.println(num);
                break;
            } else {
                System.out.println("输入类型不正确，请重新输入");
            }
        }
    }
}

public class Test6 {
    public static void main(String[] args) {
        //利用异常机制
        //出现异常就执行另外一个代码
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输出一个整数");
            try {
                int num = sc.nextInt();
                System.out.println(num);
                break;
            } catch (InputMismatchException e) {
                System.out.println("输入类型不正确，请重新输入");
            }
        }
    }
}

Throwable的几个常见方法

Throwable的几个常见方法
	a:getMessage():				获取异常信息，返回字符串。
	b:toString():				获取异常类名和异常信息，返回字符串。
	c:printStackTrace():		获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

throw的概述以及和throws的区别

public class Test8 {
    public static void main(String[] args) {
        //throws 和 throw的区别
        //相同点是都可以进行异常的抛出
        //throws用在方法声明上
        //throw使用用在方法内部抛出异常

       /* C:
        throws和throw的区别
        a:throws
        用在方法声明后面，跟的是异常类名
        可以跟多个异常类名，用逗号隔开
        表示抛出异常，由该方法的调用者来处理
        throws表示出现异常的一种可能性，并不一定会发生这些异常
        b:
        throw
                用在方法体内，跟的是异常对象名
                只能抛出一个异常对象名
        这个异常对象可以是编译期异常对象, 可以是运行期异常对象
        表示抛出异常，由方法体内的语句处理
        throw则是抛出了异常对象，
        执行throw则一定抛出了某种异常*/
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int one = sc.nextInt();
        System.out.println("请输入第一个整数");
        int two = sc.nextInt();

        double r = test(one, two);
        System.out.println(r);

    }

    private static double test(int one, int two){
        double r=0;
        if(two==0){
            //如果除数为0 直接抛出异常
            throw new ArithmeticException("除数为0了");
        }else{
            r= one / two;
        }
        return r;
    }
}

自定义异常

概述&基本使用

A:为什么需要自定义异常:
 因为在以后的开发过程中,我们可能会遇到各种问题,
而Jdk不可能针对每一种问题都给出具体的异常类与之对应.
    为了满足需求,我们就需要自定义异常.
举例：考试成绩必须在0-100之间，不满足就产生异常。
B:自定义异常概述 需要将我们自定义的异常类纳入到我们的异常体系中
	继承自Exception
	继承自RuntimeException

public class NoMoneyException extends RuntimeException{
    //继承运行异常父类
    public NoMoneyException(String message){super(message);}
}

public class Test1 {
    static double remainMoney=1000;
    public static void main(String[] args) {
        //自定义异常：我们在开发项目中，会遇到各种各样的异常，需要自己定义
        //例如：余额不足异常，指纹识别异常
        //对于Java中未提供的异常，根据业务需求自定义
        System.out.println("===========余额不足异常===========");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的取款金额");
        long money = scanner.nextLong();
        withdrawingMoney(money);
    }

    private static void withdrawingMoney(long money) {
        if(money<=remainMoney){
            remainMoney-=money;
            System.out.println("取款成功");
        }else{
            //余额不足，就要抛出异常，程序终止。
            throw new NoMoneyException("余额不足");
        }
    }
}

案例演示(判断成绩范围)

public class ScoreExpection extends RuntimeException{
    public ScoreExpection(String message){super(message);}
}

public class Test1 {
    static double remainMoney=1000;
    public static void main(String[] args) {
        //自定义异常：我们在开发项目中，会遇到各种各样的异常，需要自己定义
        //例如：余额不足异常，指纹识别异常
        //对于Java中未提供的异常，根据业务需求自定义
        System.out.println("===========余额不足异常===========");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的取款金额");
        long money = scanner.nextLong();
        withdrawingMoney(money);
    }

    private static void withdrawingMoney(long money) {
        if(money<=remainMoney){
            remainMoney-=money;
            System.out.println("取款成功");
        }else{
            //余额不足，就要抛出异常，程序终止。
            throw new NoMoneyException("余额不足");
        }
    }
}

异常的注意事项及如何使用异常处理

public class Test3 {
    public static void main(String[] args) {
        //1.子类在重写父类方法时，如果父类方法，没有抛出过异常，则子类不能抛出异常。
        //2.子类在重写父类方法时,子类不能抛出父类没有抛出过的异常
        //3.子类在重写父类方法时，子类抛出的异常，可以比父类小，或者一样，不能比父类大
        //4.子类在重写父类方法时，如果父类方法有抛出异常，子类当然可以不抛出异常。
    }
}

class Fu{
    public void show() throws Exception{

    }

}
class Zi extends Fu{
    @Override
    public void show(){

    }
}

编译期异常和运行期异常的区别

编译期异常和运行期异常的区别

	Java中的异常被分为两大类：编译时异常和运行时异常。
	所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常
	
	编译时异常:	Java程序必须显示处理，否则程序就会发生错误，无法通过编译
	运行时异常:	无需显示处理，也可以和编译时异常一样处理

快速生成异常

public class Test4 {
    public static void main(String[] args) {
        //ctrl+alt+T 快速捕获异常的快捷键

        try {
            System.out.println(1 / 0);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //方式2
        //System.out.println(1 / 0).try 回车自动生成这个异常捕获的语句语句

        //对于编译期异常，你就按alt+enter键，进行选择，要么捕获，要么抛出
        try {
            new SimpleDateFormat("yyyy").parse ("2020");
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

File文件类

概述&构造函数

public class Test1 {
    public static void main(String[] args) {
        //IO流的作用，用来进行设备之间的一个数据传输
        //这些数据在我们电脑上是以文件的形式来体现的，比如文本文件，图片文件，视频文件，音频文件,等等。
        //Java为了描述文件或文件夹这个概念，给我们提供了一个类 File来描述文件或文件夹。
        //File 文件和目录路径名的抽象表示形式。

        /*构造函数
        * File(String pathname)
        * 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
        * File(String parent, String child)
        * 从父路径名字符串和子路径名字符串创建新的 File实例。
        * File(URI uri)
        * 通过将给定的 file: URI转换为抽象路径名来创建新的 File实例 */

        System.out.println("============构造函数1============");
        //通过一个路径字符串可以封装一个文件或文件夹
        File file = new File("C:\\Users\\adair_liu\\Desktop\\a.txt");
        System.out.println(file);
        //注意路径分隔符的写法
        File file1 = new File("C:/Users/adair_liu/Desktop/b.txt");
        System.out.println(file1);

        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);
        /*
        * static String pathSeparator
        * 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
        * static char pathSeparatorChar
        * 与系统有关的路径分隔符。
        * static String separator
        * 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
        * static char separatorChar
        * 与系统有关的默认名称分隔符。*/
        System.out.println(File.pathSeparatorChar);
        System.out.println(File.separator);
        System.out.println(File.separatorChar);

        //封装一个目录
        File file2 = new File("C:\\Users\\adair_liu\\Desktop");
        System.out.println(file2);

        System.out.println("============构造函数2============");
        /*
        * File(File parent, String child)
        * 从父抽象路径名和子路径名字符串创建新的 File实例。*/
        //参数1：父路径的File类型，参数2 子文件名
        File file3 = new File(file2, "aaa.txt");
        //输出的是地址字符串
        System.out.println(file3);

        System.out.println("============构造函数3============");
        /*  File(String parent, String child)
        根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。*/
        //参数1：父路径的Stirng类型 参数2：子文件名
        File file4 = new File("C:\\Users\\ShenMouMou\\Desktop", "bbb.text");
        System.out.println(file4);

        System.out.println("=========绝对路径和相对路径========");
        //绝对路径和相对路径
        //绝对路径：带有盘符号的一个详细路径 例如：C:\Users\ShenMouMou\Desktop\aaa.txt
        // 绝对路径：D:\HBuilderX .1 .3 .2 .20181214.full\HBuilderX\iconengines
        //相对路径：不带有盘符号的路径
        //Java程序当中这个相对路径指的是哪段路径,你项目的根路径下就是相对路径

        //使用的是绝对路径来封装文件
        File file5 = new File("C:\\Users\\adair_liu\\Desktop\\Java");
        System.out.println(file5);

        //如果这个文件在项目的文件夹的根目录下，可以使用相对路径来封装
        File file6 = new File("a.txt");
        System.out.println(file6);

        //./当前目录，项目的文件夹的根目录下
        File file7 = new File("./");
        System.out.println(file7.getAbsolutePath());
    }
}

File类的创建功能

public class Test2 {
    public static void main(String[] args) throws IOException {
        //用相对路径封装文件
        File file = new File("a.txt");
        //创建一个文件，返回值指的是文件是否创建成功，成功返回true
        //文件重复，创建失败就返回false
        boolean newFile = file.createNewFile();
        System.out.println(newFile);

        System.out.println("=======================");
        //用绝对路径创建
        File file1 = new File("C:\\Users\\adair_liu\\Desktop\\Java\\b.txt");
        boolean newFile1 = file1.createNewFile();
        System.out.println(newFile1);

        System.out.println("=======================");
        //用的相对路径 ./ 当前路径 指的是项目文件夹的根目录下
        File file2 = new File("./c.txt");
        String absolutePath = file2.getAbsolutePath();
        System.out.println(absolutePath);
        boolean newFile2 = file2.createNewFile();
        System.out.println(newFile2);

        System.out.println("=======================");
        //用的相对路径 ../ 表示当前项目路径的上一级路径
        File file3 = new File("../d.txt");
        System.out.println(file3.getAbsolutePath());
        boolean newFile3 = file3.createNewFile();
        System.out.println(newFile3);

        System.out.println("=======================");
        //../../ 当前目录的上两级目录
        File file4 = new File("../../e.txt");
        System.out.println(file4.getAbsolutePath());
        System.out.println(file4.createNewFile());
    }
}

public class Test3 {
    public static void main(String[] args) {
        //在当前项目文件的根目录下创建一个demo文件夹
        File demo = new File("demo");
        //创建文件夹，创建成功返回true ,如果文件夹已经存在，你重复创建，就返回false
        System.out.println(demo.mkdir());

        System.out.println("==============================");
        File demo1 = new File("C:\\Users\\adair_liu\\Desktop", "demo");
        boolean mkdir = demo1.mkdir();
        System.out.println(mkdir);

        System.out.println("==============================");
        //mkdir() 这个方法的不好之处，就是只能创建单级文件夹
        //如果要创建多级文件夹，我们可以使用另外一个方法
        File file = new File("C:\\Users\\adair_liu\\Desktop", "aaa\\bbb\\ccc");
        // mkdirs(); 可以创建多级或单级文件夹
        System.out.println(file.mkdirs());
    }
}

File类的功能方法

public class Test4 {
    public static void main(String[] args) throws IOException {
        System.out.println("=============删除文件或文件夹=============");
        /*boolean delete()
        删除由此抽象路径名表示的文件或目录。
        void deleteOnExit()
        请求在虚拟机终止时删除由此抽象路径名表示的文件或目录。*/
        //先将本工程目录下的a.txt文件封装
        //后面调用File的成员函数对此文件进行处理
        File file = new File("a.txt");
        //删除文件，删除成功返回true,重复删除返回false
        System.out.println(file.delete());
        //delete() 删除文件夹的时候，只能删除空文件夹，如果是非空目录，则删除失败。
        //若想删除多级非空目录，用递归进行逻辑编写

        System.out.println("============重命名文件或文件夹============");
        /*boolean renameTo(File dest)
        重命名由此抽象路径名表示的文件。 */
        File file1 = new File("b.txt");
        File file2 = new File("d.txt");
        File file3 = new File("d.txt");
        File file4 = new File("C:\\Users\\adair_liu\\Desktop\\aa.txt");
        /*System.out.println(file1.createNewFile());
        System.out.println(file2.createNewFile());
        System.out.println(file3.createNewFile());*/
        //重命名：如果一个文件对象要改名，就需要将要改成的文件名封装成同类型文件
        //当源文件要改成的文件名在该路径下没有重名时，就直接对源文件重命名,并返回true
        boolean b = file1.renameTo(file2);
        System.out.println(b);

        System.out.println("--------------");
        //当源文件要改成的文件名在该路径下重名时，返回false
        System.out.println(file1.renameTo(file4));
        System.out.println("--------------");
        //当源文件要改成的文件名与源文件不在同一路径下时，返回false
        boolean b1 = file1.renameTo(file4);
        System.out.println(b1);

        System.out.println("============判断是不是个文件============");
        /*boolean isFile()
        测试此抽象路径名表示的文件是否为普通文件。 */
        File file5 = new File("aa.txt");
        //如果没有创建文件，路径下没有这个文件，就会返回false
        file5.createNewFile();
        System.out.println(file5.isFile());

        System.out.println("============判断是不是目录============");
        /*boolean isDirectory()
        测试此抽象路径名表示的文件是否为目录。 */
        File bb = new File("./", "bb");
        //如果没有创建目录，路径下没有这个目录，就会返回false
        bb.mkdirs();
        System.out.println(bb.isDirectory());

        System.out.println("========判断文件或文件夹是否存在========");
        /*boolean exists()
        测试此抽象路径名表示的文件或目录是否存在。 */
        System.out.println(file5.exists());

        System.out.println("============判断文件是否可读===========");
        /*boolean canRead()
        测试应用程序是否可以读取由此抽象路径名表示的文件。 */
        System.out.println(file5.canRead());

        System.out.println("============判断文件是否可读===========");
        /*boolean canWrite()
        测试应用程序是否可以修改由此抽象路径名表示的文件。*/
        System.out.println(file5.canWrite());

        System.out.println("============判断文件是否隐藏===========");
        /*boolean isHidden()
        测试此抽象路径名命名的文件是否为隐藏文件。 */
        System.out.println(file5.isHidden());

        System.out.println("=======判断文件是否使用的是绝对路径======");
        /*boolean isAbsolute()
        测试这个抽象路径名是否是绝对的。*/
        System.out.println(file5.isAbsolute());

        System.out.println("===========获取文件的绝对路径==========");
        //获取文件的绝对路径，返回的是字符串类型
        /*String getAbsolutePath()
        返回此抽象路径名的绝对路径名字符串。*/
        System.out.println(file5.getAbsolutePath());

        System.out.println("-------------------");
        /*File getAbsoluteFile()
        返回此抽象路径名的绝对形式。*/
        //获取文件的绝对路径,返回的是File 这个方法比较灵活
        File absoluteFile = file5.getAbsoluteFile();
        System.out.println(absoluteFile.toString());
        absoluteFile.delete();

        System.out.println("=============获取相对路径=============");
        String path = file5.getPath();
        System.out.println(path);

        System.out.println("============获取文件的父路径===========");
        /*String getParent()
        返回此抽象路径名的父 null的路径名字符串，如果此路径名未命名为父目录，则返回null。 */
        //获取文件的父路径,返回的是字符串类型
        String parent = file5.getParent();
        System.out.println(parent);
        System.out.println("-------------------");
        //获取文件的父路径,返回的是File类型 这个方法灵活
        //在封装文件时，没有指定父路径，返回就是null
        File parentFile = file5.getParentFile();
        System.out.println(parent);

        //封装时有指定父路径，就会返回父路径
        File file6 = new File("E:\\IdeaProjects\\20200524-File-类-上午\\a.txt");
        System.out.println(file6.getParentFile());

        System.out.println("============获取磁盘的总容量===========");
        /*long getTotalSpace()
        通过此抽象路径名返回分区的大小 */
        //获取磁盘的总容量，返回的是字节
        File file7 = new File("D://");
        long totalSpace = file7.getTotalSpace();
        System.out.println(totalSpace / 1024 / 1024 / 1024 + "GB");

        System.out.println("============获取磁盘的剩余容量===========");
        /*long getFreeSpace()
        返回分区未分配的字节数 named此抽象路径名。 */
        long freeSpace = file7.getFreeSpace();
        System.out.println(freeSpace/1024/1024/1024+"GB");
        //已用容量=总容量-剩余容量

        System.out.println("================获取文件名==============");
        /*String getName()
        返回由此抽象路径名表示的文件或目录的名称。*/
        String name = file5.getName();
        System.out.println(name);

        System.out.println("================获取文件大小=============");
        /*long length()
        返回由此抽象路径名表示的文件的长度。*/
        System.out.println(file5.length());
    }
}

public class Test5 {
    public static void main(String[] args) {

        File file = new File("C:\\Users\\adair_liu\\Desktop\\Java");
        /*long lastModified()
        返回此抽象路径名表示的文件上次修改的时间 */
        //获取文件的最后一次修改时间，返回的是毫秒值
        long time = file.lastModified();
        System.out.println(time);
        //把毫秒值，转换成字符串，以年月日 时分秒来展示
        /*Date(long date)
        使用给定的毫秒时间值构造一个 Date对象。*/
        Date date = new Date(time);
        /*SimpleDateFormat(String pattern)
        使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。*/
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        /*StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition pos)
        将给定的 Date成日期/时间字符串，并将结果追加到给定的 StringBuffer 。*/
        String format = simpleDateFormat.format(date);
        System.out.println(format);
    }
}

public class Test6 {
    public static void main(String[] args) {
        //public String[] list ():获取指定目录下的所有文件或者文件夹的名称数组
        // public File[] listFiles ():获取指定目录下的所有文件或者文件夹的File数组
        File file = new File("C:\\Users\\adair_liu\\Desktop\\aaa");
        String[] list = file.list();
        for (String s : list) {
            //System.out.println(s);
            if(s.equals("MyNote")){
                System.out.println("进来了");
                System.out.println(s);
                File file1 = new File(file, "a.txt");
                System.out.println(file1.delete());
            }
        }
        System.out.println("=============================");
        //public File[] listFiles ():获取指定目录下的所有文件或者文件夹的File数组
        File[] files = file.listFiles();
        for (File file1 : files) {
            //System.out.println(file1);
            System.out.println(file1.getName());
            /*//仅删除文件夹
            if (file1.isDirectory()) {
                if (!file1.delete()) {
                    deleteAll(file1);
                }
            }*/
            //删除桌面文件夹aaa里面的所有文件
            if (!file1.delete()) {
                deleteAll(file1);
            }
        }
    }
}

文件名称过滤器的概述及使用

A:文件名称过滤器的概述
	public String[] list(FilenameFilter filter)
	public File[] listFiles(FilenameFilter filter)
B:文件名称过滤器的使用:	需求：判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
- 分析:
- a: 把E:\\demo这个路径封装成一个File对象
- b: 获取所有的以.jpg结尾的文件数组		(相当于过滤)
- c: 遍历数组

public class Test1 {
    public static void main(String[] args) {
        /*  A:
        案例演示:
        需求：判断桌面aaa目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称*/

        System.out.println("================方式1=============");
        //1、封装要操作的文件夹
        File file = new File("C:\\Users\\adair_liu\\Desktop\\aaa");
        //2、获取demo文件夹里面所有文件和文件夹File对象
        File[] files = file.listFiles();
        //3、遍历对象数组
        for (File file1 : files) {
            if (file1.isFile()&&file1.getName().endsWith(".jpg")) {
                System.out.println(file1.getName());
            }
        }

        System.out.println("================方式2=============");
        //第一步都一样，但是第二步使用一个文件名过滤器
        file.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                //判断桌面aaa目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
                //dir：父路径
                //name:子文件名
                //封装子文件
                File file1 = new File(dir, name);
                if (file1.isFile()&&file1.getName().endsWith(".jpg")) {
                    return true;
                }else{
                    return false;
                }
                //返回false表示不符合条件，就不会过滤到File数组中
                //返回true表示符号条件，才会过滤到File数组中
            }
        });
        for (File file1 : files) {
            System.out.println(file1);
        }

        System.out.println("================方式3=============");
        File[] files1 = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                //pathname 子文件或子文件夹File对象
                // System.out.println(pathname);
                if (pathname.isFile()&&pathname.getName().endsWith(".jpg")) {
                    return true;
                }else{
                    return false;
                }
                //返回false表示不符合条件，就不会过滤到File数组中，返回true表示符号条件，才会过滤到File数组中

            }
        });


        //System.out.println(Arrays.toString(files));
        for (File file1 : files1) {
            System.out.println(file1.getName());
        }
    }
}

删除多级非空文件夹(用递归)

public class Test1 {
    public static void main(String[] args) {
        File file = new File("C:\\Users\\adair_liu\\Desktop\\新建文件夹");
        /*boolean deleteFile = file.delete();
        System.out.println(deleteFile);*/
        System.out.println("===============================");
        deleteAll(file);
    }

    public static void deleteAll(File file) {
        boolean deleteFlag = file.delete();
        if (!deleteFlag) {
            File[] files = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                boolean b = files[i].delete();
                if (!b) {
                    deleteAll(files[i]);
                }
            }
            //删除完非空文件夹里面的所有文件之后出来要删除文件夹
            file.delete();
        }
    }
}

le数组中，返回true表示符号条件，才会过滤到File数组中

        }
    });


    //System.out.println(Arrays.toString(files));
    for (File file1 : files1) {
        System.out.println(file1.getName());
    }
}

}

### 删除多级非空文件夹(用递归)

```java
public class Test1 {
    public static void main(String[] args) {
        File file = new File("C:\\Users\\adair_liu\\Desktop\\新建文件夹");
        /*boolean deleteFile = file.delete();
        System.out.println(deleteFile);*/
        System.out.println("===============================");
        deleteAll(file);
    }

    public static void deleteAll(File file) {
        boolean deleteFlag = file.delete();
        if (!deleteFlag) {
            File[] files = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                boolean b = files[i].delete();
                if (!b) {
                    deleteAll(files[i]);
                }
            }
            //删除完非空文件夹里面的所有文件之后出来要删除文件夹
            file.delete();
        }
    }
}