第二周：java异常和常用类 容器

一、java异常类

1.定义

异常就是在运行时产生的问题。通常用Exception描述。

在java中，把异常封装成了一个类，当出现问题时，就会创建异常类对象并抛出异常相关的信息（如详细信息，名称以及异常所处的位置）。

2.异常的继承关系

![Throwable类是所有错误跟异常类的超类（祖宗类）。

Exception异常类及其子类都是继承自Throwable类，用来表示java中可能出现的异常，并且合理的处理这些异常。

RuntimeException类是运行异常类，继承自Exception类，它以及它的子类只能在运行过程中存在，当出现时，只能修改源代码，此异常无法处理。

Error类是与Exception的平级的类，用来表示Java中存在的严重错误，只能通过修改代码来解决问题。](https://img-blog.csdnimg.cn/abdf8feed2e94360bbe0448f9c0666ae.png#pic_center)
继承体系的总结：
Throwable: 它是所有错误与异常的超类（祖宗类）
|- Error 错误
|- Exception 编译期异常,进行编译JAVA程序时出现的问题
|- RuntimeException 运行期异常, JAVA程序运行过程中出现的问题

3.异常与错误的区别

异常是指程序在编译或者运行时出现的某种异常问题，我们可以对异常进行某种处理，如果不处理异常的话，程序将会停止运行。

错误是指程序在运行时出现的严重问题，无法处理，程序将会停止运行，Error通常都是系统级别的问题，都是虚拟机jvm所在系统发生的，只能通过修改源代码解决问题。

4.异常产生的过程

1.运行或编译时产生异常

2.创建异常类的对象

3.声明异常类

4.将异常类对象传给调用者（main()方法）处理

5.调用者无法处理，再将异常类对象传给jvm虚拟机

6.jvm虚拟机将异常类的信息（名称、详细信息、异常所处的位置）打印在屏幕上，并且停止程序的运行

5.java异常抛出

①使用try-catch块处理已检查的异常

语法格式:
try {
逻辑代码块1;
} catch(ExceptionType e) {
处理代码块1;
}

如果 try 语句块中发生异常，那么一个相应的异常对象就会被拋出，然后 catch 语句就会依据所拋出异常对象的类型进行捕获，并处理。处理之后，程序会跳过 try 语句块中剩余的语句，转到 catch 语句块后面的第一条语句开始执行。
如果 try 语句块中没有异常发生，那么 try 块正常结束，后面的 catch 语句块被跳过，程序将从 catch 语句块后的第一条语句开始执行。

package Demo02;
import java.util.Scanner;
    public class Test {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("---------学生信息录入---------------");
            String name = ""; // 获取学生姓名
            int age = 0; // 获取学生年龄
            String sex = ""; // 获取学生性别
            try {
                System.out.println("请输入学生姓名：");
                name = scanner.next();
                System.out.println("请输入学生年龄：");
                age = scanner.nextInt();
                System.out.println("请输入学生性别：");
                sex = scanner.next();
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("输入有误！");
            }
            System.out.println("姓名：" + name);
            System.out.println("年龄：" + age);
        }
    }

try：该代码块中编写可能产生异常的代码。
catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
捕获异常的组合方式：

1. try catch finally组合：检测异常，并传递给catch处理，并在finally中进行资源释放。
2. try catch组合 : 对代码进行异常检测，并对检测的异常传递给catch处理。对异常进行捕获处理。
3. 一个try 多个catch组合 : 对代码进行异常检测，并对检测的异常传递给catch处理。对每种异常信息进行不同的捕获处理。
   注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。
4. try finally 组合: 对代码进行异常检测，检测到异常后因为没有catch，所以一样会被默认jvm抛出。异常是没有捕获处理的。但是功能所开启资源需要进行关闭，所有finally。只为关闭资源。

②在方法/构造函数声明中用throws子句指定。

a.throw出现在方法体中，用于抛出异常。当方法在执行过程中遇到异常情况时，将异常信息封装为异常对象，然后throw。
基本语法：throw ExceptionObject;
其中，ExceptionObject 必须是 Throwable 类或其子类的对象。如果是自定义异常类，也必须是 Throwable 的直接或间接子类。
当 throw 语句执行时，它后面的语句将不执行，此时程序转向调用者程序，寻找与之相匹配的 catch 语句，执行相应的异常处理程序。如果没有找到相匹配的 catch 语句，则再转向上一层的调用程序。这样逐层向上，直到最外层的异常处理程序终止程序并打印出调用栈情况。throw 关键字不会单独使用，它的使用完全符合异常的处理机制，但是，一般来讲用户都在避免异常的产生，所以不会手工抛出一个新的异常类的实例，而往往会抛出程序中已经产生的异常类的实例。
b.throws 声明异常
当一个方法产生一个它不处理的异常时，那么就需要在该方法的头部声明这个异常，以便将该异常传递到方法的外部进行处理。使用 throws 声明的方法表示此方法不处理异常。throws 具体格式如下：
returnType method_name(paramList) throws Exception 1,Exception2,…{…}

package Demo02;
import java.util.Scanner;
public class Test {
    public boolean validateUserName(String username) {
        boolean con = false;
        if (username.length() > 8) {
            // 判断用户名长度是否大于8位
            for (int i = 0; i < username.length(); i++) {
                char ch = username.charAt(i); // 获取每一位字符
                if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
                    con = true;
                } else {
                    con = false;
                    throw new IllegalArgumentException("用户名只能由字母和数字组成！");
                }
            }
        } else {
            throw new IllegalArgumentException("用户名长度必须大于 8 位！");
        }
        return con;
    }
    public static void main(String[] args) {
        Test te = new Test();
        Scanner input = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = input.next();
        try {
            boolean con = te.validateUserName(username);
            if (con) {
                System.out.println("用户名输入正确！");
            }
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

throw 和throws 关键字的区别
1、写法上 : throw 在方法体内使用，throws 函数名后或者参数列表后方法体前
2、意义 ： throw 强调动作，而throws 表示一种倾向、可能但不一定实际发生
3、throws 后面跟的是异常类，可以一个，可以多个，多个用逗号隔开。throw 后跟的是异常对象，或者异常对象的引用。
4、throw 用户抛出异常，当在当前方法中抛出异常后，当前方法执行结束（throw 后，如果有finally语句的话，会执行到finally语句后再结束。）。可以理解成return一样。

6.assert断言

①给idea开启断言

②用法：

*a.*assert <boolean表达式>
如果<boolean表达式>为true，则程序继续执行。
如果为false，则程序抛出AssertionError，并终止执行。
*b.*assert <boolean表达式> : <错误信息表达式>
如果<boolean表达式>为true，则程序继续执行。
如果为false，则程序抛出java.lang.AssertionError，并输入<错误信息表达式>。

③使用举例

package Demo02;

class Test {
    public static void main(String args[]) {
        String[] weekends = {"Friday", "Saturday", "Sunday"};
        assert weekends.length==2 : "There are only 2 weekends in a week";
        System.out.println("There are " + weekends.length + "  weekends in a week");
    }
}

④断言的优点

a.快速高效地检测和纠正错误。
b.断言检查仅在开发和测试期间进行。它们会在运行时自动在生产代码中删除，因此不会减慢程序的执行速度。
c.它有助于删除样板代码并使代码更具可读性。
d.重构和优化代码，以增强其正确运行的信心。

二、java常用类

1.object

Object类是所有类的父类，也就是说任何一个类在定义时如果没有明确地继承一个父类，那它就是Object类的子类。Object类提供无参构造方法 ，之所以提供这样的无参构造，是因为在子类对象实例化时都会默认调用父类中的无参构造方法，这样在定义类时即使没有明确定义父类为Object，读者也不会感觉代码的强制性要求。

使用举例：

public class Test{
    public static void main(String[] args){
        //创建Object类对象
        Test o1 = new Test();
        Test o2 = new Test();
        Test o3 = o2;
        System.out.println(o1.hashCode());
        System.out.println(o2.hashCode());
        System.out.println(o3.hashCode());
    }
}

2.string

1)构造方法
String():创建一个空的字符串
String(byte[] bys):通过字节数组创建字符串
String(char[] chs):通过字符数组创建字符串
String(byte[] bys,int offset,int length):通过字节数组一部分创建字符串
String(char[] chs,int offset,int length):通过字符数组一部分创建字符串
String(String original):通过字符串常量值创建字符串
2)成员方法
*a.*判断功能
equals(Object obj):比较两个字符串是否相等
equalsIngnoreCase(Object obj):忽略大小写比较两个字符串是否相等
contains(String str):是否包含指定字符串
startsWith(String str):是否以指定的字符串开头
endWith(String str):是否以指定的字符串结尾
isEmpty():是否为空
matches(String regex):判断字符串是否匹配给定的正则表达式。
*b.*获取功能
length():获取长度
charAt(int index): 获取指定索引位置处的字符
indexOf(int ch):获取指定字符第一次出现的索引值(从0开始)
indexOf(int ch,int fromIndex):获取从指定索引位置开始，获取指定字符第一次出现的索引值
indexOf(String s):获取指定字符串第一次出现的索引值
indexOf(String s,int fromIndex):获取从指定索引位置开始，获取指定字符串第一次出现的索引值
lastIndexOf(int ch):获取指定字符最后一次出现的索引值
substring(int start):从指定位置开始一直截取到末尾
substring(int start,int end):截取[start,end-1]范围
*c.*转换功能
byte[] getBytes():将字符串转成字节数组
char[] toCharArray():将字符串转成字符数组
static valueOf(char[] chs):将char[]转成字符串
static valueOf(int num):将int类型转成字符串
static valueOf(Object obj):将任意类型转成字符串
toLowerCase():转成小写
toUpcase():转成大写
concat(String str):字符连接
*d.*其他功能
replace(char old,char new):将old字符替换成new字符
replace(String old,String new):将old字符串替换成new字符串
trim():去除两边空格
int compareTo(String s):字典比较，如果前面值小于后面值返回负数，否则返回正数，先比较第一个元素，如果相等再比较第二个元素…返回元素之间的差值；如果比较字符串有包含关系，返回的值是它们长度的差值
int compareToIgnoreCase(String s):忽略大小写字典比较
String replaceAll(String regex, String replacement):使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement):使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
String[] split(String regex): 根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit): 根据匹配给定的正则表达式来拆分此字符串。

public class Test {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3 == s1+s2);                 
        System.out.println(s3.equals(s1+s2));
        System.out.println(s3 == "hello"+"world");        
        System.out.println(s3.equals("hello"+"world"));   
    }
}

3.StringBuff

a.构造
1）StringBuffer() ：构造一个空的字符串缓冲区，并且初始化为 16 个字符的容量。
2）StringBuffer(int length)： 创建一个空的字符串缓冲区，并且初始化为指定长度 length 的容量。
3）StringBuffer(String str) ：创建一个字符串缓冲区，并将其内容初始化为指定的字符串内容 str，字符串缓冲区的初始容量为 16 加上字符串 str 的长度。
b.常用的几种方法
1）StringBuffer 类的 append() 方法用于向原有 StringBuffer 对象中追加字符串。

public class Test {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("hello,");
        String str = "World!";
        buffer.append(str);
        System.out.println(buffer.substring(0));
    }
}

2）StringBuffer 类的 setCharAt() 方法用于在字符串的指定索引位置替换一个字符。
该方法的语法格式：StringBuffer 对象.setCharAt(int index, char ch);

public class Test {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("hello");
        sb.setCharAt(1,'E');
        System.out.println(sb);   
        sb.setCharAt(0,'H');
        System.out.println(sb);
        sb.setCharAt(2,'p');
        System.out.println(sb);
    }
}

3）StringBuffer 类中的 reverse() 方法用于将字符串序列用其反转的形式取代。
该方法的语法格式如下：StringBuffer 对象.reverse();

public class Test {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("java");
        sb.reverse();
        System.out.println(sb);
    }
}

4）删除字符串
StringBuffer 类提供了 deleteCharAt() 和 delete() 两个删除字符串的方法
*a.*deleteCharAt() 方法用于移除序列中指定位置的字符，该方法的语法格式如下：
StringBuffer 对象.deleteCharAt(int index);

public class Test {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("She");
        sb.deleteCharAt(2);
        System.out.println(sb);
    }
}

*b.*delete() 方法用于移除序列中子字符串的字符，该方法的语法格式如下：
StringBuffer 对象.delete(int start,int end);

public class Test {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("hello jack");
        sb.delete(2,5);
        System.out.println(sb);
        sb.delete(2,5);
        System.out.println(sb);
    }
}

4.StringBuilder

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

public class Test{
    public static void main(String args[]){
        StringBuilder sb = new StringBuilder(10);
        sb.append("Runoob..");
        System.out.println(sb);
        sb.append("!");
        System.out.println(sb);
        sb.insert(8, "Java");
        System.out.println(sb);
        sb.delete(5,8);
        System.out.println(sb);
    }
}

!!!String、StringBuffer和StringBuilder的使用原则

1)如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder
2)如果字符串存在大量的修改操作，并在单线程的情况下，使用StringBuilder
3)如果字符串存在大量的修改操作，并在多线程的情况下，使用StringBuffer
4)如果我们字符串很少修改，而且被多个对象引用，使用String，比如配置信息等

!!!String、StringBuffer和StringBuilder的比较

StringBuilder和StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样
String：不可变的字符序列，效率低，但是复用率高
String使用注意：如果我们需要对字符串做大量修改，不要使用String，因为会导致大量副本字符串对象存留在内存中，降低效率
StringBuffer：可变的字符序列，效率较高(增删)、线程安全
StringBuilder：可变的字符序列，效率最高、线程不安全

5.Scanner

a.构造方法
Scanner(InputStream is)
构造一个文本扫描器，它生成的值是从指定的值输入流扫描的
System.in 是一个标准的输入流，属于InputStream
b.成员方法
boolean hasNext():是否有下一个数,有true，没有false
String next():获取下个数
int nextInt():获取下个int数据
String nextLine():获取一行数据

6.Math

abs(int a):绝对值
ceil(double d):向上取整
floor(double d):向下取整
max(int a,int b):最大值
pow(double a,double b):a的b次幂
random():随机数[0.0,1.0]
round(float f):四舍五入
sqrt(double d):算术平方根

7.Random

a.构造方法
Random():以当前时间毫秒值作为种子，创建Random对象
Random(long seed):以指定种子创建Random对象
b.成员方法
nextInt():生成1个int类型范围的随机数
nextInt(int n):产生1个[0,n-1]范围内的随机数
生成0~n之间的数
①(int)Math.random()(n+1)
②Random r = new Random();
r.nextInt(m)表示生成[0,m-1]之间的随机数，也就是说random.nextInt(m+1)，将生成[0,m]之间的随机整数。
r.nextInt(n+1)
生成n~m之间的随机数
①n+(int)(Math.random()(m+1-n));
②Random r = new Random();
r.nextInt(m+1-n)+n;

8.BigInteger

1）构造方法
BigInteger(String s):通过字符串创建BigInteger对象
2）成员方法
add(BigInteger bi):+
subtract(BigInteger bi):-
multiply(BigInteger bi)😗
divide(BigInteger bi)😕

9.BigDecimal

用于解决浮点型运算精度损失的问题
1）构造方法
BigDecimal(String s):通过字符创建BigDecimal对象
2）成员方法
add(BigDecimal bi):+
subtract(BigDecimal bi):-
multiply(BigDecimal bi)😗
divide(BigDecimal bi)😕

三、容器

Java容器分为两大阵营：Collection和Map
Collection：主要是单个元素的集合，由List、Queue、Set三个接口区分不同的集合特征，然后由下面的具体的类来实现对应的功能。
Map：有一组键值对的存储形式来保存，可以用键对象来查找值。

1.List

1）list中添加，获取，删除元素
添加方法是：.add(e)；　　
获取方法是：.get(index)；　　
删除方法是：.remove(index)；
按照索引删除:.remove(Object o)；

import java.util.ArrayList;
import java.util.List;
public class Test{
        public static void main(String args[]) {
            List<String> person=new ArrayList<>();
            person.add("jackie"); 
            person.add("peter");  
            person.add("annie");    
            person.add("martin");  
            person.add("marry");    

            person.remove(3); 
            person.remove("marry");    

            String per="";
            per=person.get(1);
            System.out.println(per);    

            for (int i = 0; i < person.size(); i++) {
                System.out.println(person.get(i));
            }

        }
    }

2）list中是否包含某个元素；
　　方法：.contains（Object o）；返回true或者false

import java.util.ArrayList;
import java.util.List;
public class Test{
        public static void main(String args[]) {
            List<String> fruits=new ArrayList<>();
            fruits.add("苹果");
            fruits.add("香蕉");
            fruits.add("桃子");
            for (int i = 0; i < fruits.size(); i++) {
                System.out.println(fruits.get(i));
            }
            String appleString="苹果";
            System.out.println("fruits中是否包含苹果："+fruits.contains(appleString));
            if (fruits.contains(appleString)) {
                System.out.println("我喜欢吃苹果");
            }else {
                System.out.println("我不开心");
            }
        }
    }

3）list中根据索引将元素数值改变(替换)；
　　注意 .set(index, element); 和 .add(index, element); 的不同；

import java.util.ArrayList;
import java.util.List;
public class Test{
        public static void main(String args[]) {
            String a="白龙马", b="沙和尚", c="八戒", d="唐僧", e="悟空";
            List<String> people=new ArrayList<>();
            people.add(a);
            people.add(b);
            people.add(c);
            people.set(0, d);  
            people.add(1, e);
            for(String str:people){
                System.out.println(str);
            }
        }
    }

4）list中查看（判断）元素的索引；　　
　　注意：.indexOf（）； 和 lastIndexOf（）的不同；

import java.util.ArrayList;
import java.util.List;
public class Test{
        public static void main(String args[]) {
            List<String> names=new ArrayList<>();
            names.add("刘备");
            names.add("关羽");
            names.add("张飞");
            names.add("刘备");
            names.add("张飞");    
            System.out.println(names.indexOf("刘备"));
            System.out.println(names.lastIndexOf("刘备"));
            System.out.println(names.indexOf("张飞"));
            System.out.println(names.lastIndexOf("张飞"));
        }
    }

2.Queue

压入元素(添加)：add()、offer()
弹出元素(删除)：remove()、poll()
获取队头元素(不删除)：element()、peek()

import java.util.LinkedList;
import java.util.Queue;

public class Test {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<String>();
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("poll="+queue.poll());
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("element="+queue.element());
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("peek="+queue.peek());  
        for(String q : queue){
            System.out.println(q);
        }
    }
}

3.Set

Set 接口对数学中的一组进行建模。集合是唯一元素的集合。Java最多允许一个Set中的一个空元素。 Set 中元素的排序并不重要。Java不保证 Set 中元素的排序。当循环遍历 Set 的所有元素时，你得到 Set 中的每个元素一次。集合框架提供 HashSet 类作为实现为设置接口。
以下代码显示了如何创建一个Set并向其添加元素。 当向集合添加重复元素时，它们将被忽略。如果比较它们，则在集合中的两个元素被认为是相等的使用 equals()方法返回true。

import java.util.LinkedHashSet;
import java.util.Set;
public class Test {
    public static void main(String[] args) {
        Set<String> s1 = new LinkedHashSet<>();
        s1.add("A");
        s1.add("B");
        s1.add("C");
        s1.add("D");
        System.out.println("LinkedHashSet: " + s1);
    }
}

4.Map

Map 接口中键和值一一映射. 可以通过键来获取值。
给定一个键和一个值，你可以将该值存储在一个 Map 对象。之后，你可以通过键来访问对应的值。
当访问的值不存在的时候，方法就会抛出一个 NoSuchElementException 异常。
当对象的类型和 Map 里元素类型不兼容的时候，就会抛出一个 ClassCastException 异常。
当在不允许使用 Null 对象的 Map 中使用 Null 对象，会抛出一个 NullPointerException 异常。
当尝试修改一个只读的 Map 时，会抛出一个 UnsupportedOperationException 异常。

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Map m1 = new HashMap();
        m1.put("Zara", "8");
        m1.put("Mahnaz", "31");
        m1.put("Ayan", "12");
        m1.put("Daisy", "14");
        System.out.println();
        System.out.println(" Map Elements");
        System.out.print("\t" + m1);
    }
}

总结：

这次的预习内容感觉优点有点多，很多东西还没有彻底搞清楚，后面还需要下大工夫。