第九章：Java常用类

package com.jiayifeng.java1;

import org.junit.Test;

/**
 * author xiaojia
 * create 2023-09-11 8:09
 *
 * 快捷键：alt + shift + s：构造器
 *
 * 一：String的使用
 */
public class StringTest {
     /*
     1.String实现了Serializable接口：表示字符串是支持序列化的
     2.String实现了Comparable接口：表示String可以比较大小
     3.String内部定义了final char[] value用于存储字符串数据
     4.String：代表不可变的字符序列。简称：不可变性
          体现1：当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
          体现2：当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
          体现3：当调用String的replace()方法修饰指定字符或字符串时，也需要重新指定内存区域
     5.通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中
     6.字符串常量池中是不会存储相同内容的字符串的
      */
     @Test
     public void test1(){
          String s1 = "abc";
          String s2 = "abc";
          s1 = "Hello";

         System.out.println(s1 == s2); //比较s1和s2的地址值

         System.out.println(s1);
         System.out.println(s2);
         System.out.println("*********************888");

         String s3 = "abc";
         s3 += "def";

         String s4 = "abc";
         String s5 = s4.replace('a', 'm');
         System.out.println(s4); //abc
         System.out.println(s5); //mbc
     }

     /*
     String的实例化方式：
        方式一：通过字面量定义的方式
        方式二：通过new + 构造器的方式
        面试题：String s = new String("abc");这种方式创建的对象，在内存中创建了几个对象？
            两个：一个是堆空间中的new结构，另一个是char[]对应的常量池中的数据："char"
      */
    @Test
    public void test2(){
//        通过字面量定义的方式：此时的s1和s2的数据声明在方法区的字符串常量池中
        String s1 = "javaEE";
        String s2 = "javaEE";
//        通过new + 构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟以后对应的地址值
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");

        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s1 == s4);
        System.out.println(s3 == s4); //false
        System.out.println("***************************");

        Person p1 = new Person("Tom",12);
        Person p2 = new Person("Tom",12);
        System.out.println(p1.name.equals(p2.name)); //true
        System.out.println(p1.name == p2.name); //true

        p1.name = "Jerry";
        System.out.println(p2.name); //Tom：不可变性
    }

    /*
    字符串的特性:
        1.常量与常量的拼接结果在常量池。且常量池不会存在相同内容的常量
        2.只要其中有一个是变量，结果就在堆中
        3.如果拼接的结果调用intern()方法，返回值就在常量池中
     */
    @Test
    public void test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = (s1 + s2).intern();

        System.out.println(s3 == s4); //true
        System.out.println(s3 == s5); //false
        System.out.println(s3 == s6); //false
        System.out.println(s5 == s6); //false
        System.out.println(s3 == s7); //true
        System.out.println(s5 == s7); //false
        System.out.println(s6 == s7); //false

        System.out.println(s4 == s7); //true
    }
}

9.1.2：String方法

package com.jiayifeng.java1;

import com.sun.xml.internal.ws.addressing.WsaActionUtil;
import org.junit.Test;

import java.util.Locale;

/**
 * author xiaojia
 * create 2023-09-11 14:36
 */
public class StringMethodTest {
    @Test
    public void test1(){
        String s1 = "HelloWorld";
        System.out.println(s1.length()); //返回字符串的长度：10

        System.out.println(s1.charAt(0)); //返回某索引处的字符：H
        System.out.println(s1.charAt(9)); //d

        System.out.println(s1.isEmpty()); //判断是否是空字符串：false

        String s2 = s1.toLowerCase(); //使用默认语言环境，将String中的所有字符转换为小写
        System.out.println(s1); //HelloWorld：s1是不可变的，仍然为原来的字符串
        System.out.println(s2); //helloworld：改成小写以后的字符串

        String s3 = s1.toUpperCase(); //使用默认语言环境，将String中的所有字符转换为大写
        System.out.println(s1); //HelloWorld
        System.out.println(s3); //HELLOWORLD

        String s4 = "  he  llo world";
        String s5 = s4.trim();
        System.out.println("--------" + s3 + "--------"); //返回字符串的副本，忽略前导空白和尾部空白
        System.out.println("--------" + s4 + "--------");

        System.out.println(s1.equals(s4)); //比较字符串的内容是否相同"：false
        System.out.println(s1.equalsIgnoreCase(s4)); //与equals()方法类似，忽略大小写：false

        System.out.println(s1.concat(s4)); //将指定字符串连接到此字符串的结尾

        String s6 = "abc";
        String s7 = "hello";
        System.out.println(s6.compareTo(s7)); //比较两个字符串的大小，涉及到字符串排序：负数-7

        String s8= "北京欢迎你！";
        String s9 = s8.substring(2);
        System.out.println(s8);
        System.out.println(s9); //返回一个新的字符串，它是此字符串从beginIndex开始截取的：欢迎你！

        System.out.println(s8.substring(2,4)); //(左闭右开)返回一个新的字符串，它是此字符串从beginIndex开始截取的，从endIndex(不包含)结束的：欢迎
    }

    @Test
    public void test2(){
        String str1 = "helloworld";
        boolean b1 = str1.endsWith("ld"); //测试此字符是否以指定的后缀结束
        System.out.println(b1); //true

        boolean b2 = str1.startsWith("he"); //测试此字符是否以指定的前缀结束
        System.out.println(b2); //true

        boolean b3 = str1.startsWith("ll",2);
        System.out.println(b3); //true
    }

    @Test
    public void test3(){
//        替换
        String str1 = "北京欢迎你！";
        String str2 = str1.replace('北', '南'); //返回一个新的字符串
        System.out.println(str1); //北京欢迎你
        System.out.println(str2); //南京欢迎你

        String str3 = str1.replace("北京", "上海");
        System.out.println(str3); //上海欢迎你

//        匹配
//        判断str字符串中是否全部由数字组成，即有1-n个数字组成
        String str = "12345";
        boolean matches = str1.matches("\\d+");
        System.out.println(matches); //false

        String tel = "0571-4534289";
//        判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\\d{7,8}");
        System.out.println(result); //true

//        切片
        str = "hello|world|java";
        String[] strs = str.split("\\|");
        for(int i = 0;i < strs.length;i++){
            System.out.println(strs[i]);
        }
    }
}

9.1.3：String与char[]、byte[]之间的转换

package com.jiayifeng.java2;

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
 * author xiaojia
 * create 2023-09-12 15:29
 *
 * 一：String与char[]之间的转换：
 *      String --> char[]：调用String的toCharArray()
 *      char[] --> String:调用String的构造器
 *
 * 二：String与byte[]之间的转换：
 *  编码：String --> byte[]：调用String的getBytes()
 *  解码：byte[] --> String：调用String的构造器
 *
 *  编码：字符串 --> 字节（看得懂 ---> 看不懂的二进制数据）
 *  解码：编码的逆过程，字节 -->（看不懂的二进制数据 ---> 看得懂）
 *
 *  说明：解码时，要求使用的字符集必须与编码时使用的字符集一致，否则会出现乱码
 */
public class StringTest {
    @Test
    public void test1(){
        String str1 = "abc123";
        char[] charArray = str1.toCharArray();
        for(int i = 0;i < charArray.length;i++){
            System.out.print(charArray[i] + " ");
        }

        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);
    }

    @Test
    public void test2(){
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes(); //使用默认的字符集，进行编码
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = new byte[0]; //使用gbk字符集进行编码
        try {
            gbks = str1.getBytes("gbk");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Arrays.toString(gbks));
        System.out.println("**********");

        String str2 = new String(bytes); //使用默认的字符集，进行解码
        System.out.println(str2);

        String str3 = new String(gbks);
        System.out.println(str3); //出现乱码的原因：编码集和解码集不一致

        String str4 = null;
        try {
            str4 = new String(gbks, "gbk");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
        System.out.println(str4); //没有出现乱码原因：编码集和解码集一致
    }
}

9.1.4：StringBuffer和StringBuilder的使用

package com.jiayifeng.java2;

import org.junit.Test;

/**
 * author xiaojia
 * create 2023-09-14 15:48
 *
 * 一：关于StringBuffer和StringBuilder的使用
 *
 * 二：关于StringBuffer和StringBuilder中的方法使用
 */
public class StringBufferBuilderTest {
    /*
    一：关于StringBuffer和StringBuilder的使用
    1.String和StringBuffer和StringBuilder的异同？
       String：不可变的字符序列；底层使用char[]存储
       StringBuffer：可变的字符序列；线程安全的，效率低；底层使用char[]存储
       StringBuilder：可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

       效率：StringBuilder > StringBuffer > String

       源码分析：
       String str = new String(); //char[] value = new char[0];
       String str1 = new String("abc");char[] value = new char[]{'a','b','c'};

       StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组
       sb1.append('a'); //value[0] = 'a';
       sb1.append('b'); //value[1] = 'b';

       StringBuffer sb2 = new StringBuffer("abc"); //char[] value = new char["abc".length() + 16];

       question1: System.out.println(sb2.length()); //3
       question2:扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组
                 默认情况下，扩容为原来的2倍 + 2，同时将原有数组中的元素复制到新的数组中

                 指导意义：在开发过程中，建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

     */

    /*
    总结：
        增：append(xxx)
        删：delete(int start,int end)
        改：setCharAt(int n,char ch) / replace(int start,int end,String str)
        查：charAt(int offset,xxx)
        长度：length();
        遍历：for() + charAt() + toString()
     */

    @Test
    public void test() {
        StringBuffer sb1 = new StringBuffer("abc");
        sb1.setCharAt(0,'m');
        System.out.println(sb1); //mbc

        StringBuffer sb2 = new StringBuffer();
        System.out.println(sb2.length()); //0
    }

    @Test
    public void test2(){
        StringBuffer s1 = new StringBuffer("abc");
        s1.append(1);
        s1.append('1'); //提供了很多的append()的方法，用于进行字符串拼接
        System.out.println(s1);

        s1.delete(2,4); //删除指定位置的内容
        System.out.println(s1);

        s1.replace(1,4,"hello"); //把[start,end]位置替换为str
        System.out.println(s1);

        s1.insert(2,false); //在指定位置插入xxx
        System.out.println(s1);

        s1.reverse(); //将当前字符序列逆转
        System.out.println(s1);
    }
}

9.2：JDK 8之前的日期时间API

package com.jiayifeng.java3;

import com.sun.xml.internal.ws.util.xml.CDATA;
import org.junit.Test;

import java.sql.SQLOutput;
import java.util.Date;

/**
 * author xiaojia
 * create 2023-09-14 17:11
 *
 * 一：JDK 8之前日期和时间的API测试
 */
public class DateTimeTest {
    /*
    java.util.Date类
            |---java.sql.Data类
    1.两个构造器的使用
        >构造器一：Data()：创建一个对应当前时间的Data对象
        >构造器二：创建指定毫秒数的的Date对象
    2.两个方法的使用对应的毫秒数（时间戳）

    3.java.sql.Date对应着数据库中的日期类型的变量
        >如何实例化？
        >如何util.Date对象转换为sql.Date对象？
     */
    @Test
    public void test2(){
//        构造器一：Data()：创建一个对应当前时间的Data对象
        Date date1 = new Date();
        System.out.println(date1.toString());//Thu Sep 14 17:25:55 CST 2023

        System.out.println(date1.getTime());//1694683555892

//        构造器二：创建指定毫秒数的的Date对象
        Date date2 = new Date(1694683555892l);
        System.out.println(date2.toString());//Thu Sep 14 17:25:55 CST 2023

//        创建java.sql.Date对象
        java.sql.Date date3 = new java.sql.Date(1694683555892L);
        System.out.println(date3);//2023-09-14

//        如何util.Date对象转换为sql.Date对象
//        情况一：
        Date date4 = new java.sql.Date(1694683555892L);
        java.sql.Date date5 = (java.sql.Date)date4;
//        情况二：
        Date date6 = new Date();
        java.sql.Date date7 = new java.sql.Date(date6.getTime());
        System.out.println(date7);//2023-09-14
    }
    @Test
    public void test(){
//        1.System类中的currentTimeMills()
        long time = System.currentTimeMillis();
//        返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差
//        称为事件戳
        System.out.println(time);
    }
}

package com.jiayifeng.java3;

import org.junit.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * author 爱编程的小贾
 * create 2023-09-16 8:23
 *
 * 一：jdk 8之前的日期时间的API测试
 */
public class DateTime1Test {
    /*
    SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析
        1.两个操作
            1.1：格式化：日期 ---> 字符串
            1.2：解析：格式化的逆过程，字符串 ---> 日期

        2.SimpleDateFormat的实例化
     */
    @Test
    public void test1() throws ParseException {//异常：对写的日期字符串格式不识别，不是系统默认的格式
//        实例化：使用默认的构造器
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();

//        格式化：日期 ---> 字符串
        Date d1 = new Date();
        System.out.println(d1);//Sat Sep 16 08:35:04 CST 2023

        String format = simpleDateFormat.format(d1);
        System.out.println(format);//23-9-16 上午8:35

//        解析：格式化的逆过程，字符串 ---> 日期
        String str = "23-9-16 上午8:35";
        Date date1 = simpleDateFormat.parse(str);
        System.out.println(date1);//Sat Sep 16 08:35:00 CST 2023

//        ********按照指定的方式格式化和解析：调用带参的构造器*********************
//        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy.MM.dd hh:mm:ss");
//        格式化
        String format1 = sdf1.format(d1);
        System.out.println(format1);//02023.九月.16 公元 08:46 上午
        //2023.09.16 08:48:32
//        解析
        Date d2 = sdf1.parse("2023.09.16 08:48:32");
        System.out.println(d2);//Sat Sep 16 08:48:32 CST 2023
    }

    /*
    calendar日历类(抽象类)的使用：

     */
    @Test
    public void test2(){
//        1.实例化
//        方式一：创建其子类(GregorianCalendar)的对象
//        方式二：调用其静态方法getInstance()
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getClass());//class java.util.GregorianCalendar

//        2.常用方法
//        get()
        int days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));

//        set()
        calendar.set(Calendar.DAY_OF_MONTH,22);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);

//        add()
        calendar.add(Calendar.DAY_OF_MONTH,3);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);

//        getTime()：日历类 ---> Date
        Date date = calendar.getTime();
        System.out.println(date);//Mon Sep 25 09:18:09 CST 2023

//        setTime()：Date ---> 日历类
        Date date1 = new Date();
        calendar.setTime(date1);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);//16
    }
}

9.3：JDK 8中新日期时间API

9.3.1：LocalDate、LocalTime、LocalDateTime的使用

9.3.2：瞬时Instant

定义：时间线上的一个瞬时点，这可能被用来记录应用程序中的时间戳（时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数）

精度：纳米级

1秒 = 1000毫秒 = 10^6微秒 = 10^9纳秒

package com.jiayifeng.java3;

import org.junit.Test;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;

/**
 * author 爱编程的小贾
 * create 2023-09-16 9:20
 *
 * 一：jdk 8之中新日期时间API测试
 */
public class DateTimeTest2 {
    /*
    LocalDate、LocalTime、LocalDateTime的使用

     */
    @Test
    public void test1(){
//        now()：获取当前的日期、时间、日期+时间
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println(localDate);
        System.out.println(localTime);
        System.out.println(localDateTime);

//        of()：设置指定的年、月、日、时、分、秒。没有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2020,10,6,13,23,33);
        System.out.println(localDateTime1);

//        getXxx()：获取相关属性
        System.out.println(localDateTime1.getDayOfMonth());
        System.out.println(localDateTime1.getMonth());

//        体现不可变性
//        withXxx()：设置相关属性
        LocalDate localDate1 = localDate.withDayOfMonth(22);
        System.out.println(localDate);//2023-09-16
        System.out.println(localDate1);//2023-09-22

//        体现不可变性
        LocalDateTime localDateTime2 = localDateTime.plusMonths(3);
        System.out.println(localDateTime);//2023-09-16T09:45:52.880
        System.out.println(localDateTime2);//2023-12-16T09:45:52.880

//        减：minus
        }
    /*
    Instant的使用

    */
    @Test
    public void test2(){
//        now()：获取本初子午线对应的标准时间
        Instant instant = Instant.now();
        System.out.println(instant);//2023-09-16T02:01:11.290Z(差8小时)

//        添加时间的偏移量
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);//2023-09-16T10:02:13.971+08:00

//        获取自1970年01月01日00时00分00秒(UTC)开始的毫秒数
        long milli = instant.toEpochMilli();
        System.out.println(milli);//1694830048763

//        ofEpochMilli()：通过给定的毫秒数获取Instant实例
        Instant instant1 = Instant.ofEpochMilli(1694829971692l);
        System.out.println(instant1);//2023-09-16T02:06:11.692Z
    }

    /*
    DateTimeFormatter：格式化或解析日期、时间
    类似于SimpleDateFormat

     */
    @Test
    public void test(){
//        方式一：预定义的标准格式
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
//        格式化：日期 ---> 字符串
        LocalDateTime localDateTime = LocalDateTime.now();
        String str1 = formatter.format(localDateTime);
        System.out.println(localDateTime);//2023-09-16T10:16:54.890
        System.out.println(str1);//2023-09-16T10:16:54.89

//        解析：字符串 ---> 日期
        TemporalAccessor parse = formatter.parse("2023-09-16T10:16:54.89");
        System.out.println(parse);//{},ISO resolved to 2023-09-16T10:16:54.890

//        方式二：本地化相关的格式
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
//        格式化
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2);//23-9-16 上午10:21


//        方式三：自定义的格式（常用）
        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
//        格式化
        String str4 = formatter2.format(LocalDateTime.now());
        System.out.println(str4);//2023-09-16 10:28:04

//        解析
        TemporalAccessor accessor = formatter2.parse("2023-09-16 10:28:04");
        System.out.println(accessor);
    }
}

9.4：Java比较器

9.4.1：自然排序java.util.Comparable

package com.jiayifeng.java4;

/**
 * author 爱编程的小贾
 * create 2023-09-16 13:26
 */
public class Goods implements Comparable{
    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

//    指明商品比较大小的方式：按照价格从低到高排序
    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods){
            Goods goods = (Goods)o;
//            方式一：
            if(this.price > goods.price) {
                return 1;
            }else if(this.price < goods.price) {
                return -1;
            }else{
                return 0;
            }
        }
        throw new RuntimeException("传入的数据类型不一致");
    }
}

package com.jiayifeng.java4;

import org.junit.Test;

import java.util.Arrays;

/**
 * author 爱编程的小贾
 * create 2023-09-16 10:44
 *
 * 一：说明：Java中的对象，正常情况下，只能进行等于或不等于的比较。不能使用大于或小于的比较
 *    但在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。
 *    如何实现？使用两个接口中的任何一个：Comparable或Comparator
 *
 * 二：Comparable接口的使用
 *
 */
public class CompareTest {
    /*
    Comparable接口的使用举例：自然排序
        1.像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式
        2.像String、包装类重写compareTo()方法以后，进行了从小到大的排列
        3.重写compareTo(obj)的规则：
            如果当前对象this大于形参对象obj,则返回正整数
            如果当前对象this小于形参对象obj,则返回负整数
            如果当前对象this等于形参对象obj,则返回零
        4.对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法
        在compareTo(obj)方法中指明如何排序
     */
    @Test
    public void test1() {
        String[] arr = new String[]{"AA", "CC", "KK", "GG", "JJ", "DD"};

        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//[AA, CC, DD, GG, JJ, KK]
    }

    @Test
    public void test2() {
        Goods[] arr = new Goods[4];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",12);
        arr[2] = new Goods("xiaomiMouse",54);
        arr[3] = new Goods("huaweiMouse",65);
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

9.4.2：定制排序java.util.Comparator

package com.jiayifeng.java4;

import org.junit.Test;

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

/**
 * author 爱编程的小贾
 * create 2023-09-16 13:52
 *
 * 一：Comparator接口的使用：定制排序
 */
public class CompareTest1 {
    /*
    Comparator接口的使用：
        1.背景：
            当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，
            或者实现了java.lang.Comparable接口的顺序规则，但又不适合当前的操作，
            那么可以考虑使用Comparator的对象来排序
        2.重写compara(Object o1,Object o2)方法，比较o1,o2的大小
            如果方法返回正整数，则表示o1大于o2；
            如果返回0，表示相等
            返回负整数，表示o1小于o2
     */
    @Test
    public void test(){
        String[] arr = new String[]{"AA", "CC", "KK", "GG", "JJ", "DD"};
        Arrays.sort(arr, new Comparator<String>() {
//            按照字符串从大到小的顺序排列
            @Override
            public int compare(String o1, String o2) {
                if(o1 instanceof String && o2 instanceof String){
                    String s1 = (String)o1;
                    String s2 = (String)o2;
                    return -s1.compareTo(s2);
                }
                throw new RuntimeException("输入的数据类型不一致");
            }
        });
        System.out.println(Arrays.toString(arr));//[KK, JJ, GG, DD, CC, AA]
    }
}

9.4.3：两种接口的对比：

Comparable接口的方式一旦确定，保证Comparable接口实现类的对象在任何位置都可以比较大小

Comparator接口属于临时性的比较

9.5：System类

位于java.lang包

由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以方便的进行调用

9.6：Math类

java.lang.Math提供了一系列静态方法用于科学计算，其方法的参数和返回值类型一般为double型

Math类
abs	绝对值
sqrt	平方根
pow(double a,double b)	a的b次幂

9.7：BigInteger与BigDecimal

BigInteger：表示不可变的任意精度的整数

构造器：BigInteger（String val）：根据字符串构建BigInteger对象

BigDecimal：支持不可变的、任意精度的有符号的十进制定点数

构造器：

public BigDecimal(double val)

public BigDecimal(String val)