Java高级--Java-SE

一、Java定义字符串
1.将字符数组转为字符串

char[] ch = new char[]{'H','e','l','l','o'};
        String str = new String(ch);
        System.out.println(str);

作用：可以将字符数组中的元素，在范围内的长度
分配一个新字符串，该字符串包含来自Unicode码（65是A）点数组参数子数组的字符。
offset参数是子数组第一个编码点的索引，count参数指定子数组的长度。
子数组的内容被转换为字符;int数组的后续修改不会影响新创建的字符串。

二、string和int 的相互转换
1、string转换为int
有两种方式：Integer.parseInt(str) Integer.valueOf(str).intValue()
注意：将字符串转为int类型的值的前提是字符串内容必须是纯数字否则会报错
//java.lang.NumberFormatException: For input string: “12World”
//java.lang.NumberFormatException: For input string: “Hello56”
2、将int转换为string
第一种方式：“+”任何类型的数据加上空格符都可以变成字符串，同时与字符串拼接结果是字符串
注意：性能消耗大
获取时间戳（System.currentTimeMillis();）的代码如下：
public class Demo03 {
public static void main(String[] args) {
String str = “Hello”;
String s1 = “world”;

    long start = System.currentTimeMillis();
    for(int i = 0; i < 10000; i++){
        str +=s1;
    }
    long end = System.currentTimeMillis();
    System.out.println(end - start);
    String s2 = "张三";
    String s3 = "李四";
    String s4 = s2.concat(s3);
    System.out.println(s4);
}

}

   //说明不需要记忆
    第二种方式：“String s = String.valueOf(i);”i是int类型的数
    第三种方式："String s = Integer.toString(i)"
3、valueOf(), parse() 和 toString()
   valueOf():是一种静态方法，可以将数据的内部格式转化为可读的形式 。
   可以被类型Object重载，因此创建任何形式类的对象可被用作一个参数。
   parse():parsexxx(String)这种形式，是把字符串转换为数值型，其中xxx对应不同的数据类型，然后转换为xxx指定的类型。如：int,float
   toString():可以将一个引用类型转换为String字符串类型

三、字符串拼接（连接）
1、使用连接运算符“+”
2、使用concat()方法
将一个字符串连接到另一个字符串的后面
语法：s1.concat(s2);
四、
1、获取字符串长度
使用length()方法获取字符串长度（在数组中length是属性）
2、将字符转大小写
str.toUpperCase() //将字符串转换为大写
str.toLowerCase() //将字符串转换为小写
3、去除字符串两端的空白
String str2 = str1.trim();

代码如下：
public static void main(String[] args) {
String str = “Hello Java”;
System.out.println(str.length());
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());
String str1 = " hello ";
System.out.println(str1.length());
String str2 = str.trim();
System.out.println(str2.length());
}

五、字符串截取
1、substring(int beginIndex)形式
从指定位置开始截取，beginIndex表示开始位置的下标
2、substring(int begin,int end)形式（begin和end是元素下标）
截取指定范围内的字符串，含前不含尾

public static void main(String[] args) {
        /**
         * 字符串截取：
         * 1.从指定位置截取到结束位置（末尾）：substring(int start)
         * 2.截取指定范围内的字符串：substring(int start,int end)
         */
        String str = "Hello Java";
        System.out.println(str.substring(4));
        System.out.println(str.substring(4, 9));
        String s = "you see see you noe day day di";
        /**
         * String类的split()方法可以按指定的分割符对目标字符串进行分割，
         * 分割后的内容存放在字符串数组中。
         */
        String[] s1 = s.split(" ");
        System.out.println(Arrays.toString(s1));
        String[] s2 = s.split(" ",5);
        System.out.println(s2.length);
        System.out.println(Arrays.toString(s2));
    }

七、字符串截取：
1.从指定位置截取到结束位置（末尾）：substring(int start)
2.截取指定范围内的字符串：substring(int start,int end)
注意：substring() 方法是按字符截取，而不是按字节截取。
八、分割字符串 （spilt()）
String类的split()方法可以按指定的分割符对目标字符串进行分割，分割后的内容存放在字符串数组中
输出时可用toString()输出字符串数组
使用分隔符注意如下：
​ 1）“.”和“|”都是转义字符，必须得加“\”。
​ 如果用“.”作为分隔的话，必须写成String.split("\\.")，这样才能正确的分隔开，不能用String.split(".")。
​ 如果用“|”作为分隔的话，必须写成String.split("\\|")，这样才能正确的分隔开，不能用String.split("|")。
​ 2）如果在一个字符串中有多个分隔符，可以用“|”作为连字符，比如：“acount=? and uu =? or n=?”，把三个都分隔出来，可以用String.split("and|or")。
九、 案例：在新闻中标题的省略（美观）

public static void main(String[] args) {
        String[] news = new String[]{"如何快速领悟和学习英语","如何适应当代大学生活","无岸村的生活习性和传统习俗","喜迎二十大，奋斗新征程"};
        for (int i = 0; i < news.length; i++) {
            if(news[i].length() > 10){
                System.out.println(news[i].substring(0, 10) + "...");
            }else{
                System.out.println(news[i]);
            }
        }
    }

十、字符串的替换：replace（）方法（str.replace())//替换的是所有满足条件的字符串或字符
替换字符setCharAt(int index, char ch)//能替换指定的字符
replaceFirst() 方法：用于将目标字符串中匹配某正则表达式的第一个子字符串替换成新的字符串
replaceAll() 方法：用于将目标字符串中匹配某正则表达式的所有子字符串替换成新的字符串
字符串.replaceAll(String regex, String replacement)
说明：regex 表示正则表达式
replacement 表示用于替换的字符串
十一、 案例：替换游戏中的敏感词

 public static void main(String[] args) {
        /**
         * 字符串替换
         */
        String str = "hello jaoa";
        String replace = str.replace("o", "v");
        System.out.println(replace);
        /**
         * 替换敏感字符
         */
        String s = "你个DSB，TMD到底会不会玩，NTND啥都不会";
        s = s.replace("DSB", "*");
        s = s.replace("TMD", "*");
        s = s.replace("NTND", "*");
        System.out.println(s);
    }

十二、字符串的比较
1、== 比较字符串所指的对象是否相等
2、equals() 比较字符串内容是否一致（s1.equals(s2)）区分大小写
3、equalsIgnoreCase(s2) 不区分大小写，比较字符串内容是否一致
compareTo() 方法：一个字符串是大于、等于还是小于另一个。
一个字符串小于另一个指的是它在字典中先出现。
而一个字符串大于另一个指的是它在字典中后出现。
字符串（String）的 compareTo() 方法实现了这种功能。
十三、字符串查找：
indexOf() 方法用于返回字符（串）在指定字符串中首次出现的索引位置，如果能找到，则返回索引值，否则返回 -1
lastIndexOf() 方法用于返回字符（串）在指定字符串中最后一次出现的索引位置，如果能找到则返回索引值，否则返回 -1。
案例：用户给定文件名字（完整名字）,程序判断文件类型
十四、StringBuffer类
1、创建StringBuffer对象
1、StringBuffer（），初始长度为16
2、StringBuffer（32），可以指定长度（32）
3、StringBuffer（“happy”）可输入一个字符串，则长度为字符串长度+16
输出字符串的容量大小
capacity()方法返回字符串的容量大小
注意：StringBuffer与capacity需要共用
2、追加字符串
StringBuffer 类的 append() 方法用于向原有 StringBuffer 对象中追加字符串
例如：StringBuffer 对象.append(String str)
3、字符串的拼接：
append方法拼接字符串 ，大大减少了性能的消耗
用"＋"号拼接，性能消耗大
StringBuffer 类的 setCharAt() 方法用于在字符串的指定索引位置替换一个字符
例如：StringBuffer 对象.setCharAt(int index, char ch);
4、反转字符串
StringBuffer 类中的 reverse() 方法用于将字符串序列用其反转的形式取代。
5、删除字符串
StringBuffer 类提供了 deleteCharAt() 和 delete() 两个删除字符串的方法，
1、deleteCharAt() ：用于移除序列中指定位置的字符
deleteCharAt(int start)
2、delete()：用于删除序列中的子字符串
delete(int start , int end)（含头不含尾）
十五、StringBuffer和StringBuilder：
相同点：1、是Java提供的两个可变字符串类，相当于缓冲的作用
2、StringBuffer和StringBuilder它们使用的方式一样，功能基本相似
StringBuffer、StringBuilder、String 中都实现了 CharSequence 接口
不同点：1、StringBuffer 是线程安全的，性能较低
2、StringBuilder 没有实现线程安全功能，性能较高
注意：CharSequence 是一个定义字符串操作的接口，它只包括 length()、charAt(int index)、subSequence(int start, int end) 这几个 API
String 直接实现了 CharSequence 接口，StringBuilder 和 StringBuffer 都是可变的字符序列，它们都继承于 AbstractStringBuilder，实现了 CharSequence 接口

总结：
1、String
String是Java中基础且重要的类，被声明为 final class ，是不可变的字符串
在拼接字符串时会产生很多无用的中间对象
2、StringBuffer是为了解决大量拼接字符串时产生许多中间对象问题而提供的类，它有append和add方法，可以将字符串添加到已有序列的末尾或指定位置
3、StringBuilder与StringBuffer没有本质区别，就只是去掉了保证线程安全功能，减少开销。作用是在字符串拼接时不需要线程安全
线程安全：

​ StringBuffer：线程安全
​ StringBuilder：线程不安全

速度：

​ 一般情况下，速度从快到慢为 StringBuilder > StringBuffer > String，当然这是相对的，不是绝对的。
使用环境：

​ 操作少量的数据使用 String。
​ 单线程操作大量数据使用 StringBuilder。
​ 多线程操作大量数据使用 StringBuffer。
查找字符
System.out.println(str.charAt(3));
十六、正则表达式：
正则表达式是一个强大的字符串处理工具，可以对字符串进行查找、提取、分割、替换等操作，是一种可以用于模式匹配和替换的规范
String 类里也提供了如下几个特殊的方法。
​ 1、boolean matches(String regex)：判断该字符串是否匹配指定的正则表达式。
​ 2、String replaceAll(String regex, String replacement)：将该字符串中所有匹配 regex 的子串替换成 replacement。
​ 3、String replaceFirst(String regex, String replacement)：将该字符串中第一个匹配 regex 的子串替换成 replacement。
​ 4、String[] split(String regex)：以 regex 作为分隔符，把该字符串分割成多个子串。
1、正则表达式支持字符

正则表达式中的“通配符”远远超出了普通通配符的功能，它被称为预定义字符

方括号表达式比前面的预定义字符灵活多了，几乎可以匹配任何字符
正则表达式还支持圆括号，用于将多个表达式组成一个子表达式，圆括号中可以使用或运算符|。例如，正则表达式“((public)|(protected)|(private))”用于匹配 Java 的三个访问控制符其中之一。

Reluctant（勉强模式）：用问号后缀（?）表示，它只会匹配最少的字符。也称为最小匹配模式。 ​
Possessive（占有模式）：用加号后缀（+）表示，目前只有 Java 支持占有模式，通常比较少用。

十七、Pattern类和Matcher类的使用
java.util.regex 是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。它包括两个类：Pattern 和 Matcher。
正则表达式字符串必须先被编译为 Pattern 对象，然后再利用该 Pattern 对象创建对应的 Matcher 对象。
多个Matcher对象可共享一个Pattern对象
例如：典型的刘勇顺序如下：
// 将一个字符串编译成 Pattern 对象
Pattern p = Pattern.compile(“ab");
// 使用 Pattern 对象创建 Matcher 对象
Matcher m = p.matcher(“aaaaab”);
boolean b = m.matches(); // 返回 true
某个正则表达式仅需一次使用，则可直接使用 Pattern 类的静态 matches() 方法，此方法自动把指定字符串编译成匿名的 Pattern 对象，并执行匹配
例如：boolean b = Pattern.matches ("ab”,“aaaaab”); // 返回 true
Pattern 是不可变类，可供多个并发线程安全使用

在 Pattern、Matcher 类的介绍中经常会看到一个 CharSequence 接口，该接口代表一个字符序列，其中 CharBuffer、String、StringBuffer、StringBuilder 都是它的实现类。简单地说，CharSequence 代表一个各种表示形式的字符串。
通过 Matcher 类的 find() 和 group() 方法可以从目标字符串中依次取出特定子串（匹配正则表达式的子串）
可用于：互联网的网络爬虫，它们可以自动从网页中识别出所有的电话号码
十八、正则表达式验证电话号码
用于注册会员时 输入电话号码
(1) 创建名为 Test21.java 的 Java 文件，在 main() 方法中开始编写代码。
如：import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Text21 {
public static void main(String[] args) {
//编写代码
}
}
(2) 声明 String 类型的 regex 变量，它是用于验证电话号码的表达式。
如：String regex = “0\d{2,3}[-]?\d{7,8}|0\d{2,3}\s?\d{7,8}|13[0-9]\d{8}|15[1089]\d{8}”;
(3) 声明 String 类型的 answer 变量，它表示是否继续验证电话号码。
如：String answer = “Y”;
数字和日期处理
一、Math类的常用方法
在 Java 中 Math 类封装了常用的数学运算，提供了基本的数学操作。
Math 类位于 java.lang 包，它的构造方法是 private 的，因此无法创建 Math 类的对象，并且 Math 类中的所有方法都是类方法，可以直接通过类名来调用它们。
1、静态常量
Math 类中包含 E 和 PI 两个静态常量，正如它们名字所暗示的，它们的值分别等于 e（自然对数）和 π（圆周率）
2、求最大值、最小值和绝对值

3、求整运算

二、生成随机数（random()和Random类）
生成随机数有两种方法:一种是调用 Math 类的 random() 方法
Math.random()只能产生 double 类型的 0~1 的随机数
另一种是使用 Random 类
Random 类提供了丰富的随机数生成方法，可以产生 boolean、int、long、float、byte 数组以及 double 类型的随机数
Random 类位于 java.util 包中，该类常用的有如下两个构造方法。
​ Random()：该构造方法使用一个和当前系统时间对应的数字作为种子数，然后使用这个种子数构造 Random 对象。
​ Random(long seed)：使用单个 long 类型的参数创建一个新的随机数生成器。
Math.random()比random类较为公平，random类是伪随机数

三、数字格式化
DecimalFormat 是 NumberFormat 的一个子类，用于格式化十进制数字。DecimalFormat 类包含一个模式和一组符号

四、Java大数字运算
1、BigInteger 类
注意：这里数字 5 的双引号是必需的，因为 BigInteger 类构造方法要求参数是字符串类型。

​ 创建 BigInteger 对象之后，便可以调用 BigInteger 类提供的方法进行各种数学运算操作，下表列出了 BigInteger 类的常用运算方法
2、BigDecimal 类
一般的 float 和 double 类型数据只能用来做科学计算或工程计算，但由于在商业计算中要求数字精度比较高，所以要用到 BigDecimal 类。
BigDecimal 类支持任何精度的浮点数，可以用来精确计算货币值。
BigDecimal 常用的构造方法如下。

​ 1、BigDecimal(double val)：实例化时将双精度型转换为 BigDecimal 类型。
2、BigDecimal(String val)：实例化时将字符串形式转换为 BigDecimal 类型。

1、常用的方法

五、Java时间日期的处理
在 Java 中获取当前时间，可以使用 java.util.Date 类和 java.util.Calendar 类完成。
1、Date 类
Date 类表示系统特定的时间戳，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。
1.1、构造方法

​ Date 类有如下两个构造方法。

​ 1、Date()：此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可以获取本地的当前时间。

​ 2、Date(long date)：此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫秒数
Date 类的无参数构造方法获取的是系统当前的时间，显示的顺序为星期、月、日、小时、分、秒、年。
2、Calendar 类
Calendar 类是一个抽象类，它为特定瞬间与 YEAR、MONTH、DAY_OF—MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（如获得下星期的日期） 提供了一些方法。
不能使用new关键字，但是它提供了一个 getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。
例如：Calendar c = Calendar.getInstance();

Calendar 类中定义了许多常量，分别表示不同的意义。 ​ 1、Calendar.YEAR：年份。 ​ 2、Calendar.MONTH：月份。 ​ 3、Calendar.DATE：日期。 ​ 4、Calendar.DAY_OF_MONTH：日期，和上面的字段意义完全相同。 ​ 5、Calendar.HOUR：12小时制的小时。 ​ 6、Calendar.HOUR_OF_DAY：24 小时制的小时。 ​ 7、Calendar.MINUTE：分钟。 ​ 8、Calendar.SECOND：秒。 ​ 9、Calendar.DAY_OF_WEEK：星期几。

Java日期格式化
DateFormat类：是抽象类。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期→文本）、解析（文本→日期）和标准化日期。
类的创建：
DateFormat df = DateFormat.getDatelnstance();
格式化样式主要通过 DateFormat 常量设置。将不同的常量传入到表 1 所示的方法中，以控制结果的长度。DateFormat 类的常量如下。
​ SHORT：完全为数字，如 12.5.10 或 5:30pm。
​ MEDIUM：较长，如 May 10，2016。
​ LONG：更长，如 May 12，2016 或 11:15:32am。
​ FULL：是完全指定，如 Tuesday、May 10、2012 AD 或 11:l5:42am CST。
SimpleDateFormat 类
SimpleDateFormat 类主要有如下 3 种构造方法。
​ SimpleDateFormat()：用默认的格式和默认的语言环境构造 SimpleDateFormat。
​ SimpleDateFormat(String pattern)：用指定的格式和默认的语言环境构造 SimpleDateFormat。
​ SimpleDateFormat(String pattern,Locale locale)：用指定的格式和指定的语言环境构造 SimpleDateFormat。

内置类及包装类
一、包装类、装箱和拆箱
1、包装类

2、装箱和拆箱
装箱：将基本数据类型转换为包装类的过程
拆箱：将包装类转换为基本数据类型的过程

3、包装类的应用
1) 实现 int 和 Integer 的相互转换
可以通过 Integer 类的构造方法将 int 装箱，通过 Integer 类的 intValue 方法将 Integer 拆箱
2) 将字符串转换为数值类型
在 Integer 和 Float 类中分别提供了以下两种方法：
① Integer 类（String 转 int 型）
例如：int parseInt(String s);
② Float 类（String 转 float 型）
例如：float parseFloat(String s)；
注意：使用以上两种方法时，字符串中的数据必须由数字组成，否则转换时会出现程序错误。
3) 将整数转换为字符串
Integer 类有一个静态的 toString() 方法，可以将整数转换为字符串
二、Object类
Object 是 Java 类库中的一个特殊类，也是所有类的父类

1、toString() 方法
toString() 方法返回该对象的字符串，Object 类的 toString() 方法返回“运行时类名@十六进制哈希码”格式的字符串，但很多类都重写了 Object 类的 toString() 方法，用于返回可以表述该对象信息的字符串。
对象输出时一定会调用 Object 类中的 toString() 方法打印内容
注：哈希码（hashCode)，每个Java对象都有哈希码属性，哈希码可以用来标识对象，提高对象在集合中的执行效率
2、equals() 方法
equals() 方法是比较两个对象的内容是否相等，通常字符串的比较只是关心内容是否相等
3、getClass() 方法
getClass() 方法返回对象所属的类，是一个 Class 对象。通过 Class 对象可以获取该类的各种信息，包括类名、父类以及它所实现接口的名字等。
4、接收任意引用类型的对象
Object 类是所有对象的父类， 一切的引用数据类型都可以使用 Object 进行接收。
三、Integer类
Integer 类在对象中包装了一个基本类型 int 的值。Integer 类对象包含一个 int 类型的字段
1、Integer 类的构造方法
​ Integer 类中的构造方法有以下两个：
​ Integer(int value)：构造一个新分配的 Integer 对象，它表示指定的 int 值。
​ Integer(String s)：构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
2、Integer 类的常用方法

3、Integer 类的常量
​ Integer 类包含以下 4 个常量。
​ MAX_VALUE：值为 231-1 的常量，它表示 int 类型能够表示的最大值。
​ MIN_VALUE：值为 -231 的常量，它表示 int 类型能够表示的最小值。
​ SIZE：用来以二进制补码形式表示 int 值的比特位数。
​ TYPE：表示基本类型 int 的 Class 实例。
四、Float类
1、Float 类的构造方法
​ Float 类中的构造方法有以下 3 个。
​ Float(double value)：构造一个新分配的 Float 对象，它表示转换为 float 类型的参数。
​ Float(float value)：构造一个新分配的 Float 对象，它表示基本的 float 参数。
​ Float(String s)：构造一个新分配的 Float 对象，它表示 String 参数所指示的 float 值。

2、Float 类的常用常量
在 Float 类中包含了很多常量，其中较为常用的常量如下。 ​ MAX_VALUE：值为 1.4E38 的常量，它表示 float 类型能够表示的最大值。 ​ MIN_VALUE：值为 3.4E-45 的常量，它表示 float 类型能够表示的最小值。 ​ MAX_EXPONENT: 有限 float 变量可能具有的最大指数。 ​ MIN_EXPONENT：标准化 float 变量可能具有的最小指数。 ​ MIN_NORMAL：保存 float 类型数值的最小标准值的常量，即 2-126。 ​ NaN：保存 float 类型的非数字值的常量。 ​ SIZE：用来以二进制补码形式表示 float 值的比特位数。 ​ TYPE：表示基本类型 float
的 Class 实例。

五、Double类
1、Double 类的构造方法
​ Double 类中的构造方法有如下两个。
​ Double(double value)：构造一个新分配的 Double 对象，它表示转换为 double 类型的参数。
​ Double(String s)：构造一个新分配的 Double 对象，它表示 String 参数所指示的 double 值。
2、Double 类的常用方法

3、Double 类的常用常量
在 Double 类中包含了很多常量，其中较为常用的常量如下。
MAX_VALUE:值为 1.8E308 的常量，它表示 double 类型的最大正有限值的常量。
MIN_VALUE：值为 4.9E-324 的常量，它表示 double 类型数据能够保持的最小正非零值的常量。
NaN：保存 double 类型的非数字值的常量。
NEGATIVE_INFINITY：保持 double 类型的负无穷大的常量。
POSITIVE_INFINITY：保持 double 类型的正无穷大的常量。
SIZE：用秦以二进制补码形式表示 double 值的比特位数。
TYPE：表示基本类型 double 的 Class 实例。
六、Number类
Number 是一个抽象类，也是一个超类（即父类）。Number 类属于 java.lang 包，所有的包装类（如 Double、Float、Byte、Short、Integer 以及 Long）都是抽象类 Number 的子类。

异常处理
一、异常（Exception）处理及常见异常
异常（exception）是在运行程序时产生的一种异常情况，已经成为了衡量一门语言是否成熟的标准之一。
1、简介
Java 中的异常又称为例外，是一个在程序执行期间发生的事件，它中断正在执行程序的正常指令流
在 Java 中一个异常的产生，主要有如下三种原因：
​ 1、Java 内部错误发生异常，Java 虚拟机产生的异常。
​ 2、编写的程序代码中的错误所产生的异常，例如空指针异常、数组越界异常等。
​ 3、通过 throw 语句手动生成的异常，一般用来告知该方法的调用者一些必要信息。
2、异常类型
Java 中所有异常类型都是内置类 java.lang.Throwable 类的子类，即 Throwable 位于异常类层次结构的顶层。Throwable 类下有两个异常分支 Exception 和 Error
Error 和 Exception 两个子类分别表示错误和异常
异常类 Exception 又分为运行时异常和非运行时异常，这两种异常有很大的区别，也称为不检查异常（Unchecked Exception）和检查异常（Checked Exception）
1、Exception 类用于用户程序可能出现的异常情况，它也是用来创建自定义异常类型类的类。
2、Error 定义了在通常环境下不希望被程序捕获的异常。一般指的是 JVM 错误，如堆栈溢出。
运行时异常都是 RuntimeException 类及其子类异常，如 NullPointerException、IndexOutOfBoundsException 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
非运行时异常是指 RuntimeException 以外的异常，类型上都属于 Exception 类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如 IOException、ClassNotFoundException 等以及用户自定义的 Exception 异常
二、Error和Exception的异同
Error（错误）和 Exception（异常）都是 java.lang.Throwable 类的子类，在 Java 代码中只有继承了 Throwable 类的实例才能被 throw 或者 catch。
Exception 是程序正常运行过程中可以预料到的意外情况，并且应该被开发者捕获，进行相应的处理
Error 错误是任何处理技术都无法恢复的情况，肯定会导致程序非正常终止。
如下是常见的 Error 和 Exception：

​ 1）运行时异常（RuntimeException）：
​ NullPropagation：空指针异常；
​ ClassCastException：类型强制转换异常
​ IllegalArgumentException：传递非法参数异常
​ IndexOutOfBoundsException：下标越界异常
​ NumberFormatException：数字格式异常

​ 2）非运行时异常：
​ ClassNotFoundException：找不到指定 class 的异常
​ IOException：IO 操作异常

​ 3）错误（Error）：
​ NoClassDefFoundError：找不到 class 定义异常
​ StackOverflowError：深递归导致栈被耗尽而抛出的异常
​ OutOfMemoryError：内存溢出异常

三、异常处理机制
​ Java 的异常处理通过 5 个关键字来实现：try、catch、throw、throws 和 finally。try catch 语句用于捕获并处理异常，finally 语句用于在任何情况下（除特殊情况外）都必须执行的代码，throw 语句用于拋出异常，throws 语句用于声明可能会出现的异常。
1、在方法中用 try catch 语句捕获并处理异常，catch 语句可以有多个，用来匹配多个异常。
​ 2、对于处理不了的异常或者要转型的异常，在方法的声明处通过 throws 语句拋出异常，即由上层的调用方法来处理。
四、try catch语句（为了处理异常）
可以与多个catch并用
1、try catch语句，捕获异常并且处理异常
语法：
try{
代码块（可能出现错误的代码）
} catch(异常的类型){
处理异常的逻辑代码块
} catch () {
}…
五、try catch finally语句
语法：
try{
可能出现异常的代码块
}catch(异常的类型){
处理异常的代码
}catch (异常的类型) {
处理异常的代码
}…{
}finally{
代码块（不管异常处理结果如何，最终都会走该语句块）
注意：该语句块是在方法结束之前调用的（return语句之前执行）
}
六、声明和抛出异常
1、throws 声明异常
throws 声明的方法表示此方法不处理异常
在方法定义开始时声明
方法重写时声明抛出异常的限制
​ 使用 throws 声明抛出异常时有一个限制，是方法重写中的一条规则：子类方法声明抛出的异常类型应该是父类方法声明抛出的异常类型的子类或相同，子类方法声明抛出的异常不允许比父类方法声明抛出的异常多
2、throw 拋出异常
​ 与 throws 不同的是，throw 语句用来直接拋出一个异常，后接一个可拋出的异常类对象
throws 关键字和 throw 关键字在使用上的几点区别如下：**
1、throws 用来声明一个方法可能抛出的所有异常信息，表示出现异常的一种可能性，但并不一定会发生这些异常；throw 则是指拋出的一个具体的异常类型，执行 throw 则一定抛出了某种异常对象。
通常在一个方法（类）的声明处通过 throws 声明方法（类）可能拋出的异常信息，而在方法（类）内部通过 throw 声明一个具体的异常信息。
2、throws 通常不用显示地捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法； throw 则需要用户自己捕获相关的异常，而后再对其进行相关包装，最后将包装后的异常信息抛出。
七、自定义异常
​ 如果 Java 提供的内置异常类型不能满足程序设计的需求，这时我们可以自己设计 Java 类库或框架，其中包括异常类型。实现自定义异常类需要继承 Exception 类或其子类，如果自定义运行时异常类需继承 RuntimeException 类或其子类。
例：public class UsernameOrPasswordErrorException extends RuntimeException {//构造方法可是有参或无参}

集合，泛型
一、集合：
为了保存数量不确定的数据，以及保存具有映射关系的数据（也被称为关联数组），Java 提供了集合类。
集合类负责保存、盛装其他数据，因此集合类也被称为容器类，Java 所有的集合类都位于 java.util 包下
集合只能保存引用数据类型（保存对象）
Java 集合类型分为 Collection 和 Map，它们是 Java 集合的根接口，这两个接口又包含了一些子接口或实现类。

Collection接口的基本结构（黄色为接口，蓝色是实现的类）

Map接口的基本结构（黄色为接口，蓝色是实现的类）

二、Collection接口
Collection 接口是 List、Set 和 Queue 接口的父接口，通常情况下不被直接使用，使用它的子接口
Collection 接口中定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合

三、List集合
List 是一个有序、可重复的集合，集合中每个元素都有其对应的顺序索引。
允许使用重复元素，通过索引访问指定位置的集合元素
List 实现了 Collection 接口，它主要有两个常用的实现类：ArrayList 类和 LinkedList 类。

  1、ArrayList 类（10个元素）
      ArrayList 类实现了可变数组的大小，存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式，对尾部成员的增加和删除支持较好。
       特点：查询元素快，对元素进行增，删，改速度慢
       ArrayList 类的常用构造方法有如下两种重载形式：

​ 1、ArrayList()：构造一个初始容量为 10 的空列表。
​ 2、ArrayList(Collection<?extends E>c)：构造一个包含指定 Collection 元素的列表，这些元素是按照该 Collection 的迭代器返 回它们的顺序排列的。
2、LinkedList类
LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素

      需要频繁向集合中插入和删除元素时，使用 LinkedList 类
      LinkedList 类随机访问元素的速度则相对较慢。这里的随机访问是指检索集合中特定索引位置的元素

  重点：3、ArrayList 类和 LinkedList 类的区别
    ArrayList 与 LinkedList 都是 List 接口的实现类，因此都实现了 List 的所有未实现的方法，只是实现的方式有所不同

四、Set集合
Set 集合类似于一个罐子，程序可以依次把多个对象“丢进”Set 集合，而 Set 集合通常不能记住元素的添加顺序
Set 集合中不能包含重复的对象，并且最多只允许包含一个 null 元素。
Set 实现了 Collection 接口，它主要有两个常用的实现类：HashSet 类和 TreeSet类。
1、HashSet类
HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时就是使用这个实现类
有很好十五存取和查找功能
特点：
1、不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。
​ 2、HashSet 不是同步的，如果多个线程同时访问或修改一个 HashSet，则必须通过代码来保证其同步。
​ 3、集合元素值可以是 null。
当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据该hashCode 值决定该对象在 HashSet 中的存储位置。
（两个元素通过equals（）方法比较后为true，但hashCode不相等
在 HashSet 类中实现了 Collection 接口中的所有方法。HashSet 类的常用构造方法重载：
1、HashSet()：构造一个新的空的 Set 集合。
​ 2、HashSet(Collection<? extends E>c)：构造一个包含指定 Collection 集合元素的新 Set 集合。
其中，“< >”中的 extends 表示
HashSet 的父类，即指明该 Set 集合中存放的集合元素类型。
c 表示其中的元素将被存放在此 Set 集合中。
注意：在遍历元素（迭代器中）时，不能改集合里的元素
3、TreeSet 类（不常用）

TreeSet 类除了实现 Collection 接口的所有方法之外,还有一下方法

五、Map集合（接口）
​Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键（key）对象和一个值（value）对象。用于保存具有映射关系的数据。
key 和 value 都可以是任何引用类型的数据，Map 的 key 不允许重复，value 可以重复
Map 中的 key 和 value 之间存在单向一对一关系，即通过指定的 key，总能找到唯一的、确定的 value。从 Map 中取出数据时，只要给出指定的 key，就可以取出对应的 value。
（查询效率快，增、删、改效率也高，是当今世界上查询效率最高的数据结构）
Map 接口主要有两个实现类：HashMap 类和 TreeMap 类

Map 集合最典型的用法就是成对地添加、删除 key-value 对，接下来即可判断该 Map 中是否包含指定 key，也可以通过 Map 提供的 keySet() 方法获取所有 key 组成的集合，进而遍历 Map 中所有的 key-value 对
遍历Map集合
1）在 for 循环中使用 entries 实现 Map 的遍历（最常见和最常用的）。
2）使用 for-each 循环遍历 key 或者 values，一般适用于只需要 Map 中的 key 或者 value 时使用。性能上比 entrySet 较好。
3）使用迭代器（Iterator）遍历
4）通过键找值遍历，这种方式的效率比较低，因为本身从键取值是耗时的操作。六、Collections类
Collections 类是 Java 提供的一个操作 Set、List 和 Map 等集合的工具类。Collections 类提供了许多操作集合的静态方法，可以实现集合元素的排序，查找替换和复制等操作
1、排序（正向和逆向）
Collections 提供了如下方法用于对 List 集合元素进行排序。
- void reverse(List list)：对指定 List 集合元素进行逆向排序。

• void shuffle(List list)：对 List 集合元素进行随机排序（shuffle 方法模拟了“洗牌”动作）。
• void sort(List list)：根据元素的自然顺序对指定 List 集合的元素按升序进行排序。
• void sort(List list, Comparator c)：根据指定 Comparator 产生的顺序对 List 集合元素进行排序。
• void swap(List list, int i, int j)：将指定 List 集合中的 i 处元素和 j 处元素进行交换。
  （可不记）- void rotate(List list, int distance)：当 distance 为正数时，将 list 集合的后 distance 个元素“整体”移到前面；当 distance 为负数时，将 list 集合的前 distance 个元素“整体”移到后面。该方法不会改变集合的长度。
  2、查找、替换操作
  以下是常用的方法：
  - int binarySearch(List list, Object key)：使用二分搜索法搜索指定的 List 集合，以获得指定对象在 List 集合中的索引。如果要使该方法可以正常工作，则必须保证 List 中的元素已经处于有序状态。
  - Object max(Collection coll)：根据元素的自然顺序，返回给定集合中的最大元素。
  - Object max(Collection coll, Comparator comp)：根据 Comparator 指定的顺序，返回给定集合中的最大元素。
  - Object min(Collection coll)：根据元素的自然顺序，返回给定集合中的最小元素。
  - Object min(Collection coll, Comparator comp)：根据 Comparator 指定的顺序，返回给定集合中的最小元素。
  - void fill(List list, Object obj)：使用指定元素 obj 替换指定 List 集合中的所有元素。
  - int frequency(Collection c, Object o)：返回指定集合中指定元素的出现次数。
  - int indexOfSubList(List source, List target)：返回子 List 对象在父 List 对象中第一次出现的位置索引；如果父 List 中没有出现这样的子 List，则返回 -1。
  - int lastIndexOfSubList(List source, List target)：返回子 List 对象在父 List 对象中最后一次出现的位置索引；如果父 List 中没有岀现这样的子 List，则返回 -1。
  - boolean replaceAll(List list, Object oldVal, Object newVal)：使用一个新值 newVal 替换 List 对象的所有旧值 oldVal。
  3、复制
  Collections 类的 copy() 静态方法用于将指定集合中的所有元素复制到另一个集合中。执行 copy() 方法后，目标集合中每个已复制元素的索引将等同于源集合中该元素的索引。
  copy()语法：
  void copy(List <? super T> dest,List<? extends T> src)
  dest 表示目标集合对象，src 表示源集合对象。
  注意：当目标集合长度不够而无法包含整个源集合元素，程序会报IndexOutOfBoundsException 异常。
  八、Lambda表达式遍历Collection集合
  Java 8 为 Iterable 接口新增了一个 forEach(Consumer action) 默认方法，该方法所需参数的类型是一个函数式接口（可以使用 Lambda 表达式来遍历集合元素），而 Iterable 接口是 Collection 接口的父接口，因此 Collection 集合也可直接调用该方法。
  forEach(Consumer action) 遍历集合元素时，程序会依次将集合元素传给 Consumer 的 accept(T t) 方法（该接口中唯一的抽象方法）。
  九、Iterator（迭代器）
  1、作用：遍历容器的所有元素，迭代器是一个接口
  Java集合框架的成员
  2、区别：Collection和Map的集合不一样，Collection和Map主要用于盛装其他对象，而Iterator主要用于遍历（迭代访问）Collection集合中的元素
  Iterator 接口隐藏了各种 Collection 实现类的底层细节，向应用程序提供了遍历 Collection 集合元素的统一编程接口
  Iteration接口定义如下4个方法
  1、boolean hasNext()：如果被迭代的集合元素还没有被遍历完，则返回 true。
  ​ 2、Object next()：返回集合里的下一个元素。
  ​ 3、void remove()：删除集合里上一次 next 方法返回的元素。
  ​ 4、void forEachRemaining(Consumer action)：这是 Java 8 为 Iterator 新增的默认方法，该方法可使用 Lambda 表达式来遍历集合元素。
  注意：Iterator 必须依附于 Collection 对象，若有一个 Iterator 对象，则必然有一个与之关联的 Collection 对象。
  Iterator 提供了两个方法来迭代访问 Collection 集合里的元素，并可通过 remove() 方法来删除集合中上一次 next() 方法返回的集合元素。
  Iterator 迭代器采用的是快速失败（fail-fast）机制，一旦在迭代过程中检测到该集合已经被修改（通常是程序中的其他线程修改），程序立即引发 ConcurrentModificationException 异常，而不是显示修改后的结果，这样可以避免共享资源而引发的潜在问题。
  十、Lambda表达式遍历Iterator迭代器
  Java 8 为 Iterator 引入了一个 forEachRemaining(Consumer action) 默认方法，该方法所需的 Consumer 参数同样也是函数式接口。当程序调用 Iterator 的 forEachRemaining(Consumer action) 遍历集合元素时，程序会依次将集合元素传给 Consumer 的 accept(T t) 方法（该接口中唯一的抽象方法）。
  十一、foreach循环遍历Collection集合
  Java 8 起为 Collection 集合新增了一个 removeIf(Predicate filter) 方法，该方法将会批量删除符合 filter 条件的所有元素。该方法需要一个 Predicate 对象作为参数，Predicate 也是函数式接口，因此可使用 Lambda 表达式作为参数。