java 异常类+常用类+容器、泛型

目录

一、.异常类：

1.捕获和处理异常：

2.抛出：

 3.自定义异常类：

二、包装类、String、BigDecimal

1.包装类：

2.String：

3.Big Decimal：

三、泛型、列表、set、map：

1.泛型：

2.列表：

3.set：

4.map:

---

一、.异常类：

异常是程序运行过程中可能出现的错误情况或有别于一般情况的情况。而java使用异常类来表达这些情况。异常类课分为checked异常和unchecked异常。

checked异常是在编译就可被发现的异常，unchecked异常要在程序运行时才能被发现。

1.捕获和处理异常：

使用try、catch、finally来捕获和处理异常

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.err.println("Error: Division by zero");
        }
    }
}
//输出​ Error: Division by zero

这是因为运算时除数不能为0，属于ArithmeticException，是数学运算时发生错误。

事实上，异常有很多种，这只是一个非常简单的尝试。

下面是一些常见的异常类，在处理它们时只需按照上面的基本格式加以改变即可。

1. NullPointerException (运行时异常)： 当尝试在一个对象引用上调用方法或访问属性，而该引用为null时抛出。

2. IllegalArgumentException (运行时异常)： 当传递给方法的参数不合法或无效时抛出，例如传递了不允许的参数值。

3. IllegalStateException (运行时异常)： 在对象的状态不适合于执行特定操作时抛出，例如在未初始化对象上调用方法。

4. ArrayIndexOutOfBoundsException (运行时异常)： 当尝试访问数组中不存在的索引时抛出。

5. ArithmeticException (运行时异常)： 在数学运算中出现错误时抛出，例如除以零。

6. ClassCastException (运行时异常)： 当试图将一个对象转换为不兼容的类类型时抛出，例如将不是子类的对象转换为某个类的实例。

7. FileNotFoundException (检查异常)： 在尝试打开一个不存在的文件时抛出。

8. IOException (检查异常)： 处理输入输出操作可能出现的异常，例如读写文件、网络通信等。

9. SQLException (检查异常)： 处理数据库访问异常。

10. InterruptedException (检查异常)： 在多线程编程中，当一个线程在等待另一个线程执行某个操作时被中断时抛出。

11. NoSuchElementException (运行时异常)： 当访问集合（如List、Set）中不存在的元素时抛出。

12. OutOfMemoryError (错误)： 在程序尝试分配更多内存而可用内存不足时抛出，通常表示程序内存泄漏或者分配不当。

13. StackOverflowError (错误)： 当递归调用层次过深，导致栈空间耗尽时抛出。

14. NumberFormatException (运行时异常)： 当字符串不能转换为数字时抛出，例如使用Integer.parseInt()方法时传递的字符串格式不正确。

原文链接：https://blog.csdn.net/u011095039/article/details/132478649

2.抛出：

（1）在方法体内用throw抛出异常：抛出异常的对象。

（2）在方法头部使用throws抛出异常。

可以直接在方法内抛出异常，然后在调用者中处理，但是这样在抛出后程序就会终止。

package Test.javawork.hextodecString;

public class HexString{

    public static String hexToDecString(String hexString) throws HexFormatException {
        String regex="^[A-Fa-f0-9]+$";
        if(!hexString.matches(regex))   //该程序中的异常是输入数不是16进制数
        throw new HexFormatException(hexString+"不是16进制");
        return "是16进制";
    }

    public static void main(String[] args) {

        String s = null;
        try {
            s = HexString.hexToDecString("123we");
        } catch (HexFormatException e) {
            e.printStackTrace();
        }
        System.out.println(s);
    }
}

也可以在方法体内直接抛出并处理，这样程序可以继续执行下去。

package Test.javawork.hextodecString;
public class HexString{

    public static String hexToDecString(String hexString) {
        String regex="^[A-Fa-f0-9]+$";
        if(!hexString.matches(regex))
            try {
                throw new HexFormatException(hexString+"不是16进制");
            } catch (HexFormatException e) {
                e.printStackTrace();
            }
        return "是16进制";
    }

    public static void main(String[] args) {

        String s = HexString.hexToDecString("123we");
        System.out.println(s);

    }
}

 3.自定义异常类：

除去java自带的异常类，我们也可以自己定义异常类。

public class XXXXException extends Exception 或者RuntimeException{
          添加一个空参构造方法
          添加一个带异常信息的构造方法
  }

若继承的是Exception，则其为编译期异常，需要通过try-catch处理异常。

若继承RuntimeException，则其为运行期异常，直接抛出交给虚拟机处理即可。

二、包装类、String、BigDecimal

1.包装类：

java中有Byte、Short、Integer、Long、Float、Double、Boolean、Character8个包装类。

基本数据类型和包装类对象可以互相转化。

以int为例，valueOf（）将int型数据转Integer，num1.intValue()将Integer转化为int。

为了便于写代码，有自动拆箱装箱机制。

Integer  num1 = 1;		//自动装箱
int num2 = num1;		//自动拆箱

2.String：

（1）buffer：StringBuffer的内容和长度都是可以改变的，而String不能。

StringBuffer sb1 = new StringBuffer();

（2）builder：有无参构造和带参构造两种方法：

public static void main(String[] args) {
	StringBuilder sb1 = new StringBuilder();
	System.out.println(sb1); // (空白)
	// 带参构造
	StringBuilder sb2 = new StringBuilder("1234");
	System.out.println(sb2); // 1234
}

3.Big Decimal：

用于对于超过16位小数的数进行精确的运算，并且在运算时不能使用传统的‘+’，‘-’等运算符，而是要使用对应的方法。

import java.math.BigDecimal;

public class Test {
    public static void main(String[] args){
        BigDecimal b1 = new BigDecimal("1");
        BigDecimal b2 = new BigDecimal("2");
        BigDecimal b3 = new BigDecimal("3");
        System.out.println("相加："+b1.add(b2));
        System.out.println("相减："+b1.subtract(b2));
        System.out.println("相乘："+b2.multiply(b3));
        System.out.println("相除："+b2.divide(b3));
    }
}

三、泛型、列表、set、map：

1.泛型：

泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。

public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;

    public Generic(T key) {
        this.key = key;
    }

    public T getKey(){
        return key;
    }
}
//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
Generic<Integer> genericInteger = new Generic<Integer>(123456);

Generic<String> genericString = new Generic<String>("key_vlaue");

Log.d("泛型","key is " + genericInteger.getKey());
Log.d("泛型","key is " + genericString.getKey());

//结果为 key is 123456
//结果为 key is key_vlaue

2.列表：

列表是一个有序，可重复的集合，可以通过索引访问指定位置的元素，也可删除元素。

import java.util.List;
import java.util.ArrayList;
 
public class Main {
 
    public static void main(String[] args) {
        //使用ArrayList类创建列表
        List<Integer> numbers = new ArrayList<>();
 
        //将元素添加到列表
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        System.out.println("List: " + numbers);
 
        //从列表中访问元素
        int number = numbers.get(2);
        System.out.println("访问元素: " + number);
 
        //从列表中删除元素
        int removedNumber = numbers.remove(1);
        System.out.println("删除元素: " + removedNumber);
    }
}

3.set：

set 一次只能添加一个元素，并且其中的元素不能重复，由于其存储结构不是线性的，因此不能用索引进行访问。由于set是一个接口，因此我们在创建时必须指定一个实现类，可以为HashSet或TreeSet，两种实现方式的区别在于Hashmap是无序的，并且插入、删除查找都是O（1）的，而TreeSet是有序的，且上述三个操作的复杂度都是O（logn）；

以HashMap为例：

4.map:

Map是一个接口,其实现类为TreeMap和HashMap。
Map 中存放键值对，其 Key 是唯一的， value 是可以重复的 。
Map 中键值对的 Key 不能直接修改， value 可以修改，如果要修改 key ，只能先将该 key 删除掉，然后再来进行重新插入。

public static void main(String[] args) {
    Map<String,Integer> map = new TreeMap<>();
    //put 是插入key与对应的value
    map.put("abc",10);
    map.put("bcd",20);
    map.put("cde",23);
    System.out.println(map);//Map类重写了toString方法
    map.put("abc",20);//修改"abc"对应的value值
    System.out.println(map);
    //
    System.out.println(map.get("abc"));//20
    System.out.println(map.get("a"));//null
    System.out.println(map.getOrDefault("hello",20)); //20
    map.remove("abc"); 移除abc对应的映射关系
}