Java异常

Java异常

1.异常

1.1数组越界异常

public class Test {
    public static void main(String[] args) {
        String[] strs = new String[] {"a","b","c"};
        for(int i = 0; i<4; i++) {//0,1,2,3,strs没有第四个元素
            
            //java.lang.ArrayIndexOutOfBoundsException 数组越界异常
            System.out.println(strs[i]);
        }
    }
}

1.2空指针异常

public class Test {
    public static void main(String[] args) {
        A a = null;
        //java.lang.NullPointerException 空指针异常
        System.out.println(a.i);
    }
}
​
class A{
    int i;
}

2.异常处理机制

2.1捕获异常

try catch 是为了防止程序可能出现的异常。

public class Test {
    public static void main(String[] args) {
        int i = 0;
        try {//用try{}括住一段可能出现异常的代码段
            System.out.println(3/i);//由于异常，程序中断
        }catch(Exception e) {//当不知道捕获的是什么类型的异常时，可以直接使用所有异常的父类Exception
            e.printStackTrace();//输出异常的类型
            System.out.println(e.getMessage());//输出异常
        }finally{//捕获异常的体系中最终一段会执行的部分
            //可写可不写
        }
        System.out.println("ok");
    }
​
}

2.2抛出异常

public class Test{
    public static void main(String[] args){
        B b = new B();
        try{
            b.test();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
​
class B{
    int i;
    public void test()  throws Exception{//可以使用throws在代码中抛出异常，在调用方法中去捕获和处理
        B b = null;
        System.out.println(b.i)
    }
}

public class Test{
    public static void main(String[] args){
        B b = new B();
        try{
            b.test(-1);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
​
class B{
    int age;
    public void test(int age) throws Exception{
    if(age >= 0 && age <= 150){
        this.age = age;
        System.out.prinln("年龄是："+this.age);
        }else{
            throw new Exception("年龄不在0到150之间");
        }
    }
}

3.集合

Java集合类存放于java.util包中，是一个用来存放对象的容器。

集合存放的是多个对象的引用，对象本身还是放在堆内存中。

Java集合可分为Set、List、Map三种体系

• Set：无序，不可重复的集合

• List：有序，可重复的集合

• Map：具有映射关系的集合

3.1HashSet

HashSet是Set接口的典型表现

特点：

• 不能保证元素的排列顺序（由值的hashcode决定在set集合的存储位置）

• 不可重复（指hashcode不相同）

• HashSet不是线程安全的

• 集合元素可以使用null

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
​
public class Test1 {
    public static void main(String[] args) {
        Set set = new HashSet();//等价于 Set<Object> set = new HashSet<Object>();
        set.add(1);//可添加任何类型的数据
        set.add("a");
        System.out.println(set);
        
        set.remove(1);//移除数据
        System.out.println(set);
        
        boolean a = set.contains("a");//判断是否包含元素，输出为布尔类型
        System.out.println(a);
        
        set.clear();//清空元素
        System.out.println(set);
        
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("d");//set集合重复的值只存一个
        set.add("null");//set集合null可以存进去
        System.out.println(set);
        
        //使用迭代器遍历集合
        Iterator it = set.iterator();
        
        while(it.hasNext()){
            System.out.println(it.next());
        }
        
        //for each迭代集合
        for(Object obj : set) {//把set的每个值取出来，赋值给obj，直到循环结束
            System.out.println(obj);
        }
        
        System.out.println(set.size());//获取集合元素的个数
        
        
        //如果想让集合只能存同样类型的对象，要使用泛型
        Set<String> set1 = new HashSet<String>();//指定String为集合的泛型
        set1.add("abc");
//      set1.add(1);//报错
    }
}

3.2TreeSet

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
​
public class Test3 {
    public static void main(String[] args) {
        //TreeSet必须放入同样类型的对象
        Set<Integer> set = new TreeSet<Integer>();
        //TreeSet自然排序
        set.add(5);
        set.add(2);
        set.add(4);
        set.add(3);
        System.out.println(set);//输出结果为：2，3，4，5
    }
}

TreeSet定制排序（按年龄排列集合元素，需提供一个comparator接口👇）

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
​
public class Test4 {
    public static void main(String[] args) {
        Person p1 = new Person("张三",23);
        Person p2 = new Person("李四",21);
        Person p3 = new Person("王五",22);
        Person p4 = new Person("赵六",20);
        
        Set<Person> set = new TreeSet<Person>(new Person());
        set.add(p1);
        set.add(p2);
        set.add(p3);
        set.add(p4);
        for(Person p : set) {
            System.out.println(p.name + " " + p.age);
        }
    }
}
​
​
class Person implements Comparator<Person>{
    int age;
    String name;
    public Person() {
        
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compare(Person o1, Person o2) {//按年龄大小排列
        if(o1.age > o2.age) {
            return 1;
        }else if(o1.age < o2.age) {
            return -1;
        }else {
            return 0;
        }
    }
    
}

3.3List集合

List代表一个元素有序、可重复的集合，集合中的每个元素都有其对应的顺序索引。

import java.util.ArrayList;
import java.util.List;
​
public class Test5 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("b");//第一个，索引下标为0
        list.add("d");
        list.add("c");
        list.add("a");
        list.add("d");//可以添加重复元素
        System.out.println(list);//[b,d,c,a]
        System.out.println(list.get(2));//输出c，可以通过索引来访问指定位置的集合元素
        
        list.add(1,"f");
        System.out.println(list);//在指定索引下标的位置插入数据，该位置及该位置后的所有元素向后移一位
        
        List<String> l = new ArrayList<String>();
        l.add("123");
        l.add("456");
        list.addAll(2,l);//在指定索引位置插入集合
        System.out.println(list);
        
        System.out.println(list.indexOf("d"));//获取指定元素在集合中第一次出现的索引下标
        System.out.println(list.lastIndexOf("d"));//获取指定元素在集合中最后一次出现的索引下标
        
        list.remove(2);
        System.out.println(list);//移除指定索引下标位置的元素
        
        list.set(1, "ff");
        System.out.println(list);//修改指定索引下标位置的元素
        
        List<String> sublist = list.subList(2, 4);
        //输出索引下标的起始位置截取一段元素形成一个新的集合，截取时包含起始的索引元素但不包含结束时的索引元素
        System.out.println(sublist);//[456,d]，不包含第五个元素c
    }
}
//ArrayList线程不安全，Vactor线程安全，但不推荐使用Vactor

3.4Map集合

Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的Key，另一组用于保存Map里的Value。

Map中的key和value都可以是任何类型的数据

Map中的key不允许重复，即同一个Map对象的任何两个Key通过equals方法比较中返回false

Key和Value之间存在单项一对一关系，通过指定的Key总能找到唯一的Value与之对应。