Java入门7(异常处理,list集合)

这篇具有很好参考价值的文章主要介绍了Java入门7(异常处理,list集合)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

异常处理(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特点:文章来源地址https://www.toymoban.com/news/detail-436335.html

  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);
}

到了这里,关于Java入门7(异常处理,list集合)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • C#中try-catch语句

            在C#中,try-catch语句是一种异常处理机制,用于捕捉代码中发生的异常并作出相应的处理,防止程序因异常而崩溃。 try块中包含可能会出现异常的语句或代码块。当try块中的语句或代码块执行过程中发生异常时,程序会立即跳转到catch块,并执行catch块中的语句。

    2024年02月14日
    浏览(40)
  • try-catch以及使用技巧

    try-catch 是 JavaScript 处理错误的一种重要机制。try 块用来包含可能会出错的代码,catch 块用来处理 try 块中的错误。使用 try-catch 的主要目的是在代码出错时不会导致整个程序崩溃,可以让错误被妥善处理。 如果你想捕获代码中所有可能的异常,可以使用一个不带参数的 catch 代码

    2024年02月22日
    浏览(42)
  • C++ try-catch语法分析与应用

    通过前面的学习,我们了解了try-catch语法的基本使用。但是,C++提供的异常处理机制很全面,下面再具体分析。 发生异常的时候,我们可以主动抛出一个异常,所以,使用throw抛出一个异常。异常可以是一个数值,字符,或者表达式。 抛出的异常可以有try-catch语句捕获。tr

    2024年02月16日
    浏览(42)
  • 【Java练习题汇总】《第一行代码JAVA》异常处理篇,汇总Java练习题——异常的概念及处理标准格式(try、catch、finally、throws、throw)、断言机制 Assertion ~

    一、填空题 Throwable 下的两个子类是______________ 、______________ 。 ArthmeticException 类表示______________ 异常, ArraysIndexOutOfBoundsException 表示______________ 异常。 一个 try 代码后面必须跟着若干个_______ 代码段或者一个_______ 代码段。 如果一个方法使用了_______ , 则编译器会强制在使用此

    2024年02月16日
    浏览(41)
  • kotlin协程异常处理之-try catch

    kotlin协程小记 协程的async使用 kotlin协程异常处理之-try catch kotlin协程异常处理之-CoroutineExceptionHandler try catch是否一定有效呢?未必,来看一下: withContext是一个挂起函数,它会暂停当前协程的执行,等待传递进来的协程上下文切换后继续执行。当在withContext内部发生异常时,

    2024年02月12日
    浏览(34)
  • 优雅而高效的JavaScript——try...catch语句(js异常处理)

    😁博主:小猫娃来啦 😁文章核心: 优雅而高效的JavaScript——try…catch语句 异常处理软件开发中扮演着至关重要的角色。无论是前端还是后端开发,JavaScript作为一种常用的编程语言,异常处理对于保证程序的健壮性和可靠性至关重要。下面将详细阐述异常处理的重要性,并

    2024年02月04日
    浏览(42)
  • JavaScript的try-catch-finally异常处理机制--详解

    JavaScript 提供了异常处理机制,通过 try-catch-finally 语句块来捕获和处理异常。以下是对该机制的详细解释和示例: 1. try 块: try 块用于包裹可能会产生异常的代码块。在 try 块内,您可以放置任何可能引发异常的代码。 2. catch 块: catch 块用于捕获和处理 try 块中抛出的异常。

    2024年02月11日
    浏览(54)
  • 面试官:try-catch 到底写在循环里面好,还是外面好?大部分人都会答错!

    面试官: try-catch 到底写在循环里面好,还是外面好? 这个问题,我相信大部分人都会答错! 很多人会说当然写在循环外面好,也有一部分人说写在循环里面好,其实这两种回答都不完全对,我们来分析下两者的弊端。 try-catch 写在循环外面的弊端: 如果 try-catch 写在循环外

    2024年02月16日
    浏览(40)
  • C#,入门教程(30)——扎好程序的笼子,错误处理 try catch

    上一篇: C#,入门教程(29)——修饰词静态(static)的用法详解 https://blog.csdn.net/beijinghorn/article/details/124683349 程序员语录: 凡程序必有错,凡有错未必改! 程序出错的原因千千万,只有扎好程序的笼子才尽量不至于造成大错。 数据操作(比如:除0,超范围),尤其是文件与

    2024年01月22日
    浏览(44)
  • try catch捕获异常并打印报错行号等信息

    在我们系统中,如果某一行代码报错了,我们打印日志的时候却不知道具体报错行号,报错信息等等。 如何才能打印报错行号呢? 我们拿到Exception对象后,首先要拿到错误的堆栈信息,可以通过下面方法拿到: 拿到堆栈信息后,那么我们就可以获取具体的报错信息了. 通过

    2024年02月12日
    浏览(92)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包