JavaSe:日期API

0606

💔SimpleDateFormat的使用

❤️用法介绍

1.为什么要使用SimpleDateFormat？

​ 在Java中，如果我们想获取当前时间，一般会使用Date类的无参构造函数，如下所示，我们获取到当前时间并输出：

import java.util.Date;
public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        Date currentTime = new Date(); System.out.println(currentTime); 
// 输出：Mon Feb 18 10:24:30 CST 2019
    }
}

此时我们会发现， 输出的格式并不是我们预期的格式，一般情况下，我们希望的格式都是类似于2019-02-18，2019-02-18 10:24:30，2019/02/18这样的，此时我们就需要用到java.text.SimpleDateFormat来自定义格式。

2.使用format()方法将日期转换为字符串

• 使用format()方法，我们可以将日期类型转换为自己自定义的字符串格式，如2019-02-18，2019/02/18，2019-02-18 10:24:30等，自定义格式如下表所示：

格式	释义	举例
yyyy	年	2019
MM	月	02
dd	日	18
HH	小时(24小时制)	13，下午一点
mm	分钟	53
ss	秒	42
SSS	毫秒	629

package com.zwwhnly.springbootdemo;

import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
 
    public static void main(String[] args) {

        Date currentTime = new Date();

        System.out.println(currentTime);    // Mon Feb 18 13:53:50 CST 2019

        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd");

        SimpleDateFormat simpleDateFormat3 = new SimpleDateFormat("yyyy/MM/dd");   System.out.println(simpleDateFormat1.format(currentTime));  // 输出2019-02-18 13:53:50.629

        System.out.println(simpleDateFormat2.format(currentTime));  // 输出2019-02-18

        System.out.println(simpleDateFormat3.format(currentTime));  // 输出2019/02/18
    }
}

3.使用parse()方法将字符串转换为日期

• 在实际开发过程中，我们经常需要将字符串转换为日期类型，以进行后续操作，此时可以使用parse()方法，但需要注意：如果字符串与指定的格式不匹配，会报java.text.ParseException异常

package com.zwwhnly.springbootdemo;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
    public static void main(String[] args) {
    try {
       SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
      String strDate1 = "2019-02-18 13:58";
      String strDate2 = "2019-02-18";
      Date date1 = simpleDateFormat1.parse(strDate1);
      System.out.println(date1);
      Date date2 = simpleDateFormat1.parse(strDate2);
      System.out.println(date2);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

strDate1格式匹配能正常转换为Date类型，而strDate2由于格式不匹配，抛出java.text.ParseException，正是因为如此，以上的代码才必须包括在try,catch语句中，否则IDEA会提示错误，代码也编译不通过。

Mine

package pers.dhx_.java0606;

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

/**
 * @author Dhx_
 * @className DateTimeTest
 * @description TODO java8 之后的日期API测试
 * java.time – 包含值对象的基础包
 * java.time.chrono – 提供对不同的日历系统的访问
 * java.time.format – 格式化和解析时间和日期
 * java.time.temporal – 包括底层框架和扩展特性
 * java.time.zone – 包含时区支持的类
 * @date 2022/6/6 8:02
 */
/*        SimpleDateFoamat 的使用
 一 、 2个操作
        1、格式化： 日期--->字符串
        2、解析:格式化的逆过程，  字符串---》日期
2、 SimpleDateFoamat的实例化

*/
public class DateTimeTest {
    public static void main(String[] args) {
        try {
            Test2();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    static void Test1() {
        SimpleDateFormat sdf = new SimpleDateFormat();
        Date date = new Date();
        //格式化： 日期--->字符串
        String format = sdf.format(date);
        System.out.println(format); //  "2022/6/6 上午8:07"

        //解析： 格式化的逆过程，  字符串---》日期
        String str = "2012/6/6 上午8:57";  //要求格式
        try {
            //可能会抛异常的原因是  sdf.parse()可能无法识别 用户给定的字符串的格式
            System.out.println(sdf.parse(str));
        } catch (ParseException e) {
            e.printStackTrace();
        }

        //**********指定的方式格式化***********
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//初始化规定的格式
        System.out.println(sdf1.format(date));
        //解析
        try {
            System.out.println(sdf1.parse("2042-05-29 20:24:42"));
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    static void Test2() throws ParseException {
        //**********转换成sql下的date***********
        String birth = "2021-08-05";
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");//初始化规定的格式
        Date date = sdf1.parse(birth);
        java.sql.Date birthDate = new java.sql.Date(date.getTime());
        System.out.println(birthDate);
    }
}

Q:三天打鱼，两天晒网

• 1990-01-01

    static void Test3() {
        //计算总天数
        String birth = "1990-01-01";
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");//初始化规定的格式
        Date date = null;
        try {
            date = sdf1.parse(birth);
        } catch (ParseException e) {
            e.printStackTrace();
        }
//        System.out.println(date.getTime());
        String keyIn;
        Scanner in = new Scanner(System.in);
        keyIn = in.nextLine();
        Date date2 = null;
        try {
            date2 = sdf1.parse(keyIn);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        long result = ((date2.getTime() - date.getTime()) / 86400000) % 5;
        System.out.println(result);
        //2022-6-1
        //4
    }

🎈Calendar类

简介

Calendar 类是一个抽象类。

• 获取Calendar实例的方法

  1. 使用Calendar.getInstance()方法
  2. 调用它的子GregorianCalendar的构造器。

在java.util包下，Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。

Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，将语言敏感内容处理好，再返回子类对象。

一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND

• public void set(int field,int value)
• public void add(int field,int amount)
• public final Date getTime()
• public final void setTime(Date date)

package pers.dhx_.java0606;

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

/**
 * @author Dhx_
 * @className CalendarTest
 * @description TODO 日历类的使用 （抽象类）
 * @date 2022/6/6 8:47
 */
public class CalendarTest {
    public static void main(String[] args) {
        //创建其子类(GregorianCalendar)的对象，
        //调用其静态方法 getInstance()
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getClass());//class java.util.GregorianCalendar
        //2 常用方法
        //get()
        System.out.println(calendar.get(calendar.WEEK_OF_YEAR));
//        System.out.println(calendar.get(calendar.WEEK_OF_MONTH));
//        System.out.println(calendar.get(calendar.WEEK_OF_YEAR));
//        System.out.println("今天是2022年的第" + calendar.get(calendar.DAY_OF_YEAR) + "天");
//        System.out.println("今天是2022年的第" + calendar.get(calendar.MONTH) + "个月");

        //set()
        calendar.set(calendar.WEEK_OF_YEAR, 25); //可变对象
        System.out.println(calendar.WEEK_OF_YEAR);
        //add()
        calendar.add(calendar.WEEK_OF_YEAR, 2);
        System.out.println(calendar.WEEK_OF_YEAR);
        calendar.add(calendar.WEEK_OF_YEAR, -2);
        System.out.println(calendar.WEEK_OF_YEAR);

//        getTieme()
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println(calendar.getTime());
        System.out.println(sdf1.format(calendar.getTime()));
        SimpleDateFormat sdf2 = new SimpleDateFormat("YYYY-MM-DD");
        System.out.println(sdf2.format(calendar.getTime()));

//        setTime()
        try {
            Date date = sdf1.parse("2010-04-01");
            calendar.setTime(date);      System.out.println(sdf1.format(calendar.getTime()));
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

🌟注意融会贯通，Date类是这几个API的桥梁

❤️JDK8之后的日期API

1.新日期时间API出现的背景

如果我们可以跟别人说：“我们在1502643933071见面，别晚了！”那么就再简单不过了。但是我们希望时间与昼夜和四季有关，于是事情就变复杂了。JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：
可变性：像日期和时间这样的类应该是不可变的。
偏移性：Date中的年份是从1900开始的，而月份都从0开始。

public static void main(String[] args) {
    Date date1 = new Date(2000 - 1900, 9 - 1, 8);
    System.out.println(date1);//偏移量
    //  Fri Sep 08 00:00:00 CST 2000
} 

格式化：格式化只对Date有用，Calendar则不行。
此外，它们也不是线程安全的；不能处理闰秒等。
总结：对日期和时间的操作一直是Java程序员最痛苦的地方之一。

2.LocalDate、LocalTime、LocalDateTime

LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。

• LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存储 生日、纪念日等日期。

• LocalTime表示一个时间，而不是日期。

• LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。

🌟ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法，也就是公历。

package pers.dhx_.java0606;

import org.junit.jupiter.api.Test;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

/**
 * @author Dhx_
 * @className NewDateTest
 * @description TODO
 * @date 2022/6/6 11:45
 */
public class NewDateTest {
    public static void main(String[] args) {

    }

    @Test //TODO LocalDateTime LocalTime LocalDate
    public void test() {
        //        LocalDateTime用的频率更高
        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 l1 = LocalDateTime.of(2020, 10, 6, 22, 23);
        System.out.println(l1);
        System.out.println(localdatetime.getDayOfMonth()); //获取当前是本月的第几天
        System.out.println(localdatetime.getDayOfWeek()); //获取当前是本周的第几天 (周几)
        System.out.println(localdatetime.getMonthValue()); //获取当前是本月的第几天
        System.out.println(localdatetime.getMonth()); //获取月份
        System.out.println(localdatetime.getMinute()); //获取当前是第几分钟
        //LocalDate 不可变性
        LocalDateTime local1 = localdatetime.withDayOfMonth(22);
        System.out.println(localdate);
        System.out.println(local1);
        LocalDateTime local2 = localdatetime.withHour(18); //修改十九，不改变本身，返回修改后的LocatDateTime对象
        System.out.println(local2);

        LocalDateTime plus1 = localdatetime.plusDays(24);
    }

}

3.instant :瞬时

• Instant：时间线上的一个瞬时点。 这可能被用来记录应用程序中的事件时间戳。
• 在处理时间和日期的时候，我们通常会想到年,月,日,时,分,秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，或者说是连续的。在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机处理。在UNIX中，这个数从1970年开始，以秒为的单位；同样的，在Java中，也是从1970年开始，但以毫秒为单位。
• java.time包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数。因为java.time包是基于纳秒计算的，所以Instant的精度可以达到纳秒级。
• (1 ns = 10^-9 s) 1秒 = 10^-3毫秒 =10⁶微秒=10⁹纳秒

public void test() {
    //获取当前本初子午线 时间
    Instant instant = Instant.now();
    System.out.println(instant); //本初子午线时间  +8--> China
    //添加时间的偏移量   
    System.out.println(instant.atOffset(ZoneOffset.ofHours(8)));
    //获取对应的毫秒数
    System.out.println(instant.toEpochMilli());
    Instant instant1 = Instant.ofEpochMilli(1654501322128l);
    System.out.println(instant1);
}

4…DateTimeFormatter

• 预定义的标准格式。如：

  ISO_LOCAL_DATE_TIME;

  ISO_LOCAL_DATE;

  ISO_LOCAL_TIME

• 本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)

• 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)

public void test() {
        //方式一： 预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
        DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        String format = dtf.format(LocalDateTime.now());
        System.out.println(format);

        TemporalAccessor parse = dtf.parse("2031-06-06T15:57:26.5844559");
        //以接口的方式 定义，是因为不知道 parse() 返回的是LocalDate, LocalTime 还是LocalDateTest
        System.out.println(parse); //{},ISO resolved to 2022-06-06T15:57:26.584455900
        //************************************************************************
        //方式二：本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)

        DateTimeFormatter dtf1 = DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG);
        DateTimeFormatter dtf2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
        DateTimeFormatter dtf3 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
        DateTimeFormatter dtf4 = DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT);
        System.out.println(dtf1.format(LocalDateTime.now()));
        System.out.println(dtf2.format(LocalDateTime.now()));
        System.out.println(dtf3.format(LocalDateTime.now()));
        System.out.println(dtf4.format(LocalDateTime.now()));

        //**************************************************************************
        //自定义的日期格式  如：ofPatterm("yyyy-MM-dd hh:mm:ss E")
        DateTimeFormatter dtf5 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss E"); // E 表示周几
        //格式化
        System.out.println(dtf5.format(LocalDateTime.now()));
        //解析
        TemporalAccessor parse1 = dtf5.parse("2022-06-06 05:43:25 周一");
        System.out.println(parse1);
        //{MicroOfSecond=0, MinuteOfHour=43, NanoOfSecond=0, MilliOfSecond=0, SecondOfMinute=25, HourOfAmPm=5},ISO resolved to 2022-06-06
    }

🗼其它API

• ZoneId**：该类中包含了所有的时区信息，一个时区的ID，如 Europe/Paris
• ZonedDateTime：**一个在ISO-8601日历系统时区的日期时间，如 2007-12-03T10:15:30+01:00 Europe/Paris。 其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式，例如：Asia/Shanghai等 **
• ** **Clock：**使用时区提供对当前即时、日期和时间的访问的时钟。
  1. 持续时间：Duration，用于计算两个“时间”间隔
  2. 日期间隔：Period，用于计算两个“日期”间隔
• TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下一个工作日”等操作。
• TemporalAdjusters : 该类通过静态方法(firstDayOfXxx()/lastDayOfXxx()/nextXxx())提供了大量的常用TemporalAdjuster 的实现。

❤️Java比较器

1.在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间

的比较问题。

2.Java实现对象排序的方式有两种：

自然排序：java.lang.Comparable

定制排序：java.util.Comparator

自然排序：java.lang.Comparable

• 🌟永久性

​ Comparable 的典型实现：(默认都是从小到大排列的)

​ String：按照字符串中字符的Unicode值进行比较

if(str1>str2)
	return 1;
//从小到大

Character：按照字符的Unicode值来进行比较

数值类型对应的包装类以及BigInteger、BigDecimal：按照它们对应的数值大小进行比较

if(num1>num2)
	return 1;
//从小到大

Boolean：true 对应的包装类实例大于 false 对应的包装类实例

Date、Time等：后面的日期时间比前面的日期时间大

**定制排序：**java.util.Comparator

• C++ ,sort 的cmp
• 🌟临时性

当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，

或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那

么可以考虑使用 Comparator 的对象来排序，强行对多个对象进行整体排

序的比较。

package pers.dhx_.java0606;

import org.junit.jupiter.api.Test;

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

/**
 * @author Dhx_
 * @className CompareTest
 * @description TODO  接口  Comparable   Comparator
 * @date 2022/6/6 17:59
 * 一  Comparable
 * 1. 像String,包装类等实现了Comparable接口，给出了两个对象比较大小的条件
 * 2. 重写compareTo()功能
 * 3.重写的规则 ：重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返
 * 回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示
 * o1小于o2。
 * 4.对于自定义类，如果需要排序，那么应当实现compareto()
 */
public class CompareTest {
    public static void main(String[] args) {
        Goods[] arr = new Goods[4];

        arr[0] = new Goods("Dagh", 624);
        arr[1] = new Goods("Agdh", 645);
        arr[2] = new Goods("Bgfdrt", 623);
        arr[3] = new Goods("Jfsd", 624);
        print(arr);
        Arrays.sort(arr, new Comparator<Goods>() {
            @Override
            public int compare(Goods g1, Goods g2) {
                if (g1.getPrice() > g2.getPrice())
                    return 1;
                else if (g1.getPrice() < g2.getPrice()) return -1;
                else
                    return g1.getName().compareTo(g2.getName());
            }
        });
        print(arr);

    }

    @Test
    void Test() {
        Goods[] arr = new Goods[4];
        for (int i = 0; i < 4; i++) {
            arr[i] = new Goods("UU" + i, (new Random()).nextInt() % 200);
        }
        print(arr);
        Arrays.sort(arr);
        print(arr);
    }

    static void print(Goods[] arr) {
        System.out.println("----------------------------");

        for (Goods s : arr)
            System.out.println(s.toString() + "  ");
        System.out.println("----------------------------");
    }

}

class Goods implements Comparable {
    private String name;
    private int price;

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

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

    public String getName() {
        return name;
    }

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

    Goods() {
    }

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

    public int getPrice() {
        return price;
    }

    @Override
    public int compareTo(Object o) { //升序
        if (o instanceof Goods)
            if (this.price > ((Goods) o).price)
                return 1;
            else return -1;
        else return 0;
    }
}

对比：可以使用Comparator 为那些没有自然顺序的对象 collection 提供排序。

❤️System类

System类代表系统

• 系统级的很多属性和控制方法都放置在该类的内部。
• 位于java.lang。
• 构造器是private的，无法创建对象
• 其内部的成员变量和成员方法都是static，方便进行调用。

成员变量

• System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。

成员方法

• native long currentTimeMillis()****： 该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
• void exit(int status)：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。9.5 System类
• void gc()：该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。String getProperty(String key)：该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：

🙉Math类

• java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。
• abs 绝对值
• acos,asin,atan,cos,sin,tan 三角函数
• sqrt 平方根
• pow(double a,doble b) a的b次幂
• log自然对数
• exp e为底指数
• max(double a,double b)
• min(double a,double b)
• random()*返回0.0到1.0的随机数
• long round(double a) double型数据a转换为long型（四舍五入）
• toDegrees(double angrad)弧度—>角度
• toRadians(double angdeg) 角度—>弧度

❤️BigInteger类

• Integer类作为int的包装类，能存储的最大整型值为2 31-1，Long类也是有限的，最大为2 63-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。

java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供

所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。

另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、

位操作以及一些其他操作。

构造器

BigInteger(String val)：根据字符串构建BigInteger对象9.7 BigInteger****类

常用方法

• public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger。

• BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger

• BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger

• BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger

• BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。

• BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger。

• BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组。

• BigInteger pow(int exponent) ：返回其值为 (thisexponent) 的 BigInteger。

💃 BigDecimal类

一般的Float类和Double类可以用来做科学计算或工程计算，但在**商业计算中，**要求数字精度比较高，故用到java.math.BigDecimal类.

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

👯构造器

• public BigDecimal(double val)

• public BigDecimal(String val)

👯常用方法

• public BigDecimal add(BigDecimal augend)
• public BigDecimal subtract(BigDecimal subtrahend)
• public BigDecimal multiply(BigDecimal multiplicand)
• public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)