1. Python技术站首页
  2. 其他
  3. Java

Java入门7（异常处理，list集合）

• Java

异常处理（try-catch）

错误的种类

一般来讲，程序出现错误的时候，大致情况有三种：

  1. 语法错误
  2. 运行时错误，指的是各程序运行的时候，出现的一些没有想到的问题，比如除数为0，比如数组下标越界等等
  3. 逻辑错误，运行结果和与其结果不一致，俗称bug

⭐Java中的异常处理机制主要用于处理运行时错误

异常的定义

​ 运行时发生的错误，叫做异常，处理这些异常的代码叫做异常处理，一旦发生异常，程序将会中止在异常发生的地方，之后的代码都不会被运行

public static void main(String[] args) {
    // 这句输出会抛出异常
    System.out.println(1/0);
    // 这句输出就不会被执行
    System.out.println("tmp_text");
}

异常的处理方式

​ Java使用面向对象的方法来处理异常，在方法的执行过程中，如果出现了异常，该方法就会自动创建一个代表该异常的一个对象，将其交给运行时的系统，运行时系统自动查找对应的代码来处理这个异常，在这个过程中，生成异常，并且将其交给运行时系统的过程叫做抛出异常（throw），运行时系统，找到能处理该异常的对象的过程叫做捕获异常（catch）

异常类（Throwable类）

​ 根据javac对异常处理的要求，把异常分为两类

  1. 非检查异常-运行时异常（RunTImeException）：程序本身问题导致的异常，运行时异常并不一定需要做异常处理，不做异常处理，代码也可以通过编译
  2. 检查时异常（ChackedException）：检查时异常，可能产生检查时异常的代码，不管是否产生了异常，都必须进行异常处理，负责无法通过编译，检查时异常大部分情况下和开发者无关，只和代码之外的环境有关

处理异常的方法（Try--Catch）

​ Try 负责存放可能会产生异常的代码，catch 负责捕捉异常

​ 异常处理在很多的时候，只能保证哪怕发生了异常，代码整体也可以正常的运行，但是不能解决异常的问题，还是需要有开发者自己修改代码，从根源上解决问题

// 运行时异常
// 除数为0异常是个典型的运行时异常，运行时异常并不一定需要做异常处理，不做异常处理，代码也可以通过编译
public void test(){
    try{
        // 会产生除数为0的异常
        System.out.println(1/0);
    }catch (Exception e){
        // 打印异常相关的堆栈信息，但是并不是一定要写
        e.printStackTrace();
    }
    System.out.println("异常被处理了之后，程序依旧可以往下运行！");
}

// 检查时异常
// 不管代码是否发生异常，都需要进行异常处理，负责无法通过编译，检查时异常大部分情况下和开发者无关，只和代码之外的环境有关
public void test(){
    try {
        // 检查时异常，必须使用try——catch进行处理
        Class.forName("com.test");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    System.out.println("异常被处理了之后，程序依旧可以往下运行！");
}

// 如果有多条可能发生异常的语句，最好每一个语句单独处理，多条语句同时进行异常处理，会出现代码少运行的问题

finally关键字

​ 确保在异常发生的时候，所有的收尾工作可以正常的完成，无论是否发生异常，finally代码块中的语句都会执行

⭐如果在catch代码块中出现了return，那么也必须先执行finally中的代码之后，再return退出

// 发生异常时： try -> catch -> finally
// 没有发生异常时：try -> finally
public void test(int tmp) {
    try {
        System.out.println("test -> try()");
        tmp = 1 / tmp;
    } catch (ArithmeticException e) {
        System.out.println("test -> catch()");
    } finally {
        System.out.println("test -> finally()");
    }
}
// tmp = 1:
// 	test -> try()
// 	test -> finally()
// tmp = 0:
// 	test -> try()
// 	test -> catch()
// 	test -> finally()

throw关键字

​ 可以借助throw关键字，主动抛出一个指定类型的异常

public void test(){
    try {
        // 主动抛出一个空指针异常
        throw new NullPointerException();
    }catch (NullPointerException e){
        System.out.println("捕获了异常");
    }
}

throws关键字

​ 如果某个方法不想处理异常，可以使用throws向上抛出异常，让上层的调用者进行异常处理

public class Test04 {
    // test01负责抛出异常
    public void test01(){
        throw new NullPointerException();
    }
    // test02运行test01时触发异常，但是并没有处理，使用throws向上抛出了此异常
    public void test02() throws NullPointerException{
        test01();
    }
    // test03处理test02向上抛出的异常
    public void test03(){
        try {
            test02();
        }catch (NullPointerException e){
            System.out.println("捕获了异常");
        }
    }
}

throw 和throws 的区别

  1. throw时语句抛出一个异常，throws是方法抛出一个异常
  2. throws可以单独使用，但是throw后面必须跟一个明确的异常对象
  3. throws出现方法的头，throw出现再方法体
  4. throws表现的是出现异常的一种可能性，并不代表以后一定会出现异常，但是throw一定会抛出异常
  5. 两种都是异常处理的消极方式，最终还是需要使用try_catch进行异常处理

常见异常类型

  1. RuntimeException：所有运行时异常的父类
  2. ArithmeticException：算数错误异常
  3. IllegalAccessError：方法接收到非法参数异常
  4. ArrayIndexOutOfBoundsException：数组下标越界异常
  5. NullPointerException：空指针异常
  6. ClassNotFoundException：找不到类异常
  7. IOException：IO流异常
  8. FileNotFoundException：找不到文件异常
  9. EOFException：数据流相关异常
  10. NoSuchMethodError：找不到方法异常
  11. NumberFormatException：数字转换异常

自定义异常

​ 自定义异常类，必须是Throwable类的子类，我们需要在某一个固定场景下，通过throw去抛出这个异常

// 自定义异常 TestException
public class TestException extends Throwable{
    public TestException(String tmp){
        super(tmp);
    }
}
// test中使用自定义异常
public void test(String name){
    try {
        throw new TestException(name);
    } catch (TestException e){
        e.printStackTrace();
    }
}

集合

两大类集合

  1. Collection 单列集合：本身是一个接口
  2. Map 双列集合（以后再说）

Collection接口

​ 该接口定义的是所有单列集合所具有的共性方法

public void test(){
    // 使用多态的方法新建ArrayList集合
    Collection c01 = new ArrayList();
    Collection c02 = new ArrayList();
    // 往集合里添加数据
    for (int i = 0; i < 5; i++) {
        c01.add("robot0" + i);
    }
    for (int i = 6; i < 10; i++) {
        c02.add("robot0" + i);
    }
    // 删除集合内元素
    c01.remove("robot01");
    // 判断集合是否为空
    System.out.println(c01.isEmpty());
    // 输出集合内元素个数
    System.out.println(c01.size());
    // 合并两个集合
    c01.addAll(c02);
    // 遍历集合
    for (Object o : c01) {
        System.out.print(o + "\t");
    }
    System.out.println();
    // 判断c01中是否含有c02中的所有元素
    System.out.println(c01.containsAll(c02));
    // 判断c01中是否有"robot03"这个元素
    System.out.println(c01.contains("robot03"));
    // 从c01中移除所有c02中的元素
    c01.removeAll(c02);
    // 重新遍历集合
    for (Object o : c01) {
        System.out.print(o + "\t");
    }
}

集合的泛型

​ 泛型大部分情况下适用于集合，泛型的作用，在使用的时候去限制数据的类型范围

public class Dog {
    private String name;
    private String type;
}
public class Student {
    private int sno;
    private String name;
}
// 创建一个集合，这个集合只能存储dog类的对象的地址
public void test(){
    List<Dog> dogList = new ArrayList<>();
    Dog dog01 = new Dog("001","Dog01");
    Dog dog02 = new Dog("002","Dog02");
    Dog dog03 = new Dog("003","Dog03");
    // 这个dogList只能存储Dog类型的对象，因此集合使用泛型，可以限制集合中存储的数据类型
    dogList.add(dog01);
    dogList.add(dog02);
    dogList.add(dog03);
}

// 创建一个集合，这个集合只能存储dog类和Student类的对象的地址
// 扩展集合类型，需要使用接口的概念
public class Student implements Animal{
    private int sno;
    private String name;
}
public class Dog implements Animal{
    private String name;
    private String type;
}
//两个类同时继承同一个接口类
public void test(){
    List<Animal> animalList = new ArrayList<>();
    Dog dog01 = new Dog("001","Dog01");
    Dog dog02 = new Dog("002","Dog02");
    Dog dog03 = new Dog("003","Dog03");
    Student student01 = new Student(1001,"Robot01");
    // 这个dogList只能存储Dog类型的对象，因此集合使用泛型，可以限制集合中存储的数据类型
    animalList.add(dog01);
    animalList.add(dog02);
    animalList.add(dog03);
    animalList.add(student01);
}

List接口常用实现类

list接口相对于collection额外多了一些get，set方法

三个常用实现类：ArrayList（不保证线程安全，性能稍好），LinkedList（底层是链表），Vector（已经弃用）

List特点：

1. 有序集合：存储元素的顺序和读取元素的顺序一致
1. 允许存储重复的元素
1. 有索引，可以使用普通的for循环进行遍历

public void test(){
    List list01 = new ArrayList();
    // list添加元素
    for (int i = 0; i < 5; i++) {
        list01.add("robot0 " + i);
    }
    // 遍历list
    System.out.println(list01);
    // 指定位置改变
    list01.set(1,"ROBOT");
    System.out.println(list01);
    // 指定位置插入
    list01.add(5,"robot pro");
    System.out.println(list01);
}
List的遍历方式
// 1. for循环遍历
for(int i = 0 ; i<list.size();i++){
    System.Out.Print(list.get(i) + "\t");
}

// 2. 增强for循环遍历
for (Object o : list) {
    System.out.print(o + "\t");
}

// 3.迭代器遍历（游标）
// 获取集合对应的迭代器对象
Iterator iterator = list.iterator();
// 只要集合没有遍历完，循环就一致执行下去
while(iterator.hasNext()){
    // 调用迭代器的next方法，从集合中取出下一个元素
    Object tmp = iterator.next();
    System.out.print(tmp + "\t");
}

// 4.直接输出遍历，遍历原理见toString源码分析
System.out.println(list);



// 迭代器删除陷阱：
// 	使用迭代器进行数据删除的时候，必须使用迭代器自己的remove方法
while(iterator.hasNext()){
    Object tmp = iterator.next();
    if (tmp.equals("robot 03")){
	    //list.remove(tmp); 
        // 不能使用原集合自身的remove方法，会报错！！！
        // 需要使用迭代器提供的remove方法
        iterator.remove();
    }
}

toString源码分析

public String toString() {
    Iterator<E> it = iterator();  // 获取集合对应的迭代器
    if (! it.hasNext())  // 如果没有下一个元素，直接返回[]
        return "[]";

    StringBuilder sb = new StringBuilder();  // 定义了一个StringBuilder对象
    sb.append('[');
    for (;;) {
        E e = it.next();  // 取出集合的下一个元素
        sb.append(e == this ? "(this Collection)" : e);  // 判断集合所存储的元素是否是集合自己的内存地址，如果不是，进行元素拼接
        if (! it.hasNext())  // 发现遍历结束
            return sb.append(']').toString();  // 拼接结束符号，然后返回拼接结果
        sb.append(',').append(' ');
    }
}

Set接口常用实现类

三个常用实现类：TreeSet（基于Java红黑树，底层map），HashSet（哈希表，底层map），LinkedHashSet（）

Set特点：

  1. 不允许存储重复元素
  2. 没有索引，不能通过普通for循环遍历
  3. 不保证有序：存储顺序有可能和读取顺序不一致

Collections工具类

public void test(){
    List<String> list = new ArrayList<>();
    // 打乱顺序
    Collections.shuffle(list);
    // 将a位置和b位置交换
    Collections.swap(list,a,b);
    // 倒序排列
    Collections.reverse(list);
    // 向后位移n位
    Collections.rotate(list,n);
    // 将指定集合转换位一个线程安全的类
    Collections.synchronizedList(list);
    // 排序，需要提供比较器（Comparable 或 Comparator）
    Collections.sort(list);
}

原文链接：https://www.cnblogs.com/te9uila/p/17380953.html

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Java入门7（异常处理，list集合） - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月8日
下一篇 2023年5月8日

相关文章

  • 解决Tomcat启动报异常java.lang.ClassNotFoundException问题

    下面是解决Tomcat启动报异常java.lang.ClassNotFoundException问题的完整攻略。 问题背景 在使用Tomcat启动项目时，有时候会出现java.lang.ClassNotFoundException异常，这是因为Tomcat无法找到相关的类文件。在这种情况下，需要进一步排查问题并解决它。 解决方法 1. 检查类路径 首先，需要…

    Java 2023年5月19日
    00

  • Java实现一致性Hash算法详情

    Java实现一致性Hash算法 什么是一致性哈希算法？ 一致性哈希算法是一种分布式哈希算法，常用于分布式缓存、分布式数据库等场景，主要解决如何有效地将请求路由到不同的服务器，从而提高系统性能。 一致性哈希算法的原理 一致性哈希算法将每个资源映射到一个二维环上，即将环划分为若干个虚拟节点。当有新的数据需要放入缓存中时，首先将该数据哈希成一个数字，然后将该数字映…

    Java 2023年5月19日
    00

  • java程序员如何编写更好的单元测试的7个技巧

    下面是针对”Java程序员如何编写更好的单元测试的7个技巧”的一份攻略。 技巧1：拆分单元测试 单元测试应该足够小，以至于一个单元测试只需要测试一个方法或函数。这样使得测试容易重复、快速执行和简单调试。拆分单元测试也使测试更精确，因为每个单元测试只测试一个输入和输出组合。 示例： 以下是一个简单的 Java 类，将两个整数相加并返回结果： public cl…

    Java 2023年5月20日
    00

  • flash怎么设计一段Windows屏保动画?

    要设计一段Flash屏保动画，可以按照以下步骤进行： 设计思路 首先，需要确定自己想要展示的内容和效果，例如通过Flash展示公司的产品、服务、广告，或仅仅是提供有趣的图像和声音效果等。具体思路可以从以下两个方面入手： 1. 故事板思路 可以先写好一份脚本，包括主题、剧情和角色等，再通过Flash的故事板功能设置动画内容和每个角色的动作和表情等。这种方式适用…

    Java 2023年6月15日
    00

  • jsp+servlet实现简单登录页面功能(附demo)

    那我就来详细讲解一下“jsp+servlet实现简单登录页面功能(附demo)”的完整攻略。 首先，要了解jsp和servlet的基本概念和用途，jsp主要用于前端页面的展示，servlet主要用于处理后端的业务逻辑和数据交互。在这里，我们需要用到jsp和servlet的合作来实现登录页面功能。 下面我们来分步骤介绍： 步骤一：搭建开发环境 1. 安装JDK…

    Java 2023年6月15日
    00

  • springboot+vue制作后台管理系统项目

    Spring Boot + Vue 制作后台管理系统项目 Spring Boot和Vue.js是两个非常流行的开发框架，它们可以很好地协同工作，用于构建现代化的Web应用程序。本文将介绍如何使用Spring Boot和Vue.js制作一个后台管理系统项目，包括项目搭建、前端页面设计、后端接口开发等。 1. 项目搭建 首先，我们需要创建一个Spring Boo…

    Java 2023年5月14日
    00

  • 解决Maven静态资源过滤问题

    以下是解决Maven静态资源过滤问题的完整攻略： 1. 什么是Maven静态资源过滤问题 Maven静态资源过滤问题指的是，在使用Maven构建项目时，经常会遇到一些静态资源文件（如CSS、JS等）被Maven自动过滤掉的情况，导致这些文件最终无法被打包进最终的应用程序中去，从而影响了应用的正常运行。 2. 解决Maven静态资源过滤问题的方法 解决Mave…

    Java 2023年5月19日
    00

  • Java源码刨析之ArrayQueue

    Java源码刨析之ArrayQueue攻略 前言 在这篇文章中，我们将深入探究Java中ArrayQueue的实现原理。ArrayQueue是一种基于数组实现的队列，它的特点是入队和出队的时间复杂度均为O(1)，空间复杂度为O(n)。其实现原理对于Java初学者而言可能略显复杂，但理解了其原理就可以举一反三，掌握更多队列的实现方式。 代码分析 数据结构 Ar…

    Java 2023年5月26日
    00
合作推广
合作推广
分享本页
返回顶部