Java学习基础笔记——Java类

针对前面提到的八种基本数据类型定义相应的引用类型
有了类的特点，就可以调用类中的方法
- 基本数据类型包装类
  boolean Boolean
  char Character
  byte Byte
  short Short
  int Integer
  long Long
  float Float
  double Double
Byte、Short、Integer、Long、Float、Double -> 父类：Number

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

11.1.2 包装类和基本数据的转换

jdk5 前的手动装箱和拆箱方式，装箱：基本类型 -> 包装类型，反之，即为拆箱
jdk5 以后(含jdk5)的自动装箱和拆箱方式
自动装箱底层调用的是valueOf方法，比如Integer.valueOf ( )

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

//包装类() -> String
Integer i = 100;//自动装箱
//方式1
String str1 = i + "";
//方式2
String str2 = i.toString();
//方式3
String str3 = String.valueOf(i);

//String -> 包装类()
String str4 = "100";
Integer i2 = Integer.parseInt(str4);//使用自动装箱
Integer i3 = new Integer(str4);//构造器

11.1.4 包装类的常用方法

Integer类和Character类为例

System.out.println(Integer.MIN_VALUE);//返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值

System.out.println(Character.isDigit('a'));//判断是不是数字
System.out.println(Character.isLetter('a'));//判断是不是字母
System.out.println(Character.isUpperCase('a'));//判断是不是大写
System.out.println(Character.isLowerCase('a'));//判断是不是小写

System.out.println(Character.isWhitespace('a'));//判断是不是空格
System.out.println(Character.toUpperCase('a'));//转成大写
System.out.println(Character.toLowerCase('a'));//转成小写

只要有基本数据类型，判断的是值是否相同

11.2 String类

11.2.1 String类的理解和创建对象

String 对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起的字符序列。例如："你好"、"12.97"、"boy"等
字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占用两个字节
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);
String s5 = new String(byte[] b);

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

接口 Comparable 【String 对象可以比较大小】
String 是 final 类，不能被其他的类继承
String 有属性 private final char value[ ]; 用于存放字符串内容
注意：value 是一个 final 类型，不可修改 -> 具体指 value 的地址不可以修改，但是单个字符的内容是可以变化的

11.2.2 创建String 对象的两种方式

两种创建String 对象的区别

方式一：直接赋值 String s = "Andy";
方式二：调用构造器 String s = new String("Andy");
- 方式一：先从常量池查看是否有"Andy"数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址
- 方式二：先在堆中创建空间，里面维护了value属性，指向常量池的Andy空间。如果常量池没有"Andy"，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址

String a = "Andy";//a 指向 常量池的 "Andy"
String b = new String("Andy");//b 指向 堆中对象
System.out.println(a.equals(b));//T
System.out.println(a == b);//F
System.out.println(a == b.intern());//T
System.out.println(b == b.intern());//F

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

b.intern() 方法最终返回的是什么？

11.2.3 字符串的特性

String a = "hello";//创建 a对象
String b = "world";//创建 b对象
//1.先 创建一个 StringBuilder sb = StringBuilder()
//2.执行 sb.append("hello");
//3.执行 sb.append("world");
//4.执行 String c = sb.toString
//5.最后其实是 c 指向堆中的对象(String) value[] -> 池中 "helloworld"
String c = a + b;
String d = "helloworld";
System.out.println(c == d);//F
System.out.println(c.equals(d));//T

小结：底层是 StringBuilder sb = StringBuilder()；sb.append(a);sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的。
重要规则：
String c = "ab" + "cd";常量相加，看的是池。
String c = a + b;变量相加，是在堆中

public class StringExercise {
   public static void main(String[] args) {
 
       Test ex = new Test();
       ex.change(ex.str, ex.ch);
       System.out.print(ex.str + "and");
       System.out.println(ex.ch);
   }
}

class Test {
    String str = new String("hello");
    final char ch[] = {'j', 'a', 'v', 'a'};

    public void change(String str, char ch[]) {
        str = "java";
        ch[0] = 'h';
    }
}

11.2.4 String 类的常见方法

equals // 区分大小写，判断内容是否相等
equalsIgnoreCase // 忽略大小写的判断内容是否相等
length // 获取字符的个数，字符串的长度
indexOf // 获取字符在字符串中第1次出现的索引，索引从0开始，如果找不到，返回-1
lastIndexOf // 获取字符在字符串中最后1次出现的索引，索引从0开始，如果找不到，返回-1
substring // 截取指定范围的子串，左闭右开 [ )
trim // 去前后空格
charAt // 获取某索引处的字符，注意不能使用Str[index]这种方式
toUpperCase // 转换成大写
toLowerCase // 转换成小写
concat // 拼接字符串
replace // 替换字符串中的字符
split // 分割字符串，对于某些分割字符，我们需要转义比如 | \\等
compareTo // 比较两个字符串的大小
toCharArray // 转换成字符数组
format // 格式字符串，%s 字符串 %c 字符 %d 整型 %.2f 浮点型 -> %s %d %.2f %c 称为占位符，这些占位符由后面变量来替换 %.2f 表示保留两位小数，并且会进行四舍五入的处理

11.3 StringBuffer 和 StringBuilder 类

11.3.1 StringBuffer类

11.3.1.1 基本介绍

java.lang.StringBuffer 代表可变的字符序列，可以对字符串内容进行增删
很多方法与String相同，但StringBuffer是可变长度的
StringBuffer是一个容器

11.3.1.2 String vs StringBuffer

String 保存的是字符串常量，里面的值不能更改，每次String 类的更新实际上就是更改地址，效率较低 //private final char value[];
StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高 //char[] value

11.3.1.3 StringBuffer的构造器

//构造器的使用
//1. 创建一个 大小 为 16  的  char[] ,用于存放字符内容
StringBuffer stringBuffer = new StringBuffer();

//2. 通过构造器指定 char[]  大小
StringBuffer stringBuffer1 = new StringBuffer(100);

//3. 通过 给一个String 创建  StringBuffer, char[] 大小就是 str.length() + 16
StringBuffer andy = new StringBuffer("Andy");

11.3.1.4 String和StringBuffer相互转换

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

//方式二：使用的是 append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);

//StringBuffer -> String
StringBuffer stringBuffer3 = new StringBuffer("java");
//方式一： 使用StringBuffer提供的 toString方法
String s = stringBuffer3.toString();

//方式二: 使用构造器来搞定
String s1 = new String(stringBuffer3);

11.3.1.5 StringBuffer类常见方法

增 append
删 delete(start,end)
改 replace(start,end,string) //将start -> end 间的内容替换掉，不包含end
查 indexOf //查找子串在字符串第一次出现的索引，如果找不到返回 -1
插 insert
获取长度 length

StringBuffer s = new StringBuffer("Andy");
//append
s.append(',');
s.append("张三丰");
s.append("赵敏").append(100).append(true).append(37.5);
System.out.println(s);

//delete(start,end) -> 删除索引 >= start && <end 处的字符 -> 左闭右开区间
s.delete(11, 14);
System.out.println(s);

//replace(start,end,string) 将start -> end 间的内容替换掉，不含end
s.replace(10, 11, "张无忌");
System.out.println(s);

//indexOf 查找子串在字符串第一次出现的索引，如果找不到返回 -1
System.out.println(s.indexOf("张三丰"));

//insert 插入,在索引为 9 的位置 插入"赵敏"，原来索引 内容自动后移
s.insert(9, "赵敏");
System.out.println(s);

//length 长度
System.out.println(s.length());//22
System.out.println(s);

11.3.2 StringBuilder类

11.3.2.1 基本介绍

一个可变的字符序列。此类提供一个与StringBuffer 兼容的 API，但不保证同步（StringBuffer 是线程安全的）。该类被设计用作 StringBuffer 的一个简易转换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快
在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据

11.3.2.2 StringBuilder类常用方法

StringBuilder 和 StringBuffer 均代表可变的字符序列，方法是一样的，所以使用和StringBuffer一样

11.3.2.3 String、StringBuffer 和 StringBuilder 的比较

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样
String：不可变字符序列，效率低，但是复用率高
StringBuffer：可变字符序列，效率较高（增删）、线程安全
StringBuilder：可变字符序列、效率最高、线程不安全

使用的原则，结论：

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

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

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

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

11.4 Math类

11.4.1 基本介绍

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

11.4.2 Math 类常见方法

abs 绝对值
pow 求幂
ceil 向上取整
floor 向下取整
round 四舍五入
sqrt 求开方
random 求随机数
max 求两个数的最大值
min 求两个数的最小值

//abs 绝对值
int abs = Math.abs(-9);
System.out.println(abs);//9

//pow 求幂
double pow = Math.pow(2, 4);
System.out.println(pow);

//ceil 向上取整
double ceil = Math.ceil(3.7);
System.out.println(ceil);

//floor 向下取整
double floor = Math.floor(-3.75);
System.out.println(floor);

//round 四舍五入
long round = Math.round(3.25);
System.out.println(round);

//sqrt 求开方
double sqrt = Math.sqrt(1.44);
System.out.println(sqrt);

//random 求随机数
//random 返回的是 0 <= x < 1 之间的一个随机小数

//Math.random() * (b - a + 1)  返回的就是 0 <= 数 <= b - a
//1. (int)(a) <= x <= (int)(a + Math.random() * (b - a + 1))
//2. (int)(a + Math.random() * (b - a + 1)) = (int)(2 + Math.random()*6)
//3. Math.random()*6 返回的是 0 <= x < 6 小数
//4. 2 + Math.random()*6 返回的是  2 <= x < 8 小数
//5. (int)(2 + Math.random()*6) -> 2 <= x <= 7
//6. 公式：(int)(a + Math.random() * (b - a + 1))
for (int i = 0; i < 100; i++) {
    System.out.println((int) (2 + Math.random() * 6));
}

//max, min 两个数的最小值和最大值
int max = Math.max(1, 9);
int min = Math.min(45, 37);
System.out.println("min=" + min);
System.out.println("max=" + max);

获取一个 a-b 之间的一个随机整数 -> int num = (int) (a + Math.random() * (b - a + 1))

11.5 Date日期类、Calendar日历类以及新的日期

11.5.1 Date介绍

第一代日期类

Date：精确到毫秒，代表特定的瞬间
SimpleDateFormat：格式和解析日期的类
SimpleDateFormat 格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化

//1. 获取当前系统时间
//2. 这里的Date 类是在java.util 包
//3. 默认输出的日期格式是国外的方式，因此通常需要对格式进行转换
Date date = new Date();//获取当前系统时间
System.out.println("当前日期=" + date);
Date date1 = new Date(65468781);//通过指定毫秒数得到时间
System.out.println("当前日期=" + date1);//获取某个时间对应的毫秒数

//1. 创建 SimpleDateFormat 对象，可以指定相应的格式
//2. 这里的格式使用的字母是规定好的，不能乱写
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
String format = sdf.format(date); // format: 将日期转换成指定格式的字符串
System.out.println("当前日期=" + format);


//1. 可以把一个格式化的String 转成对应的 Date
//2. 得到 Date 仍然在输出时，还是按照国外的形式，如果希望指定格式输出，需要SimpleDateFormat 转换
//3. 在把 String -> Date ，使用的 sdf 格式需要和你给的 String 的格式一样，否则会抛出 转换异常
String s = "1996年01月01日 10:20:30 星期一";
Date parse = sdf.parse(s);
System.out.println("parse=" + sdf.format(parse));

11.5.2 Calendar类

第二代日期类

第二代日期类，主要就是 Calendar类（日历）

public abstract class Calendar extends Object implements Serializable,Cloneable,Comparable < Calendar >
Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法

/**
 * 1. Calendar 是一个抽象类，并且构造器是private
 * 2. 可以通过 getInstance() 来获取实例
 * 3. 提供大量的方法和字段提供给开发人员
 * 4. Calendar 没有提供对应的格式化的类，因此需要开发人员自己组合来输出显示
 * 5. 如果我们需要按照 24小时制来获取时间， Calendar.HOUR == 改成 -> Calendar.HOUR_OF_DAY
 */
//1.创建日历类对象//比较简单，自由
Calendar c = Calendar.getInstance();
System.out.println(c);

//2.获取日历对象的某个日历字段
System.out.println("年：" + c.get(Calendar.YEAR));
// 这里为什么要 + 1，因为Calendar 返回 月 的时候，是按照 从 0 开始编号的
System.out.println("月：" + (c.get(Calendar.MONTH) + 1));
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));

//Calendar 没有专门的格式化方法，所以需要开发人员自己来组合显示
System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" + c.get(Calendar.DAY_OF_MONTH) +
                  "\t" + c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND));

11.5.3 新的日期

第三代日期类

前面两代日期类的不足分析：JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar也存在问题是：

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

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

<3>格式化：格式化支队Date有用，Calendar则不行

<4>此外，它们也不是线程安全的；不能处理闰秒等（每隔两天，多出一秒）

11.5.3.1 第三代日期类常见方法

LocalDate(日期/年月日)、LocalTime(时间/时分秒)、LocalDateTime(日期时间/年月日时分秒)

//第三代日期
/**
 * 1. 使用now() 返回表示当前日期时间的 对象
 */
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);
ldt.getYear();
ldt.getMonthValue();
ldt.getMonth();
ldt.getDayOfMonth();
ldt.getHour();
ldt.getMinute();
ldt.getSecond();
System.out.println(ldt.getYear() + "-" + ldt.getMonthValue() + "-" + ldt.getDayOfMonth() +
                   "\t" + ldt.getHour() + ":" + ldt.getMinute() + ":" + ldt.getSecond())

DateTimeFormatter格式日期类 -> 类似于SimpleDateFormat

//2. 使用DateTimeFormatter 对象
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss E");
String format = dtf.format(ldt);
System.out.println(format);

Instant 时间戳

//1. 通过 静态方法 now() 获取表示当前时间戳的对象
Instant now = Instant.now();
System.out.println(now);
//2. 通过 from() 可以把 Instant 转成 Date
Date date = Date.from(now);
//3. 通过 date的toInstant() 可以把 date 转成Instant对象
Instant instant = date.toInstant();

第三代日期类更多方法
- LocalDateTime类
- MonthDay类：检查重复事件
- 是否是闰年
- 增加日期的某个部分
- 使用plus方法测试增加时间的某个部分
- 使用minus方法测试查看一年前和一年后的日期
- 其他的方法，不再多说，使用的时候，自己查看API使用即可

11.6 System类

11.6.1 System 类常见方法

exit：退出当前程序
arraycopy：复制数组元素，比较适合底层调用，一般使用 Array.copyOf完成复制数组 int src[] = {1,2,3}; int dest[] = new int[3]; System.arraycopy(src,0,dest,0,3);
currentTimeMillens：返回当前时间距离 1970-1-1 的毫秒数
gc：运行垃圾回收机制 System.gc();

11.7 Arrays类

11.7.1 Arrays类常见方法

Arrays里面包含了一系列静态方法，用于管理或操作数组（比如排序和搜索）

        //toString 返回数组的字符串形式   ->   Arrays.toString(arr)
        Integer integers[] = {1, 20, 90};
        //遍历数组
        for (int i = 0; i <integers.length ; i++) {
            System.out.println(integers[i]);
        }
        //直接使用Arrays.toString方法，
        System.out.println(Arrays.toString(integers));

        //sort 排序（自然排序和定制排序） Integer arr[] = {1, -1, 7, 0, 37, 5};
        Integer arr[] = {1, -1, 7, 0, 37, 5};
        //进行排序

        //1.可以直接使用冒泡排序，也可以直接使用Arrays提供的sort方法排序
        //2.因为数组是引用类型，所以通过sort排序后，会直接影响到 实参 arr
        //3.sort重载的，也可以通过传入一个接口 Comparator 实现定制排序
        //4.调用sort 定制排序 方法时，传入两个参数
        // （1）排序的数组 arr
        // （2）实现了 Comparator 接口的 匿名内部类，要求 实现compare方法

        Arrays.sort(arr);//默认排序方法

        //定制排序
        Arrays.sort(arr, new Comparator() {//匿名内部类
            @Override
            public int compare(Object integer, Object t1) {
                Integer i1 = (Integer) integer;
                Integer i2 = (Integer) t1;
                return i2 - i1;
            }
        });
        System.out.println("排序后的数组");
        System.out.println(Arrays.toString(arr));


        int arr[] = {1, -1, 8, 0, 37, 5};
        bubble01(arr);
        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o, Object t1) {
                Integer i1 = (Integer) o;
                Integer i2 = (Integer) t1;
                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;
                }
            }
        }
    }

binarySearch 通过二分搜索法进行查找，要求必须排好序 int index = Arrays.binarySearch(arr,3);
copyOf 数组元素的复制 Integer newArr[] = Arrays.copyOf(arr,arr.length);
fill 数组元素的填充 Integer num[] = new Integer[]{9, 3, 2}; Arrays.fill(num,99);
equals 比较两个数组元素内容是否完全一致 boolean equals = Arrays.equals(arr,arr2);
asList 将一组值，转换成list List<Integer> asList = Arrays.asList(2,3,4,5,6,1); System.out.println("asList=" + asList);

public class ArrayExercise {
    public static void main(String[] args) {

        Book[] books = new Book[4];
        books[0] = new Book("红楼梦", 100);
        books[1] = new Book("笑傲江湖", 90);
        books[2] = new Book("青年文摘20年", 5);
        books[3] = new Book("java从入门到放弃", 300);

        //1.按照价格从大到小排序
//        Arrays.sort(books, new Comparator() {
//            //这里是对Book数组排序，因此 o1 和 o2 就是 Book 对象
//            @Override
//            public int compare(Object o1, Object o2) {
//                Book book1 = (Book) o1;
//                Book book2 = (Book) o2;
//                double priceVal = book2.getPrice() - book1.getPrice();  
//                if (priceVal > 0) {
//                    return 1;
//                } else if (priceVal < 0) {
//                    return -1;
//                } else {
//                    return 0;
//                }
//            }
//        });
//        System.out.println(Arrays.toString(books));

        //2.按照价格从小到大排序
//        Arrays.sort(books, new Comparator() {
//            //这里是对Book数组排序，因此 o1 和 o2 就是 Book 对象
//            @Override
//            public int compare(Object o1, Object o2) {
//                Book book1 = (Book) o1;
//                Book book2 = (Book) o2;
//                double priceVal = book2.getPrice() - book1.getPrice();
//                if (priceVal > 0) {
//                    return -1;
//                } else if (priceVal < 0) {
//                    return 1;
//                } else {
//                    return 0;
//                }
//            }
//        });
//        System.out.println(Arrays.toString(books));

        //3.按照书名长度从大到小排序
        Arrays.sort(books, new Comparator() {
            //这里是对Book数组排序，因此 o1 和 o2 就是 Book 对象
            @Override
            public int compare(Object o1, Object o2) {
                Book book1 = (Book) o1;
                Book book2 = (Book) o2;
                //要求按照书名的长度来进行排序
                return book2.getName().length() - book1.getName().length();
            }
        });
        System.out.println(Arrays.toString(books));
    }
}



class Book {
    private String name;
    private double price;

    public Book(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 "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

11.8 BigInteger类和BigDecimal类

11.8.1 BigInteger和BigDecimal介绍

应用场景

BigInteger 适合保存比较大的整型
BigDecimal 适合保存精度更高的浮点型

11.8.2 BigInteger和BigDecimal常见方法

add 加
subtract 减
multiply 乘
divide 除

        //当我们编程中，需要处理很大的整数，long 不够用
        //可以使用 BigInteger 的类来搞定

        BigInteger bigInteger = new BigInteger("345677541245555555555555555");
        BigInteger bigInteger1 = new BigInteger("100");
        System.out.println(bigInteger);

        /**
         * 在对 BigInteger 进行加减乘除时，需要使用对应的方法，不能直接 + - * /
         *
         */
        BigInteger add = bigInteger.add(bigInteger1);
        System.out.println(add);//加
        BigInteger subtract = bigInteger.subtract(bigInteger1);
        System.out.println(subtract);//减
        BigInteger multiply = bigInteger.multiply(bigInteger1);
        System.out.println(multiply);//乘
        BigInteger divide = bigInteger.divide(bigInteger1);
        System.out.println(divide);//除