【Day04-常用API、日期时间、Arrays】

完球了

于 2024-09-01 20:05:27 发布

阅读量915

点赞数 31

文章标签： java rpc 开发语言学习经验分享笔记

本文链接：https://blog.csdn.net/Doshaxin/article/details/141753373

版权

1. 常见API

1.1 StringBuilder

/*
StringBuilder类
    代表可变的字符串对象，理解为一个操作字符串的容器
    相对于String来说, 本来的操作效率更高

StringBuilder常用方法
    public StringBuilder(): 构建一个空的可变字符串对象
    public StringBuilder(String str): 构建一个指定内容的可变字符串对象

    public StringBuilder append(任意对象): 拼接数据并返回本身
    public void reverse(): 翻转内容
    public int length(): 返回长度
    public String toString(): 将StringBuilder转为String对象并返回

StringBuffer
    跟StringBuilder类功能一样,但是线程安全, 性能较低
*/
public class Demo1 {
    public static void main(String[] args) {
        //1. 创建StringBuilder
        StringBuilder sb = new StringBuilder();
        //2. 字符拼接
        sb.append(1);
        sb.append(true);
        sb.append("老张");
        System.out.println(sb);
        //3. 反转内容
        sb.reverse();
        System.out.println(sb);
        //4. 返回长度
        System.out.println(sb.length());
        //5. 转为字符串
        String str = sb.toString();
        System.out.println(str);
    }

}

/*
    设计一个方法，用于返回任意整型数组的内容，要求返回的数组内容格式如：[11,22,33]
*/
public class Demo2 {

    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33};
        System.out.println(printS(arr));
        System.out.println(printSb(arr));
    }

    //需求1: 使用String搞
    public static String printS(int[] arr) {
        long start = System.currentTimeMillis();
        String str = "[";
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                str += arr[i] + "]";
            } else {
                str += arr[i] + ",";
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("String方法拼接使用时间: " + (end - start) + "毫秒");
        return str;
    }

    //需求2: 使用StringBuilder搞
    public static String printSb(int[] arr) {
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]).append("]");
            } else {
                sb.append(arr[i]).append(",");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder方法拼接使用时间: " + (end - start) + "毫秒");
        return sb.toString();
    }

1.2 StringJoiner

/*
StringJoiner类
    JDK8提供的一个类，和StringBuilder用法类似,但是代码更简洁

常用方法
    public StringJoiner("间隔符号")  构建一个可变字符串对象，指定拼接时的间隔符号
    public StringJoiner("间隔符号","开始符号","结束符号") 构建一个可变字符串对象，指定拼接时的间隔符号，开始符号和结束符号

    public StringJoiner add(String str)   按照格式拼接数据并返回本身
    public int length()  返回长度
    public String toString()  将StringJoiner转为String对象并返回

案例
    设计一个方法，按照格式要求，返回任意类型数组内容
*/
public class Demo4 {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33};
        System.out.println(join(arr));
    }

    //需求: 设计一个方法，按照格式要求，返回任意类型数组内容
    public static String join(int[] arr) {
        //1.创建一个StringJoiner，并指定分隔符，前缀，后缀
        StringJoiner sj = new StringJoiner(",", "[", "]");
        //2.循环遍历
        for (int a : arr) {
//            sj.add(a + "");
            sj.add(String.valueOf(a));//这两种都可以
        }
        return sj.toString();//[11,22,33]
    }
}

好处：

JDK8出现的一个可变的、操作字符串的容器。

使用它拼接字符串的时候，不仅高效，而且代码的编写更加的方便。

1.3 Math

/*
Math类
    一个专门用于数学运算的工具类
Math类常用方法
    int abs(int a) 返回参数的绝对值
    double ceil(double a) 向上取整(不是四舍五入)
    double floor(double a) 向下取整(不是四舍五入)
    long round(double a) 四舍五入
    int max(int a,int b) 返回两个参数中的较大值
    int min(int a,int b) 返回两个参数中的较小值
    double pow(double a,double b) 返回a的b次幂
    double random() 返回[0.0,1.0)之间的随机正数
*/
public class Demo1 {
    public static void main(String[] args) {
        int a = -3;
        int b = 2;
        double c = 3.1415;
        System.out.println(Math.abs(a));//3
        System.out.println(Math.ceil(c));//4.0
        System.out.println(Math.floor(c));//3.0
        System.out.println(Math.round(c));//3
        System.out.println(Math.max(a, b));//2
        System.out.println(Math.min(a, b));//-3
        System.out.println(Math.pow(b, 3));//8.0
        System.out.println(Math.random());//返回[0.0, 1.0)之间的随机数  0.4254312468493433
    }
}

1.4 System

/*
System
    代表程序所在系统的一个工具类

System类常用方法
    void exit(int status) 终止虚拟机，非0参数表示异常停止
    long currentTimeMillis() 返回当前系统时间的毫秒值 (从1970年1月1日  00:00:00走到此刻的总的毫秒数(1s = 1000ms)。
*/
public class Demo2 {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());//1725090671006
        System.exit(0);//终止虚拟机，非0参数表示异常停止
    }
}

1.4 BigDecimal

构造器	说明
public BigDecimal(double val) 注意：不推荐使用这个,无法总精确运算	将 double转换为BigDecimal
public BigDecimal(String val)	把String转成BigDecima

方法名	说明
public static BigDecimal valueOf(double val)	转换一个 double成 BigDecimal
public BigDecimal add(BigDecimal b)	加法
public BigDecimal subtract(BigDecimal b)	减法
public BigDecimal multiply(BigDecimal b)	乘法
public BigDecimal divide(BigDecimal b)	除法
public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式)	除法、可以控制精确到小数几位
public double doubleValue()	将BigDecimal转换为double

/*
BigDecimal
    用于解决浮点型运算时，出现结果失真的问题

BigDecimal常用方法
    BigDecimal(double val)      将double转换为BigDecimal (注意：不推荐使用这个)
    BigDecimal(String val)  	把String转成BigDecimal
    static BigDecimal valueOf(数值型数据)

    BigDecimal add(另一BigDecimal对象)  加法
    BigDecimal subtract(另一个BigDecimal对象)  减法
    BigDecimal multiply(另一BigDecimal对象)   乘法
    BigDecimal divide(另一BigDecimal对象)   除法(除不尽报错)
    double doubleValue()	将BigDecimal转换为double

    BigDecimal divide (另一个BigDecimal对象,精确几位,舍入模式)  除法、可以控制精确到小数几位
        舍入模式
           RoundingMode.UP         进一
           RoundingMode.FLOOR      去尾
           RoundingMode.HALF_UP    四舍五入
*/
public class Demo3 {
    public static void main(String[] args) {
        //0. 浮点型运算时, 直接+ - * / 可能会出现运算结果失真
        System.out.println(0.1 + 0.2);//0.30000000000000004
        System.out.println(1.0 - 0.32);//0.6799999999999999
        System.out.println(1.015 * 100);//101.49999999999999
        System.out.println(1.301 / 100);//0.013009999999999999
        System.out.println("=============================");
        //1. 创建BigDecimal 对象
        BigDecimal bigDecimal1 = new BigDecimal("10");
        BigDecimal bigDecimal2 = BigDecimal.valueOf(7);
        //2. 加减乘除
        //加
        BigDecimal add = bigDecimal1.add(bigDecimal2);
        System.out.println(add);
        //减
        BigDecimal subtract = bigDecimal1.subtract(bigDecimal2);
        System.out.println(subtract);
        //乘
        BigDecimal multiply = bigDecimal1.multiply(bigDecimal2);
        System.out.println(multiply);
        //除：默认只支持整除，否则会报错
//        BigDecimal divide = bigDecimal1.divide(bigDecimal2);//ArithmeticException
//        System.out.println(divide);

        //public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式)
        //舍入模式：RoundingMode.UP 向上取整，进一
        //        RoundingMode.HALF_UP 四舍五入
        //        RoundingMode.DOWN 向下取整
        BigDecimal divide = bigDecimal1.divide(bigDecimal2, 2, RoundingMode.UP);
        System.out.println(divide);

        //将BigDecimald对象转换为double数据类型
        double value = divide.doubleValue();
        System.out.println(value);
    }
}

2. 日期时间

2.1 JDK8之前的日期、时间

2.1.1 Date

/*
Date
    代表的是日期和时间，目前使用java.util包下的Date

Date常用方法
    Date()  封装当前系统的时间日期对象
    Date(long time)  封装指定毫秒值的时间日期对象

    long getTime()  返回从时间原点到此刻经过的毫秒值
    void setTime(long time)  设置时间日期对象的毫秒值
*/
public class Demo1 {
    public static void main(String[] args) {
        Date date = new Date();//当前时间
        System.out.println(date);//Fri Aug 30 11:22:02 CST 2024

        //获得当前时间的毫秒数
        long time = date.getTime();
        System.out.println(time);//1724988200216

        //创建一个Date对象，设置时间是当前时间的1小时之前
        Date beforeDate = new Date(time - 3600 * 1000);
        System.out.println(beforeDate);//Fri Aug 30 10:26:08 CST 2024

        //重新设置date对象的毫秒值
        beforeDate.setTime(time + 3600 * 1000);
        System.out.println(beforeDate);//Fri Aug 30 12:27:27 CST 2024
    }
}

2.1.2 SimpleDateFormat

SimpleDateFormat：代表简单日期格式化，可以用来把日期对象、时间毫秒值格式化成我们想要的形式。

SimpleDateFormat解析字符串时间成为日期对象

解析方法	说明
public Date parse(String source)	把字符串时间解析成日期对象

/*
SimpleDateFormat美
    日期时间格式化类，可以对Date对象进行格式化和解析操作

SimpleDateFormat常用方法
    public SimpleDateFormat() 空参构造，代表默认格式   2023/9/30 上午2:38
    public SimpleDateFormat("指定格式") 带参构造，指定日期时间格式

    public final String format(Date date/long time) 格式化
    public Date parse(String source)

格式代表符号
      y	年
      M	月
      d	日
      H	时
      m	分
      s	秒
      EEE  星期几
      a    上午/下午
*/
public class Demo2 {
    public static void main(String[] args) throws ParseException {
        //1.将Date日期对象，转换成标准的日期字符串
        Date date = new Date();
        //2.创建SimpleDateFormat对象，指定日期格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//2024-08-30 12:04:16
//        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");//2024年08月30日 11时54分04秒
        //3.调用format方法，日期格式化处理
        String format = simpleDateFormat.format(date);
        System.out.println(format);
        //4. 将字符串，转换为Date日期对象
        //创建SimpleDateFormat对象，指定日期格式（省略）
        //上边创建了
        //调用parse方法将字符串，转化成日期
//        Date parse = simpleDateFormat1.parse("2024年08月30日 11时54分04秒");//ParseException报错，需要跟上边创建的格式"yyyy-MM-dd HH:mm:ss"一样
        Date parse = simpleDateFormat.parse("2024-08-30 12:02:51");
        System.out.println(parse);//Fri Aug 30 12:02:51 CST 2024
    }
}

2.1.2 Calendar

/*
Calender类
    代表的是系统此刻时间对应的日历，通过它可以单独获取、修改时间中的年、月、日、时、分、秒等。

常见方法
    static Calendar getInstance()	获取当前日历对象

    int get(int field) 获职日历中指定信息
    final Date getTime() 获取日期对象
    Long getTimeInMillis() 获取时间毫秒值

    void set(int field,int value) 修改个信息
    void add(int field,int amount) 为某个信息增加/减少指定的值
 */
public class Demo3 {
    public static void main(String[] args) {
        //1. 创建日历对象   static Calendar getInstance()
        Calendar calendar = Calendar.getInstance();
        //2. 获取: 年 月 日  时 分 秒   int get(int field) 获职日历中指定信息
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);//MONTH默认是从0开始的
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(year + "/" + (month + 1) + "/" + day);
        //3. 获取日期对象 final Date getTime()
        Date date = calendar.getTime();
        System.out.println(date);
        //4. 获取时间毫秒值 Long getTimeInMillis()
        long timeInMillis = calendar.getTimeInMillis();
        System.out.println(timeInMillis);
        //5. 修改日期中的某个项 void set(int field,int value)
        calendar.set(Calendar.YEAR, 2099);
        calendar.set(Calendar.DAY_OF_MONTH, 30);
        calendar.set(Calendar.MONTH, 1);
        //6. 为某个信息增加/减少指定的值 void add(int field,int amount)
        calendar.add(Calendar.YEAR, 10);
        Date time = calendar.getTime();
        System.out.println(time);
    }
}

2.2 JDK8之后的日期、时间

2.2.1 LocalDate、LocalTime、LocalDateTime

/*
三个类
    LocalDate：代表本地日期(年、月、日、星期)
    LocalTime：代表本地时间(时、分、秒、纳秒)
    LocalDateTime：代表本地日期、时间(年、月、日、星期、时、分、秒、纳秒)

创建方式
    Xxx.now() 获取时间信息
    Xxx.of(2025, 11, 16, 14, 30, 01)  设置时间信息

LocalDateTime转换为LocalDate和LocalTime
    public LocalDate toLocalDate()	转换成一个LocalDate对象
    public LocalTime toLocalTime()	转换成一个LocalTime对象

以LocalDate为例子演示常用方法
    获取细节: getYear、getMonthValue、getDayOfMonth、getDayOfYear、getDayOfWeek
    直接修改某个信息，返回新日期对象： withYear、withMonth、withDayOfMonth、withDayOfYear
    把某个信息加多少，返回新日期对象： plusYears、plusMonths、plusDays、plusWeeks
    把某个信息减多少，返回新日期对象： minusYears、minusMonths、minusDays，minusWeeks
    判断两个日期对象，是否相等，在前还是在后：equals isBefore isAfter
*/
public class Demo1 {
    public static void main(String[] args) {
        //1. 两种方式创建LocalDateTime
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);//2024-08-30T15:56:05.039733400
        LocalDateTime time = LocalDateTime.of(2002,2,2,22,22,22);
        System.out.println(time);//2002-02-02T22:22:22
        //2. 使用LocalDateTime获取LocalDate和LocalTime
        LocalDate localDate = now.toLocalDate();
        LocalTime localTime = now.toLocalTime();
        System.out.println(localDate);//2024-08-30
        System.out.println(localTime);//15:56:05.039733400
        //3. 获取细节: getYear、getMonthValue、getDayOfMonth、getDayOfYear、getDayOfWeek
        int year = now.getYear();
        Month month = now.getMonth();
        int day = now.getDayOfMonth();
        System.out.println(year + "-" + month.getValue() + "-" + day);//2024-8-30
        //4. 直接修改某个信息，返回新日期对象： withYear、withMonth、withDayOfMonth、withDayOfYear
        LocalDateTime DateTime = now.withMonth(7).withYear(2025);
        System.out.println(now);//2024-08-30T15:56:05.039733400
        System.out.println(DateTime);//2025-07-30T15:56:05.039733400
        //5. 把某个信息加多少，返回新日期对象： plusYears、plusMonths、plusDays、plusWeeks
        LocalDateTime dateTime1 = now.plusYears(1).plusMonths(1).plusDays(1);
        System.out.println("dateTime1=" + dateTime1);//dateTime1=2025-10-01T15:56:05.039733400
        //6. 把某个信息减多少，返回新日期对象： minusYears、minusMonths、minusDays，minusWeeks
        LocalDateTime dateTime2 = now.minusYears(1).minusMonths(1).minusDays(1);
        System.out.println("dateTime2=" + dateTime2);//dateTime2=2023-07-29T15:56:05.039733400
        //7. 判断两个日期对象，是否相等，在前还是在后：equals isBefore isAfter
        boolean result = dateTime1.equals(dateTime2);
        System.out.println(result);//false

        boolean before = dateTime1.isBefore(dateTime2);
        System.out.println(before);//false

        boolean after = dateTime1.isAfter(dateTime2);
        System.out.println(after);//true
    }
}

2.2.2 ZoneId、ZoneDateTime

/*
时区和带时区的时间
    时区(ZoneId)
        public static Set<String> getAvailableZoneIds()	获取Java中支持的所有时区
        public static ZoneId systemDefault()	获取系统默认时区
        public static ZoneId of(String zoneId)	获取一个指定时区
    带时区的时间(ZonedDateTime)
        public static ZonedDateTime now()	获取当前时区的ZonedDateTime对象
        public static ZonedDateTime now(ZoneId zone) 	获取指定时区的ZonedDateTime对象
*/
public class Demo2 {
    public static void main(String[] args) {
        //时区（ZoneId）
        //获取Java中支持的所有时区
        Set<String> zoneIds = ZoneId.getAvailableZoneIds();
        System.out.println(zoneIds);
        //获取系统默认时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId);//Asia/Shanghai
        ZoneId zoneId1 = ZoneId.of("Asia/Tokyo");
        System.out.println(zoneId1);//Asia/Tokyo
        //带时区的时间
        ZonedDateTime now = ZonedDateTime.now(zoneId1);//不带参数，默认打印自己机器的时间
        System.out.println(now);
    }
}

2.2.3 DateTimeFormatter


/*
DateTimeFormatter:定义格式化时间的格式
    public static DateTimeFormatter ofPattern(时间格式) 	获取格式化器对象

LocalDateTime的方法
    public String format(DateTimeFormatter formatter)	时间转字符串
    public static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) 	字符串转时间
*/
public class Demo3 {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = now.format(pattern);
        System.out.println(format);
        LocalDateTime parse = LocalDateTime.parse("2002-02-02 22:22:22", pattern);
        System.out.println(parse);
    }
}

3. Arrays

3.1 Arrays类提供的常见方法

/*
Arrays
    数组工具类

Arrays常用方法
    public static String toString(类型[] arr)  返回数组内容的字符串表示形式
    public static int[] copyOfRange(类[]arr，起始索引，结束索引) 拷贝数组，元素为索引的指定范围，左包含右不包含
    public static copyOf(类型[] arr，int newLength)  拷贝数组，指定新数组的长度
    public static void setAll(double[] array, IntToDoubleFunction generator)  将数组中的数据改为新数据，重新存入数
    public static void sort(类型[ arr); 对数组元素进行升序排列(存储自定义对象下节讲)
*/
public class Demo1 {
    public static void main(String[] args) {
        int[] arr = {1,3,2,5,4};

        //public static String toString(类型[] arr)  返回数组内容的字符串表示形式
        System.out.println(Arrays.toString(arr));
        //public static int[] copyOfRange(类[]arr，起始索引，结束索引) 拷贝数组，元素为索引的指定范围，左包含右不包含
        int[] copy = Arrays.copyOfRange(arr, 1, 3);
        System.out.println(Arrays.toString(copy));
        //public static copyOf(类型[] arr，int newLength)  拷贝数组，指定新数组的长度
        int[] copyOf = Arrays.copyOf(arr, 6);
        System.out.println(Arrays.toString(copyOf));
        //public static void setAll(double[] array, IntToDoubleFunction generator)  将数组中的数据改为新数据，重新存入数
        double[] arr1 = {1.0, 3.0, 5.0, 7.0, 9.0};
        Arrays.setAll(arr1, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {
                return arr1[value] = value * 2;
            }
        });
        //public static void sort(类型[ arr); 对数组元素进行升序排列(存储自定义对象下节讲)
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

3.2 排序

/*
使用Arrays对对象进行排序
    方式1: 自然排序(本案例)
        1、实现Comparable接口，指定泛型
        2、重写compareTo方法
        3、指定排序规则
    排序规则
        返回正数，表示当前元素较大
        返回负数，表示当前元素较小
        返回0，表示相同
 */
public class Demo2 {
    public static void main(String[] args) {
        //1. 定义学生数组对象,保存四个学生进行测试
        Student[] students = new Student[4];
        students[0] = new Student("蜘蛛精", 169.5, 23);
        students[1] = new Student("紫霞1", 163.8, 26);
        students[2] = new Student("紫霞2", 164.8, 26);
        students[3] = new Student("至尊宝", 167.5, 24);
        System.out.println(Arrays.toString(students));
        //2. 指定排序的规则
        Arrays.sort(students);
        //3. 打印结果
        System.out.println(Arrays.toString(students));
    }
}

class Student implements Comparable<Student>{
    private String name;
    private double height;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public Student(String name, double height, int age) {
        this.name = name;
        this.height = height;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student stu) {
        return this.height > stu.getHeight() ? 1 : -1;
    }
}

/*
使用Arrays对对象进行排序
    方式2: 比较器排序
        1、调用sort排序方法，参数二传递Comparator按口的实现类对象(匿名内部类实现)
        2、重写compare方法
        3、指定排序规则
    排序规则
        返回正数，表示当前元素较大
        返回负数，表示当前元素较小
        返回0，表示相同
 */
public class Demo3 {
    public static void main(String[] args) {
        //1. 定义学生数组对象,保存四个学生进行测试
        Teacher[] teachers = new Teacher[4];
        teachers[0] = new Teacher("蜘蛛精", 169.5, 23);
        teachers[1] = new Teacher("紫霞1", 163.8, 26);
        teachers[2] = new Teacher("紫霞2", 164.8, 26);
        teachers[3] = new Teacher("至尊宝", 167.5, 24);

        //2. 指定排序的规则
        Arrays.sort(teachers, new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                System.out.println(o1 + "--" + o2);
                return o1.getHeight() > o2.getHeight() ? 1 : -1;
            }
        });
        Arrays.sort(teachers, new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                return o1.getAge() > o2.getAge() ? 1 : -1;
            }
        });
        //3. 打印结果
        System.out.println(Arrays.toString(teachers));
    }
}

class Teacher{
    private String name;
    private double height;
    private int age;

    public Teacher(String name, double height, int age) {
        this.name = name;
        this.height = height;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", age=" + age +
                '}';
    }
}

完球了

关注

31
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
【Day04-常用API、日期时间、Arrays】

代表简单日期格式化，可以用来把日期对象、时间毫秒值格式化成我们想要的形式。使用它拼接字符串的时候，不仅高效，而且代码的编写更加的方便。JDK8出现的一个可变的、操作字符串的容器。除法、可以控制精确到小数几位。把字符串时间解析成日期对象。对象，精确几位，舍入模式。注意：不推荐使用这个。
复制链接

扫一扫