Java 异常及异常处理

异常

异常概念：

在Java语言中，将程序执行中发生的不正常情况称为“异常”

Java程序在执行过程中所发生的异常(运行时一切不正常情况)事件可分
为两类：
• Error : Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资
源耗尽等严重情况。一般不编写针对性的代码进行处理。
• Except ion: 其它因编程错误或偶然的外在因素导致的一般性问题，可
以使用针对性的代码进行处理。例如：
访问数组下标越界
试图读取不存在的文件
网络连接中断

对于这些异常，一般有两种解决方法：一是遇到异常就终止程序的运行。
• 另一种方法是由程序员在编写程序时，就考虑到异常的检测、异常消息的提示，以及异常的处理。
• 捕获异常最理想的是在编译期间，但有的异常只有在运行时才会发生。比如：除数为0，数组下标越界等

异常处理 基本语法

try{
可能会发生异常的代码
}catch(异常类型 引用名){
异常处理代码
}finally{
必须执行代码}

语法解析

try
检测不安全的代码块（发现异常）
try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将
跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代
码放到try块中，因为随时可能会中断执行。

catch
把抓到的类型匹配的异常捕获，保证程序能继续运行下去
catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，
一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类
的顺序写，否则有编译错误

捕获异常的有关信息：
与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。
getMessage() 获取异常信息，返回字符串
printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的
位置。返回值void。

finally
finally该内容总是会执行的，只能有一个finally语句
finally{
必须执行的逻辑

throws

● throws,定义一个方法的时候可以使用throws关键字声明,表示此方法
不处理异常，而交给方法调用处进行处理。
例如:
public void test throws 异常1，异常2，异常3{
}
● 任何方法都可以使用throws关键字声明异常类型，包括抽象方法。
● 子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常(针对编
译期异常)。
● 使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要
么继续使用throws声明

throw

throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实
例化对象. • 在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也
可以自己抛出。
语法：throw throw new 异常类构造方法
如： throw new RunTimeException();

区别

● throw用于方法体中，用来抛出一个实际的异常对象，使用throw后，
要么使用try catch捕获异常，要么使用throws声明异常
● throws用于方法声明处，用来声明该方法可能发生的异常类型，可以是
多个异常类型，用来强制调用该方法时处理这些异常
● 抽象方法也可以使用throws

自定义异常

自定义异常类
● 基本语法
public class 异常类名 extends Exception/RuntimeException{
public 异常类名(String msg){
super(msg);
}
}
● 自定义异常类中往往不写其他方法，只重载需要使用的构造方法
● 继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或
throws抛出

第七章 集合

为了代替数组（长度不可变）而产生的可变长的容器

集合其中包括四个接口：Collection、Map、list、set

八个类：Arraylist、Linklist、vector、hashset、treeset、Hashmap、treemap、hashtable

Collection 接口

定义了存取一组对象的方法，其子接口Set和List分别定义了存储方式。
● Set 中的数据对象没有顺序且不可以重复。
● List 中的数据对象有顺序且可以重复。
在Collection 中定义了一些集合中的共有方法:
boolean add(Object element); 添加元素
boolean addAll(Collection c);添加c中所有的元素
boolean remove(Object element);删除元素
boolean removeAll(Collection c);删除指定集合 不包含时,删除相交
的元素
void clear(); 清空集合
int size(); 返回集合长度
boolean isEmpty(); 判断是否为空
boolean contains(Object element); 是否包含
boolean containsAll(Collection c); 是否包含c中所有的元素
boolean retainAll(Collection c);求交集,集合数据发生变化返回true,
不变返回false

List继承了Collection接口,有三个实现的类
－ ArrayList
数组列表，数据采用数组方式存储。
－LinkedList
链表
－Vector
数组列表，添加同步锁,线程安全的

• ArrayList实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高
• LinkedList采用链表存储方式。插入、删除元素时效率比较高

ArrayList的常用方法
add(int index, E element) 向指定位置添加元素数据
get(int index) 获取指定位置元素
indexOf(Object o) 返回元素o在集合中第一次出现的位置
lastIndexOf(Object o) 从后往前第一次出现的位置
remove(int index) 删除并返回指定位置元素
removeRange(int fromIndex, int toIndex) 删除指定区间的元素(子类继承使用)
set(int index, E element) 替换指定位置元素

LinkedList的常用方法
add(int index,Object element) 向指定位置添加元素数据
addFirist(Object element) 头插
addLast(Object element) 尾插
get(int index) 获取
removeFirst() 头删
removeLast() 尾删
remove(int index) 删除指定
getFirst() 获取头部
getLast() 获取尾部

Set 接口
● Set接口继承了Collection接口。
Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的
● Set接口有两个实现类
● HashSet
HashSet类中的元素不能重复，即彼此调用equals方法比较，都返回false。
底层数据结构是哈希表+链表
哈希表依赖于哈希值存储
● TreeSet
可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。
TreeSet底层数据结构是二叉树(红黑树是一种自平衡的二叉树)

Mapa接口常用方法
V put(K key,V value) 添加
V remove(Object key)根据key值删除整个键值对
void clear()
boolean containsKey(Object key) 是否包含该键
boolean containsValue(Object value) 是否包含该值
boolean isEmpty()
int size()
V get(Object key) 根据值找键
Collection values() 将值全部取出 返回一个集合
Set keySet() 将键全部取出 返回一个不重复的set

Map 接口
● HashMap
HashMap中元素的key值不能重复， 排列顺序是不固定的,可以存储一个
为null的键。
● TreeMap
TreeMap中所有的元素都保持着某种固定的顺序，如果需要得到一个有序
的Map就应该使用TreeMap，key值所在类必须实现Comparable接口。
● HashTable
实现了同步。
不能存储为null的键

collections（集合处理的工具类）

1.什么是Collections？

此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合。

2.其主要方法如下：

• addAll(Collection<? super T> c, T… elements) 将所有指定的元素添加到指定的集合。
• binarySearch(List<? extends Comparable<? super T>> list, T key) 使用二叉搜索算法搜索指定对象的指定列表。
• copy(List<? super T> dest, List<? extends T> src) 将所有元素从一个列表复制到另一个列表中。
• emptyList() 返回空列表（immutable）。
• fill(List<? super T> list, T obj) 用指定的元素代替指定列表的所有元素。
• max(Collection<? extends T> coll) 根据其元素的 自然顺序返回给定集合的最大元素。
• min(Collection<? extends T> coll) 根据其元素的 自然顺序返回给定集合的最小元素。
• replaceAll(List list, T oldVal, T newVal) 将列表中一个指定值的所有出现替换为另一个。
• reverse(List<?> list) 反转指定列表中元素的顺序。
• sort(List list, Comparator<? super T> c) 根据指定的比较器引起的顺序对指定的列表进行排序。
• swap(List<?> list, int i, int j) 交换指定列表中指定位置的元素。

3.代码实现。

package collectionsDemo;

import java.util.*;

public class CollectionsDemo {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<String> alist = new ArrayList<>();
        alist.add("a");
        alist.add("b");
        alist.add("c");
        Collections.addAll(alist,"d","e","f");//addAll(Collection<? super T> c, T... elements)将所有指定的元素添加到指定的集合。
        System.out.println(alist);
        ArrayList<Integer> alist1 = new ArrayList<>();
        alist1.add(1);
        alist1.add(3);
        alist1.add(2);
        alist1.add(7);
        alist1.add(4);
        alist1.add(2);
//        Collections.sort(alist1);
//        Collections.sort(alist1, new Comparator<Integer>() {//可自定义排序
//            @Override
//            public int compare(Integer o1, Integer o2) {
    
    
//                return o1-o2;
//            }
//        });
        Collections.sort(alist1,((o1, o2) -> {
    
    return o2-o1;}));
        System.out.println(alist1);
        System.out.println(Collections.binarySearch(alist1,1));//binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
        // 使用二叉搜索算法搜索指定对象的指定列表。
        Collections.swap(alist1,0,2);//交换指定列表中指定位置的元素
        System.out.println(alist1);

        ArrayList<Integer> alist2 = new ArrayList<>();
        alist2.add(0);
        alist2.add(0);
        alist2.add(0);
        alist2.add(0);
        alist2.add(0);
        alist2.add(0);
        alist2.add(0);
        alist2.add(0);
        alist2.add(0);
        Collections.copy(alist2,alist1);//copy(List<? super T> dest, List<? extends T> src)
        // 将所有元素从一个列表复制到另一个列表中。
        System.out.println(alist2);

        System.out.println(Collections.max(alist1));
        System.out.println(Collections.min(alist1));

        Collections.replaceAll(alist2,0,1);//将旧集合中的某一元素替换为新元素
        System.out.println(alist2);

        Collections.reverse(alist2);//翻转集合中元素
        System.out.println(alist2);

        List<Integer> alist3 = new ArrayList<>();
        alist3=Collections.emptyList();//返回一个不能更改的集合；

        System.out.println(alist3);
    }
}

4.运行结果

[a, b, c, d, e, f]
[7, 4, 3, 2, 2, 1]
-1
[3, 4, 7, 2, 2, 1]
[3, 4, 7, 2, 2, 1, 0, 0, 0]
7
1
[3, 4, 7, 2, 2, 1, 1, 1, 1]
[1, 1, 1, 1, 2, 2, 7, 4, 3]
[]