异常机制和File类

异常:

1.1 基本概念

• 异常就是"不正常"的含义，在Java语言中主要指程序执行中发生的不正常情况。
• java.lang.Throwable类是Java语言中错误(Error)和异常(Exception)的超类。
• 其中Error类主要用于描述Java虚拟机无法解决的严重错误，通常无法编码解决，如：JVM挂掉了 等。
• 其中Exception类主要用于描述因编程错误或偶然外在因素导致的轻微错误，通常可以编码解决， 如：0作为除数等。

1.2 异常的分类

• java.lang.Exception类是所有异常的超类，主要分为以下两种：
• RuntimeException - 运行时异常，也叫作非检测性异常
• IOException和其它异常 - 其它异常，也叫作检测性异常，所谓检测性异常就是指在编译阶段都能 被编译器检测出来的异常。

其中RuntimeException类的主要子类：

• ArithmeticException类 - 算术异常
• ArrayIndexOutOfBoundsException类 - 数组下标越界异常
• NullPointerException - 空指针异常
• ClassCastException - 类型转换异常
• NumberFormatException - 数字格式异常
• 注意： 当程序执行过程中发生异常但又没有手动处理时，则由Java虚拟机采用默认方式处理异常，而默认 处理方式就是：打印异常的名称、异常发生的原因、异常发生的位置以及终止程序。

语法格式:

注意事项

• a.当需要编写多个catch分支时，切记小类型应该放在大类型的前面；
• b.懒人的写法： catch(Exception e) {}
• c.finally通常用于进行善后处理，如：关闭已经打开的文件等。

finally里面如果有return ,有拦截其他return的优先权.

1.5 异常的抛出

基本概念:

• 在某些特殊情况下有些异常不能处理或者不便于处理时，就可以将该异常转移给该方法的调用者， 这种方法就叫异常的抛出。
• 当方法执行时出现异常，则底层生成一个异常类对象抛出，此时异常代 码后续的代码就不再执行。
• 语法格式 访问权限 返回值类型 方法名称(形参列表) throws 异常类型1,异常类型2,...{ 方法体; } 如： public void show() throws IOException{}

方法重写的原则:

• a.要求方法名相同、参数列表相同以及返回值类型相同，从jdk1.5开始支持返回子类类型；
• b.要求方法的访问权限不能变小，可以相同或者变大；
• c.要求方法不能抛出更大的异常； 注意： 子类重写的方法不能抛出更大的异常、不能抛出平级不一样的异常，但可以抛出一样的异常、更小 的异常以及不抛出异常。

       经验分享 若父类中被重写的方法没有抛出异常时，则子类中重写的方法只能进行异常的捕获处理。

                      若一个方法内部又以递进方式分别调用了好几个其它方法，则建议这些方法内可以使用抛出 的方法处理到最后一层进行捕获方式处理。

1.6自定义异常:

实现流程 :

• a.自定义xxxException异常类继承Exception类或者其子类。
• b.提供两个版本的构造方法，一个是无参构造方法，另外一个是字符串作为参数的构造方法。

产生异常:  throw new 异常类型(实参);

异常的声明: throws 异常类型 

class IlleaglNUmberException extends Exception {
    public IlleaglNUmberException(String message) {
        super(message);
    }

    public IlleaglNUmberException(Throwable cause) {
        super(cause);
    }
}

public class TestException {
    public static void main(String[] args) {
        try {
            System.out.println(divide(10, 0));
        } catch (IlleaglNUmberException e) {
            e.printStackTrace();
        }
    }

    public static int divide(int m, int n) throws IlleaglNUmberException {
        try {
            return m / n;
        } catch (ArithmeticException e) {
            throw new IlleaglNUmberException(e);
        }

    }

}

File 类:

java.io.File类主要用于描述文件或目录路径的抽象表示信息，可以获取文件或目录的特征信息， 如：大小等。

 常用方法:

测试代码:

package com.lagou.task16;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;

public class FileTest {

    // 自定义成员方法实现指定目录以及子目录中所有内容的打印
    public static void show(File file) {
        // 获取目录f3下的所有内容并记录到一维数组中
        File[] filesArray = file.listFiles();
        // 遍历数组
        for (File tf: filesArray) {
            String name = tf.getName();
            // 判断是否为文件，若是则直接打印文件名称
            if (tf.isFile()) {
                System.out.println(name);
            }
            // 若是目录，则使用[]将目录名称括起来
            if (tf.isDirectory()) {
                System.out.println("[" + name + "]");
                show(tf);
            }
        }
    }

    public static void main(String[] args) throws IOException {

        // 1.构造File类型的对象与d:/a.txt文件关联
        File f1 = new File("d:/a.txt");
        // 2.若文件存在则获取文件的相关特征信息并打印后删除文件
        if (f1.exists()) {
            System.out.println("文件的名称是：" + f1.getName());
            System.out.println("文件的大小是：" + f1.length());
            Date d1 = new Date(f1.lastModified());
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println("文件的最后一次修改时间：" + sdf.format(d1));
            // 绝对路径： 主要指以根目录开始的路径信息，如：c:/  d:/   /..
            // 相对路径： 主要指以当前目录所在位置开始的路径信息，如：./  ../   相对路径
            System.out.println("文件的绝对路径信息是：" + f1.getAbsolutePath());
            System.out.println(f1.delete()? "文件删除成功": "文件删除失败");
        } else {
            // 3.若文件不存在则创建新的空文件
            System.out.println(f1.createNewFile()? "文件创建成功": "文件创建失败！");
        }

        System.out.println("---------------------------------------------------------");
        // 4.实现目录的删除和创建
        File f2 = new File("d:/捣乱/猜猜我是谁/你猜我猜不猜/死鬼");
        if (f2.exists()) {
            System.out.println("目录名称是：" + f2.getName());
            System.out.println(f2.delete()? "目录删除成功": "目录删除失败");
        } else {
            //System.out.println(f2.mkdir()? "目录创建成功": "目录创建失败");   // 创建单层目录
            System.out.println(f2.mkdirs()? "目录创建成功": "目录创建失败");   // 创建多层目录
        }

        System.out.println("---------------------------------------------------------");
        // 5.实现将指定目录中的所有内容打印出来
        File f3 = new File("d:/捣乱");
        // 获取目录f3下的所有内容并记录到一维数组中
        File[] filesArray = f3.listFiles();
        // 遍历数组
        for (File tf: filesArray) {
            String name = tf.getName();
            // 判断是否为文件，若是则直接打印文件名称
            if (tf.isFile()) {
                System.out.println(name);
            }
            // 若是目录，则使用[]将目录名称括起来
            if (tf.isDirectory()) {
                System.out.println("[" + name + "]");
            }
        }

        System.out.println("---------------------------------------------------------");
        // 6.实现目录中所有内容获取的同时进行过滤
        // 匿名内部类的语法格式：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
        /*FileFilter fileFilter = new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                // 若文件名是以.avi为结尾，则返回true表示保留   否则返回false就是表示丢弃
                return pathname.getName().endsWith(".avi");
            }
        };*/
        // Lambda表达式的格式：(参数列表) -> {方法体}
        FileFilter fileFilter = (File pathname) -> {return pathname.getName().endsWith(".avi");};
        File[] filesArray2 = f3.listFiles(fileFilter);
        for (File tf : filesArray2) {
            System.out.println(tf);
        }

        System.out.println("---------------------------------------------------------");
        // 7.使用递归的思想获取目录以及子目录中的内容
        show(new File("d:/捣乱"));
    }
}

时间转换补充:

LocalDateTime localDateTime = new Timestamp(file.lastModified()).toLocalDateTime();
DateTimeFormatter dateTimeFormatter =DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = dateTimeFormatter.format(localDateTime);
System.out.println(format);

 

统计c:/windows目录的大小：

 public Long fileSize(File f) {
        File[] files = f.listFiles();
        if (files == null) {
            return 0L;
        }
        Long currentDirSize = 0L;
        for (File file : files) {
            if (file.isFile()) {
                currentDirSize += file.length();
            }
            if (file.isDirectory()) {
                currentDirSize += fileSize(file);
            }
        }
        return currentDirSize;
    }

    @Test//统计c:/windows目录的大小.
    public void test4() {
        File f = new File("C:/Windows");
        System.out.println(fileSize(f));
    }

删除文件夹:

public class DelListFile {

    public static  void delFiles(File file){
        File[] files = file.listFiles();
        if(files==null){return;}
        for (File file1 : files) {
            if(file1.isFile()){
                file1.delete();
            }else {
                delFiles(file1);
            }
        }
        file.delete();
    }

    public static void main(String[] args) {
        File file = new File("D:/Program Files");
        delFiles(file);

    }
}

拷贝文件夹:

public class CopyFileList {

    public static void cpoyFile(String src,String dsc){

        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream = new FileInputStream(src);
            fileOutputStream = new FileOutputStream(dsc);
            byte[] buf = new byte[8192];
            int count;
            while ((count = fileInputStream.read(buf)) != -1) {
                fileOutputStream.write(buf, 0, count);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
    }

    public static void cpoyFileList(String src,String dsc){
        File f1=new File(src);
        File f2=new File(dsc);
        if(!f2.exists()){
            f2.mkdir();
        }
        File[] files = f1.listFiles();
        if(files==null){return;}
        for (File file1 : files) {
            if(file1.isFile()){
                cpoyFile(file1.getPath(),dsc+"/"+file1.getName());
            }else {
                cpoyFileList(file1.getPath(),dsc+"/"+file1.getName());
            }
        }
    }

    public static void main(String[] args) {
        cpoyFileList("C:\360Downloads\wpcache","C:\360Downloads\test");
    }
}