第二周：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代码块中存放的代码都是一定会被执行的。
捕获异常的组合方式：

try catch finally组合：检测异常，并传递给catch处理，并在finally中进行资源释放。
try catch组合 : 对代码进行异常检测，并对检测的异常传递给catch处理。对异常进行捕获处理。
一个try 多个catch组合 : 对代码进行异常检测，并对检测的异常传递给catch处理。对每种异常信息进行不同的捕获处理。
注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。
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)