Java入门-枚举&异常&常用类

今日语录：何为爱情-你陪着我的时候，我从没羡慕过任何人

一、枚举

简介

1、枚举的英文：enumeration，简写enum

2、枚举时一组常量的集合

3、可以这样理解：枚举属于一种特殊的类，里面只包含一组有限的特定对象
应用介绍

1、不需要提供setXxx方法，因为枚举对象值通常为只读

2、对枚举对象/属性使用final + static 共同修饰，实现底层优化

3、枚举对象名通常使用全部大写，常量的命名规范

4、枚举对象根据需要，也可以有多个属性

image-20211128203725494
小结

1、构造器私有化

2、本类内部创建一组对象

3、对外暴露对象（通过为对象添加public final static修饰符）

4、可以提供get方法，但不提供set方法

1、enum关键字

使用enum关键字定义的枚举类

package com.hspedu.enum_;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.AUTUMN);
        System.out.println(Season2.SUMMER);
    }
}
//演示使用enum关键字来实现枚举类
enum  Season2 {//类


    //定义了四个对象, 固定.
//    public static final Season SPRING = new Season("春天", "温暖");
//    public static final Season WINTER = new Season("冬天", "寒冷");
//    public static final Season AUTUMN = new Season("秋天", "凉爽");
//    public static final Season SUMMER = new Season("夏天", "炎热");
    //如果使用了enum 来实现枚举类
    //1. 使用关键字 enum 替代 class
    //2. public static final Season SPRING = new Season("春天", "温暖") 直接使用
    //   SPRING("春天", "温暖") 解读 常量名(实参列表)
    //3. 如果有多个常量(对象)， 使用 ,号间隔即可
    //4. 如果使用enum 来实现枚举，要求将定义常量对象，写在前面
    //5. 如果我们使用的是无参构造器，创建常量对象，则可以省略 ()
    SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"),
    SUMMER("夏天", "炎热")/*, What()*/;

    private String name;
    private String desc;//描述

    private Season2() {//无参构造器

    }

    private Season2(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + ''' +
                ", desc='" + desc + ''' +
                '}';
    }
}

enum关键字实现枚举类注意事项

1、当我们使用enum关键字开发一个枚举类时，默认会继承Enum类

image-20211128205902287

2、传统的public static final Season SPRING = new Season(“春天”，“温暖”)；

简化成SPRING(“春天”,”温暖”)，这里必须知道，他调用的是哪个构造器。

3、如果使用无参构造器创建枚举对象，则实参列表和小括号都可以省略

4、当有多个枚举对象时，使用间隔，最后有一个分号结尾

5、枚举对象必须放在枚举类的首行
例题

image-20211128210430672
enum常用方法说明

说明：

使用关键字enum时，会隐式继承Enum类，这样我们就可以使用Enum类相关方法
```
public abstract class Enum<E extends Enum<E>> implements Comparable<E>,Serializable{
	
}
```
1、toString()：Enum类已经重写过了，返回的是当前对象名，子类可以重写该方法，用于返回对象的属性信息

2、name():返回当前对象名（常量名），子类中不能重写

3、ordinal()：返回当前对象的位置号，默认从0开始

4、values()：返回当前枚举类中所有的常量

5、valueOf()：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常

6、compareTo()：比较两个枚举常量，比较的就是位置号。
enum实现接口
1、使用enum关键字后，就不能再继承其他类了，因为enum会隐式继承Enum，而java是单继承机制

2、枚举类和普通类一样，可以实现接口，如下形式：
```
enum 类名 implements接口1,接口2,..{}
```

二、注解

1、注解（Annotation）也被称为元数据（Metadata）。用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息

2、和注释一样，注解冰箱程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息。

3、在java SE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替java EE旧版中遗留下来的繁冗代码和XML配置等。

Annotation简介

使用Annotation时要在其前面增加@符号，并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素

1、三个基本的Annotation:

a、@Override：限定某个方法、是重写父类方法，该注解只能用于方法

b、@Deprecated：用于表示某个程序元素（类、方法等）已过时

c、@SuppressWarnings:抑制编译器警告

PS：@interface说明：

@interface不是interface，是注解类是jdk1.5之后加入的

1、@Override

@Override使用说明

1、@Override表示指定重写父类的方法（从编译层面验证），如果父类没有fly方法，则会报错

2、如果不写@Override注解，而父类仍有public void fly(){}，仍然构成重写

3、@Override只能修饰方法，不能修饰其他类，包，属性等等

4、查看@Override注解源码为@Target(ElementType.METHOD)，说明只能修饰方法

5、@Target是修饰注解的注解，称为元注解

2、@Deprecated

1、@Deprecated用于表示某个程序元素（类、方法等）已过时

2、可以修饰方法，类、字段、包、参数等等

3、@Taget（value={CONSTRUCTOR,FIELD,LOCAL_VARIABLE,METHOD,PACKAGE,PARAMETER,TYPE}）

4、@Deprecated的作用可以做到新旧版本的兼容和过渡

5、使用@Deprecated修饰的方法、类等，代表过时，不意味着不能继续使用（意为不推荐使用）

3、@SuppressWarnings

1、当我们不希望看到这些警告时，可以使用SuppressWarnings注解来抑制警告信息

2、在{“”}中，可以写入你希望抑制（不显示）的警告信息

3、可以指定的警告类型有：

@SuppressWarning 中的属性介绍以及属性说明

all，抑制所有警告
boxing，抑制与封装/拆装作业相关的警告
cast，抑制与强制转型作业相关的警告
dep-ann，抑制与淘汰注释相关的警告
deprecation，抑制与淘汰的相关警告
fallthrough，抑制与switch陈述式中遗漏break相关的警告
finally，抑制与未传回finally区块相关的警告
hiding，抑制与隐藏变数的区域变数相关的警告
incomplete-switch，抑制与switch陈述式(enum case)中遗漏项目相关的警告
javadoc，抑制与javadoc相关的警告
nls，抑制与非nls字串文字相关的警告
null，抑制与空值分析相关的警告
rawtypes，抑制与使用raw类型相关的警告
resource，抑制与使用Closeable类型的资源相关的警告
restriction，抑制与使用不建议或禁止参照相关的警告
serial，抑制与可序列化的类别遗漏serialVersionUID栏位相关的警告
static-access，抑制与静态存取不正确相关的警告
static-method，抑制与可能宣告为static的方法相关的警告
super，抑制与置换方法相关但不含super呼叫的警告
synthetic-access，抑制与内部类别的存取未最佳化相关的警告
sync-override，抑制因为置换同步方法而遗漏同步化的警告
unchecked，抑制与未检查的作业相关的警告
unqualified-field-access，抑制与栏位存取不合格相关的警告
unused，抑制与未用的程式码及停用的程式码相关的警告

4、关于@SuppressWarnings作用范围是和你放置的位置相关

比如你把@SuppressWarnings放置在main方法，那么抑制警告的范围就是main

通常我们放置举铁语句，方法，类

Java入门-枚举&异常&常用类 — image-20211128220852567

4、元注解

元注解种类

1、Retention // 指定注解的作用范围，三种:SOURCE,CLASS,RUNTIME

2、Target // 指定注解可以在哪些地方使用

3、Documented // 指定该注解是否会在javadoc体现

4、Inherited // 子类会继承父类注解

三、异常（Exception）

简介

Java语言中，将程序执行中发生的不正常情况称为“异常”。（开发中的语法错误或逻辑错误不是异常）
执行过程中所发生的异常事件可分为两类

1、Error(错误)：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError[栈溢出]和OOM[Out of memery内存溢出],Error是严重错误，程序会崩溃

2、Exception：其他因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：空指针访问，视图读取不存在的文件，网络连接中断等，Exception分为两大类：运行时异常（程序运行时发生的异常）和编译时异常（编译时，编译器检查出的异常）

3、类异常体系图

image-20211128232036313
小结

1、异常分为两大类：运行时异常和编译时异常

2、运行时异常，编译器u要求强制处理的异常。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。java.lang.RuntimeException类及其的子类都是运行时异常

3、对于运行时异常，可以不做处理，因为这类一场很普遍，若完全处理可能会对程序的可读性和余小宁效率产生影响

4、编译时异常，是编译器要求必须处置的异常

1、运行时异常

常见运行时异常

1、NullPointerException空指针异常

2、ArithmeticException数学运算异常

3、ArrayIndexOutOfBoundsException数组下标越界异常

4、ClassCaseException类型转换异常

5、NumberFormatException数字格式不正确异常

2、编译异常

简介

指在编译期间，就必须处理的异常，否则代码不能通过编过
常见的编译异常

1、SQLException 操作数据库时，查询表可能发生异常

2、IOException 操作文件时，发生异常

3、FileNotFoundException 当操作一个不存在的文件时，发生异常

4、ClassNotFoundException 加载不存在的类时，发生异常

5、IllegalArguementException 参数异常

四、异常处理

简介

异常处理就是当异常发生时，对异常的处理方式
异常处理的方式

1、try-catch-finally

程序员在代码中捕获发生的异常，自行处理
```
try{
	可疑代码块
	将异常生成对应的异常对象，传递给catch块
}catch(异常){
	对异常的处理
}
```
2、throws

将发生的异常抛出，交给调用者（方法）来处理，最顶级的处理者就是JVM

基本介绍

1、如果一个方法（中的语句执行时）可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显式地声明并抛出异常，表明该方法将不对这些异常进行处理，而是由方法的调用者负责处理

2、在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

3、throws关键字后也可以是异常列表，既可以抛出多个异常
注意事项和使用细节

1、对于编译异常，程序中必须处理，比如try-catch或throws

2、对于运行时异常，程序中如果没有处理，默认就是throws的方式处理

3、子类重写父类的方法时，对抛出异常的规定：子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出异常的类型的子类型

4、在throws过程中，如果有方法try-catch，就相当于处理异常，就可以不必throws
注意事项
1、如果发生了异常，则异常发生后面的代码不会执行，直接进入catch

2、如果异常没有发生，则程序顺序执行try的代码块，不会进入catch块

3、如果希望不管是否发生异常，都执行某段代码（比如关闭连接，释放资源等）

则使用finally{}

4、可以有多个catch语句，捕获不同的异常进行不同的业务处理，要求父类异常在后，子类异常在前，比如（Exception 在后，NullPointerException在前），如果发生异常，只会匹配一个catch

5、可以进行try-catch-finally配合使用，这种用法相当于没有捕获异常，因此程序会直接崩掉。应用场景：就是执行一段代码，不管是否发生异常，都必须执行某个业务逻辑
```
try{
	代码
}
finally{
	总是执行
}
```
语法：

PS：如果程序员没有显式的声明try-catch，那么默认使用throws抛出异常。

1、throw VS throws

	意义	位置	后面跟的东西
throws	异常处理的一种方式	方法声明处	异常类型
throw	手动生成异常对象的关键字	方法体中	异常对象

五、常用类

1、包装类

包装类的分类 Wrapper

1、针对八种基本定义相应的引用类型-包装类

2、有了类的特点，就可以调用类中的方法

基本数据类型	包装类	父类
boolean	Boolean
char	Character
byte	Byte	Number
short	Short	Number
int	Integer	Number
long	Long	Number
float	Float	Number
double	Double	Number

包装类和基本数据的转换

1、jdk5前的手动装箱和拆箱方式，装箱：基本类型->包装类型，反之，拆箱

2、jdk5以后（含jdk5）的自动装箱和拆箱方式

3、自动装箱底层调用的是valueOf方法，比如Integer.valueOf()

image-20211130222802398

包装类型和String类型的相互转换

包装类（Integer）->String
Integer i = 100;
方式一：String str1 = i + "";
方式二：String str2 = i.toString();
方式三: String str3 = String.valueOf(i);

String -> 包装类(Integer)
String str4 = "234";
方式一：Integer i2 = Integer.parseInt(str4);
方式二：Integer i3 = new Integer(str4);

2、String类

简介
1、String对象用于保存字符串，也就是一组字符序列

2、字符串常量对象使用双引号括起来的字符序列。例如：“你好”、“123”等

3、字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节

4、String类较常用的
```
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count);
```
image-20211130230501668

5、String 类实现了接口 Serializable【String 可以串行化：可以在网络传输】

6、String 是 final 类，不能被其他类继承

7、String 有属性 private final char value[];用于存放字符串内容

8、一定要注意：value 是一个final类型，不可以修改（需要功力）：即value不能指向新的地址，但是单个字符内容是可以变化的
创建String对象的两种方式

1、方式一：直接赋值 String s = “asd”;

2、方式二：调用构造器 String s = new String(“asd”);

区别：

1、方式一：先从常量池查看是否有“asd”数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址

2、方式二：先在堆中创建空间，里面维护了value属性，指向常量池的asd空间。如果常量池没有“asd”，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址

3、画出两种方式的内存分布图

当调用intern方法时，如果池中已经包含一个等于此String对象的字符串（用equals(Object)方法确定），则返回池中的字符串。否则，将此String对象添加到池中，并返回此String对象的引用。

PS:b.intern()方法返回的是常量池的地址（对象）

3、字符串的特性

1、String是一个final类，代表不可变的字符序列

2、字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的

3、例题一：

image-20211202214744922

例题二：

image-20211202215526071

内存图：

image-20211202215616390

image-20211202215850592

4、String类的常用方法

1、String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因此java设计者还提供了StringBuilder和StringBuffer来增强String的功能，并提高效率。

equals：区分大小写，判断内容是否相等

equalsIgnoreCase：忽略大小写的判断内容是否相等

length：获取字符的个数，字符串的长度

indexOf：获取字符在字符串中第一次出现的索引，索引从0开始，如果找不到，返回-1

lastIndexOf：获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1

substring：截取指定范围的字串

trim：去除前后空格

charAt：获取某索引处的字符，注意不能使用Str[index]这种方式

toUpperCase：转大写字母

tuLowerCase：转小写字母

concat：拼接字符串

replace：替换字符串中的字符

split：分割字符串，对于某些字符串，我们需要转义

toCharArray():抓换成字符串数组

compareTo()：比较两个字符串的大小，如果前者大，则返回正数，如果后者大，则返回负数，如果相等，返回0

1、如果长度相同，并且每个字符也相同，则返回0

2、如果长度相同或者不同，但是在进行比较时，可以区分大小就返回
if(c1 != c2)
{
	return c1 - c2;
}
3、如果前面的部分都相同，就返回 str1.len – str2.len

format：格式字符串

占位符有：%s 字符串 %c 字符 %d 整型 %.2f 浮点型
例如:
String str = String.format("我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c，希望大家喜欢我！", name, age, score, gender);
image-20211202225213824

5、StringBuffer类

简介

1、java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删

2、很多方法与String相同，但StringBuffer是可变长度的。

3、StringBuffer是一个容器。

4、类图：

image-20211202230235092

image-20211202230336258
String VS StringBuffer

1、String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率更低

2、StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新内容，不用更新地址，效率较高
StringBuffer的构造器

StringBuffer(CharSequence seq)

public java.lang.StringBuilder(CharSequence seq)构造一个字符串缓冲区，它包含与指定的CharSequence相同的字符
StringBuffer(int capacity) // capacity：容量

构造一个不带字符，但具有指定初始容量的字符串缓冲区。即对char[]大小进行指定

StringBuffer(String str)

构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容

String  -->  StringBuffer
String str = "chenx";
方式一：使用构造器
注意：返回的是StringBuffer对象，对str本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);

方式二：使用append方法
StringBuffer stringBufferSec = new StringBuffer();
stringBufferSec = StringBufferSec.append(str);

StringBuffer --> String
StringBuffer stringBuffer = new StringBuffer("chenx");
方式一：使用toString()方法
String str = stringBuffer.toString();

方式二:使用构造器
String str2 = new String(stringBuffer);

StringBuffer类常用方法
1、增 append

2、删 delete(Start,End)

3、改 replace(start, end, string) –>将start—-end间的内容替换掉，不含end

4、查indexOf //查找子串在字符串第i次出现的索引，如果找不到则返回-1

5、插 insert

6、获取长度 length

例题一：

image-20211202233014104

例题二：
```
String price = "21345678.9";
StringBuffer sb = new StringBuffer(price);

for(int i=sb.lastIndexOf(".")-3;i>0;i-=3){
	sb = sb.insert(",");
}
System.out.println(sb); // -> 12,345,678.9
```

6、StringBuilder类

简介

1、一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但不保证同步（StringBuilder是非线程安全的）。该类被设计用作StrinBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先使用该类，因为在大多情况下，StringBuilder比StringBuffer要快。

2、在StringBuffer上的主要操作是append和insert方法，可重载这些方法，以接收任意类型的数据。

3、类图：

image-20211202234655526

image-20211202235102328

7、String VS StringBuffer VS StringBuilder

1、StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样

2、String:不可变字符序列，效率低，但是复用率高

3、StringBuffer：可变字符序列、效率高（增删）、线程安全

4、StringBuilder：可变字符序列、效率最高、非线程安全

5、String使用注意说明：

String s = “a”; // 创建一个字符串

s+=”b”; // 实际上原来的“a”字符串对象已经丢弃了，现在又产生了一个字符串s += “b”;（也就是”ab”）。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象留存在内存中，降低效率。如果这样的操作放在循环中，会极大影响程序的性能

总结：如果我们对String做大量修改，不要使用String

使用原则：

1、如果字符串存在大量修改操作，一般使用StringBuffer或StringBuilder

2、如果字符串存在大量修改操作，且在单线程的情况，使用StringBuilder

3、如果字符串存在大量修改操作，且在多线程情况，使用StringBuffer

4、如果我们对字符串很少修改，被多个对象引用，使用String，比如配置信息等。

StringBuilder和StringBuffer的使用方法一致，互通

8、Math类

简介

Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数

常用方法

1、abs:绝对值

2、pow:求幂

3、ceil：向上取整

4、floor：向下取整

5、round：四舍五入

6、sqrt:求开方

7、random：求随机数

Math.random() * (b-a) 返回的就是0 <= 数 <= b-a
（1）（int）(a) <= x <= (int)(a + Math.random() * (b - a + 1))
（2）使用具体的数给小伙伴介绍 a = 2   b = 7
 （int）(a + Math.random() * (b - a + 1)) = (int)(2 + Math.random * 6)
 Math.random() * 6 返回的是 0 <= x < 6 小数
 2 + Math.random() * 6返回的就是2 <= x < 8小数
 (int)(2 Math.random() * 6) = 2 <= x <= 7
（3）公式就是(int)(a + Math.random() * (b - a + 1))

例题一：
随机取 2 <= X <= 7
for(int i=0;i<10;i++){
 System.out.println((int)(2 + Math.random()*(7-2+1));
}

8、max：求两个数最大值

9、min：求两个数最小值

9、Arrays类

常见方法

1、toString()返回数组的字符串形式

Arrays.toString(arr)

2、sort排序（自然排序和定制排序）

Integer arr[] = {1,-1,7,0,89}

方法一：自然排序
Arrays.sort(arr);

方法二：定制排序
Arrays.sort(arr,new Comparator(){
 @Override
 public int compare(){
  Integer i1 = (Integer)o1;
  Integer i2 = (Integer)o2;
  return i2 - i1;
 }
});

源码分析：
1、Arrays.sort(arr,new Comparator(){
public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {
            sort(a); 
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0); // 1 走这
        }
    }
2、static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
                         T[] work, int workBase, int workLen) {
        assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;

        int nRemaining  = hi - lo;
        if (nRemaining < 2)
            return;  // Arrays of size 0 and 1 are always sorted

        // If array is small, do a "mini-TimSort" with no merges
        if (nRemaining < MIN_MERGE) {
            int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
            binarySort(a, lo, hi, lo + initRunLen, c);   // 2 走这
            return;
        }
3、private static <T> void binarySort(T[] a, int lo, int hi, int start,
                                       Comparator<? super T> c) {
        assert lo <= start && start <= hi;
        if (start == lo)
            start++;
        for ( ; start < hi; start++) {
            T pivot = a[start];

            // Set left (and right) to the index where a[start] (pivot) belongs
            int left = lo;
            int right = start;
            assert left <= right;
            /*
             * Invariants:
             *   pivot >= all in [lo, left).
             *   pivot <  all in [right, start).
             */
             
             /**
             *执行到binarySort方法的代码，会根据动态绑定机制c.compare()执行我们传入的匿名内部类的compare()
             */
            while (left < right) {
                int mid = (left + right) >>> 1;
                if (c.compare(pivot, a[mid]) < 0)
                    right = mid;
                else
                    left = mid + 1;
            }
            assert left == right;
4、new Comparator(){
 @Override
 public int compare(){
  Integer i1 = (Integer)o1;
  Integer i2 = (Integer)o2;
  return i2 - i1;
 }
5、public int compare(Object o1,Object o2)返回的值>0 还是<0会影响整个排序结果，这就充分体现了接口编程+动态绑定+匿名内部类的综合使用，将来的底层框架和源码的使用

3、binarySearch通过二分搜索法进行查找，要求必须排好序

int index = Arrays.binarySearch(arr,3);

1、使用binarySearch()二叉查找
2、要求数组是有序的，如果该数组不是有序的，不能使用binarySearch
3、如果数组中不存在该元素，那么索引值返回-1

4、Array模拟排序

package com.hspedu.arrays_;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class ArraysSortCustom {
    public static void main(String[] args) {

        int[] arr = {1, -1, 8, 0, 20};
        //bubble01(arr);

        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i2 - i1;// return i2 - i1;
            }
        });

        System.out.println("==定制排序后的情况==");
        System.out.println(Arrays.toString(arr));

    }

    //使用冒泡完成排序
    public static void bubble01(int[] arr) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //从小到大
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    //结合冒泡 + 定制
    public static void bubble02(int[] arr, Comparator c) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
                if (c.compare(arr[j], arr[j + 1]) > 0) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

5、copyOf数据元素的复制

Integer[] newArr = Arrays.coptOf(arr,arr.length);

6、fill：数组元素的填充(使用该元素，替换原来的元素)

Interger[] num = new Integer[]{9,4,3};
Arrays.fill(num,99);

替换后结果:
{99,99,99}

7、equals：比较两个元素是否完全一致

8、asList：将一组值转换为list

1、asList方法，会将(1,2,3)转换成list集合
2、返回的asList编译类型List（接口）
3、asList运行类型是java.util.ArrayList;

10、System类

常用方法

1、exit退出当前程序

2、arraycopy：复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组

int[] src = {1,2,3};

int[] dest = new int[3];

System.arraycopy(src,0,dest,0,3);

参数说明：
源数组
* @param   src      the source array.  

  从原数组的哪个索引位置开始拷贝
* @param   srcPos   starting position in the source array. 

  目标数组，即把原数组的数据拷贝到哪个数组
* @param   dest     the destination array.  

  把原数组的数据拷贝到 目标数组的哪个索引
* @param   destPos  starting position in the destination data.

  length:从源数组拷贝多少个数据到目标数组
* @param   length   the number of array elements to be copied.

3、currentTimeMillens：返回当前时间距离1970-1-1的毫秒数

4、gc：运行垃圾回收机制System.gc()；

11、BigInteger类和BigDecimal类

简介

1、Biginteger适合保存比较大的整型

2、BigDecimal适合保存精度更高的浮点型（小数）
常用方法

1、加：add

2、减：subtract

3、乘：multiply

4、除：divide

12、Date类(第一代日期类)

第一代日期类

1、Date：精确到毫秒，代表特定的瞬间

2、SimpleDateFormat：格式化和解析日期的类

SimpleDateFormat：格式化和解析日期的具体类。它允许进行格式化（日期->文本）、解析（文本->日期）和规范化
常用方法
1、获取当前系统时间：Date date = new Date();

2、通过指定毫秒数得到时间：Date d2 = new Date(9234576);

3、SimpleDateFormat：格式化日期和解析日期类
```
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
```
image-20211205163307332

13、Calendar类（第二代日期类）

第二代日期类

image-20211205164045172

主要就是Calendar类（日历）
```
public abstract class Calendar extends Object implements Serializable,Cloneable,Compareable<Calendar>
```

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
可以通过 getInstance()方法获取实例
没有专门的格式化方法，需要程序员自己组合展示
如果我们需要按24小时进制来获取时间，Calendar.HOUR==>Calendar.HOUR_OF_DAY

常用示例

Calendar c = Calendar.getInstance();
System.out.println("年:"c.get(Calendar.YEAR));
System.out.println("月:"c.get(Calendar.MONTH));
System.out.println("日:"c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时:"c.get(Calendar.HOUR));
System.out.println("分钟:"c.get(Calendar.MINUTE));
System.out.println("秒:"c.get(Calendar.SECOND));

14、第三代日期类

前面两代日期类的不足分析

JDK1.0包含了一个java.util.Date类，但是它的大多数方法已经在JDK1.1引入Calendar类之后被弃用，而Calendar也存在的问题是：

1、可变性：像日期和时间这样的类应该是不可变的

2、偏移性：Date中的年份是从1900开始的，而月份都是从0开始

3、格式化：格式化只对Date有用，Calendar不行

4、他们也不是线程安全的：不能处理闰秒等（每隔2天，多出1s）
第三代日期类常用方法

LocalDate(日期)

image-20211205172240323

LocalTime(时间)

image-20211205172330778

**LocalDateTime(日期时间)**JDK8后才有

image-20211205172406495
1、LocalDate：只包含日期，可以获取日期字段

2、LocalTime：只包含时间，可以获取时间字段

3、LocalDateTme 包含日期+时间可以获取日期和时间字段‘

4、DateTimeFormatter格式日期类

类似于SimpleDateFrmat
```
LocalDateTime now = LocalDateTime.now();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String dateStr = dtf.format(now);
System.out.println(dateStr);

运行结果：
2021-12-05 17:53:33
```
5、Instant：时间戳
```
Instant -->  Date
Date date = Date.from(instant);

Date --> Instant
Instant instant = date.toInstant();
```
6、MonthDay类：检查重复事件

7、是否是闰年

8、增加日期的某个部分

9、使用plus方法测试增加时间的某个部分

10、使用minus方法测试查看一年前和一年后的日期
小伙伴们，情人节祝福，虽迟但到，祝大家学的愉快~