Java IO流概述异常 File文件类

最新推荐文章于 2024-06-04 23:11:16 发布

LCYeezus

最新推荐文章于 2024-06-04 23:11:16 发布

阅读量125

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_47884045/article/details/112969261

版权

19.01_IO流（IO流概述及其前奏）

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

在这里插入图片描述

19.02_异常的概述和分类

  A：异常的概述：	异常就是Java程序在运行过程中出现的错误。
  B：异常的分类：	举例：张三骑自行车旅游
  C：异常的继承体系
  		异常的基类：		Throwable
  			严重问题：		Error	不予处理，因为这种问题一般是很严重的
  									问题。比如：内存溢出
  			非严重问题：		Exception	
  									  编译时异常：非RuntimeException
  									  运行时异常：RuntimeException

在这里插入图片描述

public static void main(String[] args) {
        //运行期异常：RuntimeException及其子类，发生在运行期，可以选择处
        //理也可以选择不处理
        int a = 1;
        int b = 0;
        //ArithmeticException 描述初始为0的异常
        //当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，
        //抛出此类的一个实例。
        System.out.println(a/b);

        System.out.println("下面写了很多代码");
        System.out.println("下面写了很多代码");
        System.out.println("下面写了很多代码");
    }

19.03_JVM默认是如何处理异常的

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

19.04_try…catch的方式处理异常

  A：异常处理的两种方式
  		a：try...catch...finally
  		b：throws
  B：try...catch处理异常的基本格式
  		try{
  			可能出现问题的代码;
  		}catch(异常名 变量名){
  			针对问题的处理;
  		}finally{
  			释放资源;
  		}
		
	 变形格式：
	 	try{
	 		可能出现问题的代码;
	 	}catch(异常名 变量名){
	 		针对问题的处理;
	 	}
	 注意事项：
	 	a：try中的代码越少越好
	 	b：catch中要做处理，哪怕是一条输出语句也可以.（不能将异常信息隐藏）
  C：try...catch处理异常的基本格式2
  		try{
  			可能出现问题的代码；
  		}catch(异常名1 变量名1){
  			对异常的处理方式;
  		}catch(异常名2 变量名2){
  			对异常的处理方式;
  		}....

public static void main(String[] args) {
        //运行期异常：RuntimeException及其子类，发生在运行期，可以选择处
        //理也可以选择不处理
        int a = 1;
        int b = 0;
        //ArithmeticException 描述初始为0的异常
        //当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛
        //出此类的一个实例。
        //try catch 来自己捕获异常处理，不交由JVM来处理。
        //try里面放的代码就是有可能出现问题的代码，
        //catch (异常类型 e) 一旦你try里面发生了catch (异常类型 e)所捕获
        //的异常类型，那么catch里面的代码执行
        //catch 里面就是你对异常的具体处理逻辑。
        try{
            System.out.println(a/1);
        }catch(ArithmeticException e){
            System.out.println("初始为0了");
        }
        System.out.println("下面写了很多代码");
        System.out.println("下面写了很多代码");
        System.out.println("下面写了很多代码");
    }

public static void main(String[] args) {
        int[] arr = {1,2,3};
        arr = null;
        //ctrl+H 可以看到类的继承关系
        //ArrayIndexOutOfBoundsException 用非法索引访问数组时抛出的异常。
        //如果索引为负或大于等于数组大小，则该索引为非法索引。
        try{
            System.out.println(arr.length);
            arr[10] = 30;
            int a = 1/0;
        }catch (ArithmeticException e){
            //对异常进行处理
            System.out.println("初始为0了");
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("角标越界了");
        }catch (NullPointerException e){
            System.out.println("空指针异常");
        }catch (Exception e){
            System.out.println("其他异常");
        }
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
    }

public static void main(String[] args) {
        int[] arr = {1,2,3};
        arr = null;
        try{
            System.out.println(arr.length);
            arr[10] = 30;
            int a = 1/0;
        }catch (ArithmeticException e){
            //对异常进行处理
            System.out.println("除数为0了");
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("角标越界了");
        }catch (NullPointerException e){
            System.out.println("空指针异常");
        }catch (Exception e){
            System.out.println("其他异常");
        }
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");

        /*
         *  我们自己来处理异常时，try 里面放的是有可能出现问题的代码
         *  catch() 括号里面写的是有可能发生这种异常的类型
         * 一旦try里面发生了该种异常，catch里面的代码就会执行
         * catch 里面的代码就是发生了该异常你如何去处理，你最简单的处理，
         * 可以输出一句话提醒自己，但是不要做空处理
         * 如果你要捕获多个异常，可以写多个catch来捕获，多个异常类是并列
         * 的兄弟关系，谁前谁后无所谓
         *  如果异常类有父子关系，父类放后面
         *  能明确的异常，尽量明确，不要用最大的Exception一捕了之。
         */
    }

public static void main(String[] args) {
        int[] arr = {1,2,3};
        arr = null;
        try{
            System.out.println(arr.length);
            arr[10] = 30;
            int a = 1/0;
            //JDK1.7 写法
        }catch (ArithmeticException | NullPointerException | ArrayIndexOutOfBoundsException e){
            if(e instanceof ArithmeticException){
                //对异常进行处理
                System.out.println("除数为0了");
            }else if(e instanceof NullPointerException){
                //对异常进行处理
                System.out.println("空指针异常了");
            }else if(e instanceof ArrayIndexOutOfBoundsException){
                //对异常进行处理
                System.out.println("空指针异常了");
            }else if(e instanceof ArrayIndexOutOfBoundsException){
                System.out.println("角标越界异常了");
            }
        }
    }

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

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

19.06_Throwable的几个常见方法

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

public static void main(String[] args) {
        int a = 10;
        int b = 5;
        try{
            System.out.println(a / 0);
        }catch (Exception e){
            //System.out.println("发生异常了");
            //打印详细的异常信息
            e.printStackTrace();
            //System.out.println(e.getMessage());
            //System.exit(0);
        }
        System.out.println("aaaaa");
    }

public static void main(String[] args) {
        while (true){
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个整数");
            try{
                int i = scanner.nextInt();
                //InputMismatchException
                System.out.println(i);
                break;
            }catch (InputMismatchException e){
                //e.printStackTrace();
                //你对异常处理
                System.out.println("你输入的类型不正确，请重新输入");
            }
        }
    }

public static void main(String[] args) {
        //编译期异常：非RuntimeException 及其子类 ，编译期异常，发生在编
        //译期间，必须处理，如果不处理程序无法运行
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        //编译期异常 ParseException 表示解析时出现意外错误。
        //编译期异常，必须处理
        //处理方式有两种：1.使用try 自己捕获处理 2.自己不处理，甩锅给调用
        //者处理
        try{
            Date date = simpleDateFormat.parse("2020-10=10");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
    }

19.07_throws的方式处理异常

  A：throws的方式处理异常
  		定义功能方法时，需要把出现的问题暴露出来让调用者去处理
  		那么就通过throws在方法上标识

19.08_throw概述及和throws的区别

  A：throw的概述：	在功能方法内部出现某种情况，程序不能继续运行，需要进
  					行跳转时，就用throw把异常对象抛出
  B：throws和throw的区别
  		   a：throws
  		   			用在方法声明后面，跟的是异常类名，可以跟多个异常类名，
  		   			用逗号隔开；表示抛出异常，由该方法的调用者来处理；
  		   			throws表示出现异常的一种可能性，并不一定会发生这些异常
  		   b：throw
  		   			用在方法体内，跟的是异常对象名；只能抛出一个异常对象名；
  		   			这个异常对象可以是编译期异常对象，可以是运行期异常对象；
  		   			表示抛出异常，由方法体内的语句处理；
  		   			throw是抛出了异常，执行throw一定抛出了某种异常

public static void main(String[] args) {
        //一般到main方法里面，就不要在抛出给虚拟机来处理，你可以自己捕获
        //处理
        try {
            show();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println("下面代码");
        System.out.println("下面代码");
        System.out.println("下面代码");
        System.out.println("下面代码");
        System.out.println("下面代码");
        System.out.println("下面代码");
        System.out.println("下面代码");
    }

    private static void show() throws ParseException {
        //编译期异常：非RuntimeException 及其子类 ，编译期异常，发生在编
        //译期间，必须处理，如果不处理程序无法运行
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        //编译期异常 ParseException 表示解析时出现意外错误。
        //编译期异常，必须处理
        //处理方式有两种：1.使用try 自己捕获处理 2.自己不处理，采用throws
        //甩锅给调用者处理，谁调用谁处理

        Date date = simpleDateFormat.parse("2020-10=10");
    }

public static void main(String[] args) {
        // throws 对编译期异常，进行抛出，抛给调用者去处理
        // throw 用在方法内部，对异常进行抛出的。

        /*
        *  C:throws和throw的区别
	a:throws
		用在方法声明后面，跟的是异常类名
		可以跟多个异常类名，用逗号隔开
		表示抛出异常，由该方法的调用者来处理
		throws表示出现异常的一种可能性，并不一定会发生这些异常
	b:throw
		用在方法体内，跟的是异常对象名
		只能抛出一个异常对象名
		这个异常对象可以是编译期异常对象,可以是运行期异常对象
		表示抛出异常，由方法体内的语句处理
		throw则是抛出了异常，执行throw则一定抛出了某种异常
        *
        */
        double r = division(5,0);

        System.out.println("r = " + r);
        System.out.println("下面的代码r=" + r);
        System.out.println("r = " + r);
        
    }

    private static double division(int a, int b) {
        double r = 0;
        if(b == 0){
            //用 throw 抛出异常对象
            throw new ArithmeticException("除数为0了");
        }else{
            r = a/b;
        }
        return r;
    }

19.09_finally关键字的特点及作用

  A：finally的特点
  		  被finally控制的语句体一定会执行（前提：JVM没有停止）
  		  特殊情况：在执行到finally之前JVM退出了(比如System.exit(0))
  B：finally的作用：用于释放资源，在IO流操作和数据库操作中会见到
  
  C：面试题1：	final,finally和finalize的区别

			*	final：是一个状态修饰符，可以用来修饰类、变量、成员方法。
					   被修饰的类不能被子类继承，修饰的变量其实是一个常量
					   不能再次被赋值；修饰的方法不能被子类重写
			*	finally：用在try...catch...语句中，作用：释放资源，
						 特点：始终被执行(JVM不能退出)
			*	finalize：Object类中的一个方法，用来回收垃圾
			
	 面试题2：	如果catch里面有return语句，请问finally的代码还会执行吗？
	 			如果会，请问在return前还是return后
	 			答：会执行，在return前

public static void main(String[] args) throws ParseException {
        try{
            System.out.println(1/1);
        }catch (ArithmeticException e){
            //catch 里面就是你try里面发生了我所捕获的这个异常，那么catch
            //里面的代码就会执行
            System.out.println("catch里面的代码执行了");
        }finally {
            //finally里面会做一些善后收尾的工作，比如资源的释放
            //最终的：不管你 try里面有没有遇到异常finally里面的代码都会执行
            System.out.println("不管你 try里面有没有遇到异常finally里面的代码都会执行");
        }
    }

public static void main(String[] args) throws ParseException {
        Scanner scanner = null;
        try{
            System.out.println(1/0);
            scanner = new Scanner(System.in);
            System.out.println("请输入一个整数");
            int i = scanner.nextInt();
            System.out.println(i);
        }catch (InputMismatchException e){
            e.printStackTrace();
        }finally{
            System.out.println("finally里面的代码执行了");
            //释放资源
            if(scanner != null){
                scanner.close();
            }
        }
    }

public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add(20);
        Iterator<Object> iterator = list.iterator();
        /*   public E next () {
            int i = cursor;
            if (i >= size) {
                throw new NoSuchElementException();
            }
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }*/
    }

public static void main(String[] args) {
        /* A:
        面试题1:
        final,finally和finalize的区别

        final 修饰变量，为一个常量，修饰类，此类不能被继承 修饰方法，此方
        	  法不能被重写
        finally
        finalize() 回收垃圾
        */
        System.gc();
        // 如果catch里面有return语句，请问finally的代码还会执行吗 ? 如果
        //会，请问是在return前还是return后。
        try{
            System.out.println(23 / 0);
        }catch (Exception e){
            System.out.println("哦,catch了...............");
            return;
        }finally {
            System.out.println("哦,被执行了..............");
        }
    }

19.10_自定义异常概述和基本使用

  A：为什么需要自定义异常
  		因为在以后的开发过程中，我们可能会遇到各种问题，而JDK不可能针对每
  		一种问题都给出具体的异常类与之对应。为了满足要求，我们就需要自定义
  		异常
  B：自定义异常概述
  		需要将我们自定义的异常类纳入到我们的异常体系中
  		继承自Exception
  		继承自RuntimeException

public class MyTest {
    static int money = 100;
    public static void main(String[] args) {
        //自定义异常：为什么要有自定义异常，Java中给我们提供的这些异常类，
        //不能描述我们开发中所有遇到异常情况，那有时为了描述，我们遇到异常
        //情况，我们就需要自定义异常。开发银行业务，余额不足异常
        withdrawal();

        System.out.println("aaaaaa");
    }

    private static void withdrawal() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的取款金额");
        int num = scanner.nextInt();
        if(num <= money){
            money -= num;
            System.out.println("取款成功");
        }else{
            //抛出自定义异常
            throw new NoMonenyException("余额不足异常");
        }
    }
}
public class NoMonenyException extends RuntimeException {
    public NoMonenyException() {
        super();
    }

    public NoMonenyException(String message){
        super(message);
    }
}

public static void main(String[] args) {
        //  举例：考试成绩必须在0 - 100 之间，不满足就产生异常。
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的考试成绩 0-100");
        int score = scanner.nextInt();
        showScore(score);
    }

    private static void showScore(int score) {
        // 判断成绩范围
        if(score > 100 || score <0){
            // 抛出一个异常对象
            //注意 自定义异常类 提供有参数构造
            throw new ScoreException("成绩不在有效的范围内(0~100)....");
        }else{
            System.out.println("成绩合法.....................");
        }
    }
public class ScoreException extends RuntimeException {
    public ScoreException() {

    }

    public ScoreException(String message){
        super(message);
    }
}

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

  A：异常注意事项(针对编译期异常)
  		a：子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子
  		   类，或者子类不抛出异常也是可以的。(父亲坏了，儿子不能比父亲更坏)
  		b：如果父类抛出多个异常，子类重写父类时，只能抛出相同的异常或者是
  		   他的子集，子类不能抛出父类没有的异常，或者子类不抛出异常也是可以的
  		c：如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，
  		   如果子类方法内有异常发生，那么子类只能try，不能throws
  B：如何使用异常处理
  			原则：如果该功能内部可以将问题处理，用try，如果处理不了，交由
  				 调用者处理，这是用throws
  			区别：
  					后续程序需要继续运行就try
  					后续程序不需要继续运行就throws

public class MyTest {
    public static void main(String[] args) {
        //1.子类在重写父类方法时，父类方法没有抛出过异常，子类在重写该方
        //  法时，就不能抛出异常。
        //2.如果父类方法有抛抛出异常，子类在重写该方法时，可以抛出和父类
        //  方法一样的异常，或者父类方法异常的子类,当然子类可以不抛出，自
        //  己捕获处理
        //3.子类抛出的异常，不能比父类大，要么一样,要么是父类异常的子类，
        //  不能抛出父类没有抛出过的编译期异常
    }
}

abstract class Fu{
    public abstract void show() throws ParseException, ArithmeticException, ActivationException;
}

class Zi extends Fu{

    @Override
    public void show() throws ParseException, ActivationException {
        new SimpleDateFormat("yyyy-MM-dd").parse("2020-10-10");
    }
}

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //选中你认为可能会出现问题的代码 按快捷键 ctrl+alt+T 捕获处理
        try{
            System.out.println(a / b);
        }catch (ArithmeticException e){
            e.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("下面的代码");
        //编译期异常，你就按 alt+enter 自己选 抛出和还是自己捕获处理
        try{
            new SimpleDateFormat("yyyy-MM-dd").parse(" ");
        }catch (ParseException e){
            e.printStackTrace();
        }

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

19.12_File类的概述和构造方法

  A：File类的概述
  		   查看API
  		   文件和目录路径的抽象表示形式
  		   这个File类可以用来表示文件，也可以用来表示目录
  B：构造方法
  			File(String pathname)：根据一个路径得到File对象
  			File(String parent,String child)：根据一个目录和一个子文件/
  											  目录得到File对象
  			File(File parent,String child)：根据一个父File对象和一个子
  											文件/目录得到File对象

public static void main(String[] args) {
        //File 文件和目录路径名的抽象表示形式。
        //File 用来描述文件和目录（文件夹）
        //构造方法
        /* File(File parent, String child)
        根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
        File(String pathname)
        通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
        File(String parent, String child)
        根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
        */

        // File(String pathname)
        // 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
        //绝对路径：带有盘符号的一个详细的路径 C:\Users\ShenMouMou\Desktop\a.txt
        //相对路径：不带盘符号，Java项目中的相对路径，就指的是，项目的根目录 E:\IdeaProjects\20210103-File-类-下午
        File file = new File("C:\\Users\\57642\\Desktop\\a.txt");
        // E:\IdeaProjects\20210103 - File - 类 - 下午
        //用的是相对路径
        File file1 = new File("b.txt");
    }

public static void main(String[] args) {
        File file = new File("C:\\Users\\57642\\Desktop\\a.txt");
        /*  File(String parent, String child)
        根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。*/
        //父路径，子文件名
        File file1 = new File("C:\\Users\\57642\\Desktop", "a.txt");
    }

public static void main(String[] args) {
        /* File(File parent, String child)
        根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。*/
        File file = new File("C:\\Users\\57642\\Desktop\\a.txt");
        File file1 = new File("C:\\Users\\57642\\Desktop", "a.txt");
        //封装父目录
        File parentFile = new File("C:\\Users\\57642\\Desktop");
        File file2 = new File(parentFile, "a.txt");

        // 正斜杠  反斜杠
        File file3 = new File("C:\\Users\\57642\\Desktop\\a.txt");
        File file4 = new File("C:/Users/57642/Desktop/a.txt");
    }

19.13_File类的创建、删除和重命名功能

  A：创建功能
  		public boolean createNewFile()：创建一个新的文件 如果存在这样的
  										文件，就不创建了
  		public boolean mkdir()：创建文件夹 如果存在这样的文件夹，就不创建
  								了 注意这个方法只能创建单层目录 如果创建
  								多层目录得一层一层创建
  		public boolean mkdirs()：创建文件夹，如果父文件夹不存在，会帮你
  								 创建出来 可以创建多层目录 当然也可以创
  								 建单层目录
  B：删除功能
  		public boolean delete()：删除文件或者文件夹
  		注意：删除文件夹时，这个文件夹是空文件夹 如果这个文件夹里面有文件，
  			  则不能删除
  			  
  C：重命名功能
  		public boolean rename(File deat)：把文件重命名为指定的文件路径

public static void main(String[] args) throws IOException {
        //相对路径：你项目目录的根目录下
        File file = new File("a.txt");
        //绝对路径：
        File file2 = new File("E:\\IdeaProjects\\20210103-File-类-下午\\b.txt");
        //创建文件，返回值的意思，如果文件不存在，创建成功返回true，如果
        //文件已经存在，你重复创建返回false
        boolean b = file.createNewFile();
        System.out.println(b);
        boolean b2 = file2.createNewFile();
        System.out.println(b2);
    }

public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\57642\\Desktop\\abc");
        //创建的是单级目录
        boolean b = file.mkdir();
        System.out.println(b);

        File file1 = new File("C:\\Users\\57642\\Desktop", "abc\\aa\\bb");
        //创建单级或多级目录。返回值的第一次创建成功返回true，如果目录已
        //经存在，重复创建返回false
        boolean b1 = file1.mkdirs();
        System.out.println(b1);
    }

public static void main(String[] args) throws IOException {
        File file = new File("b.txt");
        boolean b = file.createNewFile();
        System.out.println(b);
        //删除文件,不走回收站，删除成功返回true 删除失败返回false
        boolean b1 = file.delete();
        System.out.println(b1);

        File file1 = new File("C:\\Users\\57642\\Desktop\\abc\\aa\\bb");
        //delete() 只能删除空目录，非空目录，无法直接删除。
        boolean b2 = file1.delete();
        System.out.println(b2);
    }

public static void main(String[] args) throws IOException {
        //修改的文件
        File file = new File("c.txt");
        //新命名的文件
        File file1 = new File("C:\\Users\\57642\\Desktop\\bb.txt");
        //renameTo() 你要修改的文件和你传入的新文件如果两个文件的父目录
        //相同，那么就是重命名
        //你要修改的文件和你传入的新文件如果两个文件的父目录不相同，那就是
        //剪贴。
        boolean b = file.renameTo(file1);
        System.out.println(b);
    }

public static void main(String[] args) throws IOException {
        //要修改的文件
        File file = new File("new.txt");
        file.createNewFile();
        File file2 = new File("./new2.txt");
        file2.createNewFile();
        //file file2在同一级目录

        File file3 = new File("../new.txt");
        file3.createNewFile();
        //file3上一级目录

        File file4 = new File("../../new.txt");
        file4.createNewFile();
        //file4上两级目录
    }

19.14_File类的判断和获取功能

  A：判断功能
  		public boolean isDirectory()：判断是否是目录
  		public boolean isFile()：判断是否是文件
  		public boolean exists()：判断是否存在
  		public boolean canRead()：判断是否可读
  		public boolean canWrite()：判断是否可写
  		public boolean isHidden()：判断是否隐藏
  		public boolean isAbsolute()：判断是否使用的是绝对路径
  B：获取功能
  		public String getAbsolutePath()：获取绝对路径
  		public String getPath()：获取相对路径
  		public String getParent()：返回此抽象路径名父目录的路径名字符串，
  								   如果此路径名没有指定父目录，则返回null
  		public File getParentFile()：返回此抽象路径名父目录的抽象路径名，
  									 如果此路径名没有指定父目录，则返回
  									 null
  		public long getTotalSpace()：返回抽象路径名指定的区分大小。返回
  									 总容量，单位字节
  		public long getFreeSpace()：返回此抽象路径名指定的分区中未分配的
  									字节数。返回剩余容量，单位字节
  		public String getName()：获取名称
  		public long length()：获取长度。字节数
  		public long lastModified()：获取最后一次的修改时间，毫秒值
  		public String[] list()：获取指定目录下的所有文件或者文件夹的名称
  								数组
  		public File[] listFiles()：获取指定目录下的所有文件或者文件夹的
  								   File数组

public static void main(String[] args) throws IOException {
        File file = new File("new.txt");
        file.createNewFile();
        if(file.isFile()){
            System.out.println("是文件");
        }
        if(file.isDirectory()){
            System.out.println("是目录");
        }else{
            System.out.println("不是目录");
        }
        if(file.exists()){
            System.out.println("文件存在");
        }
    }

public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\57642\\Desktop\\a.txt");
        if(file.isAbsolute()){
            System.out.println("是绝对路径");
        }else{
            System.out.println("不是绝对路径");
        }

        if(file.canRead()){
            System.out.println("可读");
        }
        if(file.canWrite()){
            System.out.println("可写");
        }else{
            System.out.println("不可写");
        }

        if(file.isHidden()){
            System.out.println("隐藏文件");
        }else{
            System.out.println("不是隐藏文件");
        }
    }

public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\57642\\Desktop\\a.txt");
        //获取文件的大小，单位是字节
        long size = file.length();
        System.out.println(size);
        //获取文件名
        String name = file.getName();
        System.out.println(name);
        //获取文件的父路径,返回的是字符串形式
        String parent = file.getParent();
        System.out.println(parent);
        //获取文件的父路径,返回的是File形式,这种方式更加灵活
        File parentFile = file.getParentFile();
        System.out.println(parentFile.toString());
    }

public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\57642\\Desktop\\a.txt");
        //获取文件的绝对路径，返回的是字符串形式
        String absolutePath = file.getAbsolutePath();
        System.out.println(absolutePath);
        //获取文件的绝对路径，返回的是File形式的
        File absoluteFile = file.getAbsoluteFile();
        System.out.println(absoluteFile);
        File file1 = new File("new.txt");
        String path = file1.getPath();
        System.out.println(path);
    }

public static void main(String[] args) throws IOException {
        File file = new File("F:\\");
        //获取总空间大小单位是字节 1byte=8bit  1kb=1024byte  1M=1024kb  1G=1024M

        long totalSpace = file.getTotalSpace();
        System.out.println(totalSpace / 1024 / 1024 / 1024.0 + "GB");

        //获取剩余空间
        long freeSpace = file.getFreeSpace();
        System.out.println(freeSpace / 1024 / 1024 / 1024.0 + "GB");

        //已用空间=总空间-剩余空间
    }

public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\57642\\Desktop\\a.txt");
        //获取文件的最后一次修改时间，返回的是毫秒值
        long time = file.lastModified();
        System.out.println(time);
        Date date = new Date(time);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println(format);
    }

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

  A：文件名称过滤器的概述
  			public String[] list(FilenameFilter filter)
  			public File[] listFiles(FilenameFilter filter)

public static void main(String[] args) throws IOException {
        //  public String[] list ():获取指定目录下的所有文件或者文件夹的
        //							名称数组
        //  public File[] listFiles ():获取指定目录下的所有文件或者文件
        //							   夹的File数组
        File file = new File("C:\\Users\\57642\\Desktop\\abc");
        //获取指定目录下的所有文件或者文件夹的名称数组
        String[] list = file.list();
        for (String s : list) {
            System.out.println(s);
        }
    }

public static void main(String[] args) throws IOException {
        //  public File[] listFiles ():获取指定目录下的所有文件或者文件
        //							   夹的File数组
        File file = new File("C:\\Users\\57642\\Desktop\\abc");
        File[] files = file.listFiles();
        for (File file1 : files) {
            System.out.println(file1.getName() + "=====" + file1.length());
            if(file1.getName().endsWith(".png")){
                file1.delete();
            }
        }
    }

public static void main(String[] args) throws IOException {
        /* A:
        案例演示:
        需求：判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件
        	 名称
        分析:*/
        File file = new File("C:\\Users\\57642\\Desktop\\abc");
        File[] files = file.listFiles();
        for (File file1 : files) {
            if(file1.getName().endsWith(".jpg") && file1.isFile()){
                System.out.println(file1.getName());
            }
        }
    }

public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\57642\\Desktop\\abc");
        File[] files = file.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                //System.out.println("过滤的方法执行了" + dir + "===" + name);
                //dir 父目录
                File file1 = new File(dir, name);
                if(file1.isFile() && name.endsWith(".jpg")){
                    return true;
                }
                //返回true 符合条件就会把文件过滤到文件数组中，返回false
                //表示不符合条件，不会过滤到数组中
                return false;
            }

        });
        System.out.println(Arrays.toString(files));
    }

public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\57642\\Desktop\\abc");
        File[] files = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File f) {
                //System.out.println(pathname);
                //返回true 符合条件就会把文件过滤到文件数组中，返回false
                //表示不符合条件，不会过滤到数组中
                return f.isFile() && f.getName().endsWith(".jpg");
            }
        });
        for (File file1 : files) {
            System.out.println(file1);
        }
    }

LCYeezus

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java IO流概述异常 File文件类

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

扫一扫