java之集合总结，异常（try...catch...finally，抛出throws）

最新推荐文章于 2021-03-28 00:15:32 发布

时光仍在

最新推荐文章于 2021-03-28 00:15:32 发布

阅读量369

点赞数

分类专栏： java 文章标签：异常分类和处理集合总结 try...catch和finally 抛出异常throws和throw java

java 专栏收录该内容

38 篇文章 1 订阅

订阅专栏

一. 集合总结

1. 单列集合 (Collection)
  1.1 线程不安全的  jdk1.2
    ArrayList   查询快 增删慢(相对)
    LinkedList  查询慢 增删快(相对)
    HashSet     去重
    TreeSet     排序
    LinkedHashSet   除了去重 还有存取顺序

  1.2 线程安全的 jdk 1.0  完全被ArrayList替代
   Vector 

2.双列集合(Map) 
   2.1线程不安全的 jdk 1.2
    HashMap
    LinkedHashMap
    TreeMap

   2.2 线程安全的 jdk 1.0 被HashMap替代
    Hashtable

3.HashMap 和 Hashtable 区别?
    Hashtable : 保存null值 运行时报错
    HashMap : 可以保存null值

代码例子：

public class Demo01 {
    public static void main(String[] args) {
        // HashMap
        HashMap<String, Integer> map = new HashMap<>();
        map.put(null, 22);
        map.put("kll", null);
        //System.out.println(map);
        //Hashtable
        Hashtable<String, Integer> map1 = new Hashtable<>();
        map1.put(null, 33);
    }
}

运行结果：这里写图片描述

二.异常

1.异常类
Throwable：所有异常的父类。
包含：1. Error(数据库奔溃系统奔溃)[自己无法解决]。2.Exception(异常类)。
RuntimeException：运行时异常，是Exception异常类的子类。
2.异常的处理方式
2.1 异常处理方法: ① 自己处理。②交给上级去处理(该方法是谁调用的谁就是上级)

常见异常出现的代码：

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

        int[] array = {12, 5, 3};
        // 2.越界异常
        //System.out.println(array[3]);
        // 1. 空指针异常
        //array = null;
        //System.out.println(array[0]);
        // 3.算术异常
        int a = 10 / 0;
    }
}

    main 函数中，发生异常，默认交给方法的调用者（JVM虚拟机）处理。
      处理过程：
     1. 打印错误信息 / by zero
     2.打印异常类  java.lang.ArithmeticException
     3.打印错误发生的位置  Kll.java:15
     4.将程序停止

2.2 异常的处理方法:


 * try.....catch.........finally
 * try:存放可能发生异常的代码
 * catch:匹配异常类的对象
 * finally:异常匹配完毕后 肯定会执行的代码
 * 
 * 使用try处理
 *  1.程序不会停止,会继续向下执行
 *  2.catch 成功后 执行括号中语句
 *  3.括号中语句执行完毕后,程序继续执行
 *  
 * 用try...catch处理异常的流程:
 *  catch处理 异常时,可以使用多个catch语句
 *  try中,可能发生多个类型的异常
 *   匹配时注意,类要从小往大依次书写
 *   
 *   
 *   Java安卓(移动端)
 *   移动端处理异常 try...catch  处理的方式 打印一下
 *   
 *   JavaEE(网站端)
 *   try...catch  处理后,会将发生错误跳过去(忽略过去)
 *   需要将错误写入日志中

用try…..catch处理异常代码：

public class Kll {
    public static void main(String[] args) {
        TestException test = new TestException();

        try {
            // new ArithmeticException("/by zero");
            // 异常对象 返回后,int类型接受不了
            // 异常对象 会向下与catch进行匹配
            // 匹配成功,执行catch后边括号内的代码
            // 异常处理完毕后,不会停止程序,会继续向下执行

            int rel = test.division(10, 0);
            // 注意: 异常发生后,异常发生的语句之后的语句不会执行,会直接匹配catch语句
            System.out.println("try语句停止");
        } catch (ArithmeticException e) {//ArithmeticException 或者 Exception都可以
            // 多态对象创建
            // Exception e = new ArithmeticException("/by zero")
            // 括号中填的是 要匹配的 异常类的引用
            System.out.println("catch语句");
        }
        System.out.println("已停止");
    }
}
// 测试异常处理
class TestException{
    public int division(int a, int b) {
        /*
         * 10 / 0 发生算术异常
         * 产生了一个算术异常对象 并且携带了异常信息
         * new ArithmeticException("/by zero");
         * 将这个创建好的异常对象,返回给方法的调用者
         */
        return a / b;
    }
}

3.finally
3.1finally特点:

无论发生异常与否.(除非用System.exit(0) 关闭虚拟机)
finally中的语句,一定会被执行
作用是:
数据库部分用于关闭数据库
流部分用于关闭资源流
final finally finalize 三个关键词有什么关系?
没关系
final(绝育) 修饰变量,方法,类
finally (遗言) 异常处理部分使用,关闭资源
finalize 方法名，Object类中的方法名。
当对象成为垃圾时,系统会自动调用该方法,将对象销毁。

finally代码例子：

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

        try {
            int num = 10 / 1;
            System.out.println(num);
            return;
        // return，结束方法，但是finally里的语句还是会执行
        } catch (Exception e) {
            System.out.println("catch语句处理");
        } finally {
            System.out.println("finally语句");
        }
        System.out.println("程序停止");
    }
}

4.用抛出解决异常的方式

4.1throw 和 throws区别：

写法:
throw : 后边跟的是抛出异常的对象
throws :后跟的是异常类的类名
位置:
throw :方法中
throws :方法上
作用:
throw :抛出一个异常对象
throws :标识方法，携带一个异常
4.2案例

/*案例需求：
    创建一个人类 有name 和 age
    要求 人类的年龄赋值时 要在 0 到 120岁之间*/

1️⃣创建人类
就直接用携带异常的方式，进行处理范围。

public class Person {
    private String name;
    private int age;
    // 构造方法
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    // set/get方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    // 控制年龄范围 0 - 120
    // 抛出异常的方法,需要在方法上标识一下
    // 该方法可能会接收到 异常对象
    // 关键词 throws  标识方法,有异常
    // throws + 异常类型
    public void setAge(int age) throws Exception{
        if (age > 0 && age < 120) {
            this.age = age;
        }else {
            // 抛出一个异常对象 提示用户赋值错误
            // Exception e =
            // new Exception("AgeOutOfBounds " + "Age: " + age);
            // 谁调用了 该方法,就抛给谁
            // 关键词 throw

            // 创建自定义异常类的对象
            AgeOutOfBoundsException e = new AgeOutOfBoundsException("AgeOutOfBounds " + "Age: " + age);
            throw e;
        }
    }
    // toString方法
    @Override
    public String toString() {
        return "[name=" + name + ", age=" + age + "]";
    }

}
// 自定义 异常类
// 核心:类名(见名知意,类名就能反映出异常的类型)
// 年龄超出了范围
// 需要提供构造方法
class AgeOutOfBoundsException extends Exception{

    public AgeOutOfBoundsException() {
        super();
    }

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

}

2️⃣主函数

public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("kll");
        // 自己处理,使用try..catch
        /**try {
            person.setAge(130);
            System.out.println(person);
        } catch (Exception e) {
            // 打印异常信息
            // 第一种
            //System.out.println(e.getMessage());
            //e.getMessage();
            // 打印信息 错误位置
            // 第二种
            e.printStackTrace();
        }*/
        // 交给上级处理
        // 将异常在方法上抛出 即在main方法上 抛出  throws 异常类名
        try {
            person.setAge(130);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

五.异常的分类:

1.运行时异常(程序员犯的错,需要将程序停下来修改错误)[RuntimeException]
例如: 空指针,越界
特点： 1.不强制处理. 2.一旦发生运行时异常,程序会立即停止(不处理的情况下)
2.编译时异常(除了运行时异常,剩下的全是编译时异常)
未雨绸缪(有可能发生错误,提前为这个错误做准备)
特点: 系统强制你对编译时异常进行处理。

时光仍在

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java之集合总结，异常（try...catch...finally，抛出throws）

一. 集合总结1. 单列集合 (Collection) 1.1 线程不安全的 jdk1.2 ArrayList 查询快增删慢(相对) LinkedList 查询慢增删快(相对) HashSet 去重 TreeSet 排序 LinkedHashSet 除了去重还有存取顺序 1.2 线程安全的 jdk 1.0 ...
复制链接

扫一扫

专栏目录