Day20.常用类：Date类、LocalTime、Math类、bigDecimal、Arrays、枚举

焰火青年·

已于 2022-04-21 17:59:00 修改

阅读量503

点赞数

分类专栏： Java 文章标签： java 开发语言后端

于 2021-12-31 23:32:58 首次发布

本文链接：https://blog.csdn.net/a111042555/article/details/122262760

版权

Java 专栏收录该内容

39 篇文章 2 订阅

订阅专栏

日期类(Date)

日期格式化(SimpleDateFormat)

时间戳 (currentTimeMillis方法)

大数据类 BigInteger(BigDecimal)

日期类(Date)

java.util.Date

构造方法

Date()
分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

新建一个日期类；

        Date nowTime = new Date();
        System.out.println(nowTime);    //Fri Dec 31 15:28:40 CST 2021

日期格式化(SimpleDateFormat)

java.util.SimpleDateFormat

当我们对输出格式有要求时，会用到SimpleDateFormat这个类

SimpleDateFormat是java.text包下的，专门负责日期格式化的。 yyyy 年 MM 月 dd 日 HH 时 mm 分 ss 秒 SSS 毫秒在日期格式中，除了y M d H m s S这些字符不能随意写之外，剩下的符号自己随意组织

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        //SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
        //SimpleDateFormat sdf = new SimpleDateFormat("yy/MM/dd HH:mm:ss");

        String nowTimeStr = sdf.format(nowTime);
        System.out.println(nowTimeStr);

String ---> Date；

        //假设现在有一个日期字符串String，如何切换成Date类型？
        String time = "2008-08-08 08:08:08 888";
        //注：字符串日期格式要和SimpleDateFormat格式相同 否则异常：ParseException
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        Date dateTime = sdf2.parse(time);
        System.out.println(dateTime);   //Fri Aug 08 08:08:08 CST 2008

时间戳 (currentTimeMillis方法)

currentTimeMillis，System类包下的方法

获取自1970年1月1日 00:00:00 000到当前系统时间的总毫秒数

        long s = System.currentTimeMillis();
        System.out.println(s);//1640939183355

获取昨天此时的时间

    public static void main(String[] args) {
        //这个时间是什么时间？
        //1970-01-01 00:00:00 001
        Date time = new Date(1); //参数是一个毫秒

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String strTime = sdf.format(time);
        //北京是东8区
        System.out.println(strTime);    //1970-01-01 08:00:00 001

        ------------------------------------------------------------

        //获取昨天的此时的时间
        Date time2 = new Date(System.currentTimeMillis() - 1000*60*60*24);
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String strTime2 = sdf.format(time2);
        //北京是东8区
        System.out.println(strTime2);    //2021-12-30 16:50:47 679
    }

    public static void main(String[] args){

        //需求：统计一个方法执行所耗费的时长
        //在调用目标方法前记录一个毫秒数
        long begin = System.currentTimeMillis();
        print();
        //在调用目标方法后记录一个毫秒数
        long end = System.currentTimeMillis();
        System.out.println("耗费时长 = "+(end-begin));  //耗费时长 = 31
    }
    public static void print(){
        for (int i = 0; i < 1000; i++) {
            System.out.println("i = "+i);        //打印增加了时长
        }
    }

日历类 Calendar

java.util.Calendar

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

`static Calendar`	`getInstance()` 使用默认时区和语言环境获得一个日历。
`int`	`get(int field)` 返回给定日历字段的值。

JDK8后日期类(LocalTime)

java 8中引入的java.time API 已经纠正了过去的缺陷。

java.time – 包含值对象的基础包
java.time.chrono – 提供对不同的日历系统的访问。
java.time.format – 格式化和解析时间和日期
java.time.temporal – 包括底层框架和扩展特性
java.time.zone – 包含时区支持的类
LocalDate、LocalTime、LocalDateTime 本地日期类

方法	描述
now() / now(ZoneId zone)	静态方法，根据当前时间创建对象/指定时区的对象
of()	静态方法，根据指定日期/时间创建对象
format(DateTimeFormatter t)	格式化本地日期、时间，返回一个字符串
parse(Charsequence text)	将指定格式的字符串解析为日期、时间
getDayOfMonth()/getDayOfYear()	获得月份天数(1-31) /获得年份天数(1-366)
getDayOfWeek()	获得星期几(返回一个 DayOfWeek 枚举值)
getMonth()	获得月份, 返回一个 Month 枚举值
getMonthValue() / getYear()	获得月份(1-12) /获得年份
getHours()/getMinute()/getSecond()	获得当前对象对应的小时、分钟、秒
withDayOfMonth()/withDayOfYear()/withMonth()/withYear()	将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象
with(TemporalAdjuster t)	将当前日期时间设置为校对器指定的日期时间
plusDays(), plusWeeks(), plusMonths(), plusYears(),plusHours()	向当前对象添加几天、几周、几个月、几年、几小时
minusMonths() / minusWeeks()/minusDays()/minusYears()/minusHours()	从当前对象减去几月、几周、几天、几年、几小时
plus(TemporalAmount t)/minus(TemporalAmount t)	添加或减少一个 Duration 或 Period
isBefore()/isAfter()	比较两个 LocalDate
isLeapYear()	判断是否是闰年（在LocalDate类中声明）

获取时间

        //获取当前时间
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now); //2022-04-07T23:12:45.325428400
        //获取指定的时间
        LocalDateTime of = LocalDateTime.of(2022,4,7,23,06);
        System.out.println(of); //2022-04-07T23:06

指定时区日期时间：ZonedDateTime

        //获取此时格林威治时间
        ZonedDateTime utc = ZonedDateTime.now(ZoneId.of("UTC"));
        System.out.println(utc); //2022-04-07T15:11:22.025616300Z[UTC]
        //获得此时东八区的时间
        ZonedDateTime now1 = ZonedDateTime.now(ZoneId.of("+8"));
        System.out.println(now1);

        //常见时区
        //Asia/Shanghai
        //UTC   //格林威治时间
        //America/New_York

持续日期/时间 Period、Duration

用于计算两个“日期”间隔： Period

public static void main(String[] args) {
		LocalDate t1 = LocalDate.now();
		LocalDate t2 = LocalDate.of(2018, 12, 31);
		Period between = Period.between(t1, t2);
		System.out.println(between);
		
		System.out.println("相差的年数："+between.getYears());//1年
		System.out.println("相差的月数："+between.getMonths());//又7个月
		System.out.println("相差的天数："+between.getDays());//零25天
		System.out.println("相差的总数："+between.toTotalMonths());//总共19个月
	}

计算两个“时间”间隔: Duration

public static void main(String[] args) {
		LocalDateTime t1 = LocalDateTime.now();
		LocalDateTime t2 = LocalDateTime.of(2017, 8, 29, 0, 0, 0, 0);
		Duration between = Duration.between(t1, t2);
		System.out.println(between);
		
		System.out.println("相差的总天数："+between.toDays());
		System.out.println("相差的总小时数："+between.toHours());
		System.out.println("相差的总分钟数："+between.toMinutes());
		System.out.println("相差的总秒数："+between.getSeconds());
		System.out.println("相差的总毫秒数："+between.toMillis());
		System.out.println("相差的总纳秒数："+between.toNanos());
		System.out.println("不够一秒的纳秒数："+between.getNano());
	}

日期时间格式化 DateTimeFormatter

该类提供了三种格式化方法：

预定义的标准格式。如：DateTimeFormatter.ISO_DATE_TIME; ISO_DATE

本地化相关的格式。如：DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)

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

	@Test
	public void test(){
		LocalDateTime now = LocalDateTime.now();
		//自定义的格式
		DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒  SSS毫秒  E 是这一年的D天");
         //格式化操作
		String str = df.format(now);
		System.out.println(str);
	}

	@Test
	public void test1(){
		LocalDateTime now = LocalDateTime.now();
		//预定义的标准格式
		DateTimeFormatter df = DateTimeFormatter.ISO_DATE_TIME;//2019-06-06T16:38:23.756
        //格式化操作
		String str = df.format(now);
		System.out.println(str);
	}

	@Test
	public void test2(){
		LocalDateTime now = LocalDateTime.now();
		//本地化相关的格式
//		DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);//2019年6月6日 下午04时40分03秒
		DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);//19-6-6 下午4:40
        //格式化操作
		String str = df.format(now);
		System.out.println(str);
	}

解析字符串


	//把字符串解析为日期对象
    public void test3(){
        //自定义的格式
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy.MM.dd");
        //解析操作
        LocalDate parse = LocalDate.parse("2020.12.12", pattern);
        System.out.println(parse);
    }

Math类

java.lang.Math

`static double`	`abs(double a)` 返回 `double` 值的绝对值。
`static long`	`round(double a)` 返回最接近参数的 `long`。(四舍五入)
`static double`	`ceil(double a)` 返回大于等于参数的最小的整数。
`static double`	`floor(double a)` 返回小于等于参数最大的整数。
`static double`	`pow(double a, double b)` 返回第一个参数的第二个参数次幂的值。
`static double`	`sqrt(double a)` 返回正确舍入的 `double` 值的正平方根。
`static double`	`random()` 返回带正号的 `double` 值，该值大于等于 `0.0` 且小于 `1.0`。
`static double`	`max(double a, double b)` 返回两个 `double` 值中较大的一个。
`static double`	`min(double a, double b)` 返回两个 `double` 值中较小的一个。

数字格式化(DecimalFormat)

java.text.NumberFormat

DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。帮你用最快的速度将数字格式化为你需要的样子。

        //表示，千分位，保留2个小数
        DecimalFormat df = new DecimalFormat("###,###.##");
        String s = df.format(1234.567);
        System.out.println(s);       //1,234.56
        //不够位数补0
        DecimalFormat df2 = new DecimalFormat("###,###.0000");
        String s2 = df2.format(1234.56);
        System.out.println(s2);     //1,234.5600

大数据类 BigInteger(BigDecimal)

java.math.BigDecimal

使用字符串创建对象

BigInteger bigInteger = new BigInteger("132112331");

1、构造器描述
BigDecimal(int) 创建一个具有参数所指定整数值的对象。
BigDecimal(long) 创建一个具有参数所指定长整数值的对象。
BigDecimal(String) 创建一个具有参数所指定以字符串表示的数值的对象。//推荐使用

2、方法描述
add(BigDecimal) BigDecimal对象中的值相加，然后返回这个对象。
subtract(BigDecimal) BigDecimal对象中的值相减，然后返回这个对象。
multiply(BigDecimal) BigDecimal对象中的值相乘，然后返回这个对象。
divide(BigDecimal) BigDecimal对象中的值相除，然后返回这个对象。
toString() 将BigDecimal对象的数值转换成字符串。
doubleValue() 将BigDecimal对象中的值以双精度数返回。
floatValue() 将BigDecimal对象中的值以单精度数返回。
longValue() 将BigDecimal对象中的值以长整数返回。
intValue() 将BigDecimal对象中的值以整数返回。

取舍小数

//除以** | 保留*位小数 |舍入格式 (除以1则本身取舍)

BigDecimal divide(BigDecimal divisor)
          返回一个 BigDecimal，其值为 (this / divisor)，其首选标度为 (this.scale() - divisor.scale())；如果无法表示准确的商值（因为它有无穷的十进制扩展），则抛出 ArithmeticException。
BigDecimal divide(BigDecimal divisor, int roundingMode)
          返回一个 BigDecimal，其值为 (this / divisor)，其标度为 this.scale()。
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
          返回一个 BigDecimal，其值为 (this / divisor)，其标度为指定标度。

divisor - 此 BigDecimal 要除以的值。

scale - 要返回的 BigDecimal 商的标度。

roundingMode - 要应用的舍入模式。

BigDecimal 已过时不推荐 setScale(int newScale, int roundingMode)
          返回一个 BigDecimal，其标度为指定值，其非标度值通过此 BigDecimal 的非标度值乘以或除以十的适当次幂来确定，以维护其总值

        /*
        1.BigDecimal 属于大数据，精度极高，不属于基本数据类型，属于Java对象(引用数据类型)
        这是SUN提供的一个类，专门在财务软件中使用
        2.注意：财务软件double是不够的。
         */
        //精度级高的100
        BigDecimal v1 = new BigDecimal(100);
        BigDecimal v2 = new BigDecimal(200);
        //求和
        BigDecimal v3 = v1.add(v2); //300
        //除法
        BigDecimal v4 = v2.divide(v1); //2

        
        //保留三位，四舍五入
        BigDecimal shang = big.divide(1, 3, BigDecimal.ROUND_HALF_UP);

随机数(Random)

java.util.Random

Random()
创建一个新的随机数生成器。

Random(long seed)
使用单个 long 种子创建一个新的随机数生成器。

`protected int`	`next(int bits)` 生成下一个伪随机数。
`boolean`	`nextBoolean()` 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 `boolean` 值。
`int`	`nextInt()` 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 `int` 值。
`int`	`nextInt(int n)` 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 `int` 值。

        //创建随机数对象
        Random random = new Random();
        //随机产生一个int类型取值范围内的数字。
        int num1 = random.nextInt();
        System.out.println(num1);   //-228851400

        //产生[0 - 100]之间的随机数，不包括101
        random.nextInt(101);

小测试：生成5个不重复的随机数，放到数组中

    public static void main(String[] args) {
        //生成5个不重复的随机数，放到数组中
        Random random = new Random();

        int[] a = new int[5];
        int index = 0;
        while(index < a.length){
            int r = random.nextInt(6);
            if(panDuan(a,r)){
                a[index++] = r;
            }
        }
        System.out.println(Arrays.toString(a));
    }
    //判断数组是否含有该数方法
    public static boolean panDuan(int []a,int r){
        for (int i = 0; i < a.length; i++) {
            if(r == a[i]){
                return false;
            }
        }
        return true;
    }

数组工具类Arrays

java.util.Arrays

`static void`	`sort(int[] a)` 对指定的 int 型数组按数字升序进行排序。
`static void`	`sort(int[] a, int fromIndex, int toIndex)` 对指定 int 型数组的指定范围按数字升序进行排序。
`static int`	`binarySearch(Object[] a, int fromIndex, int toIndex, Object key)` 使用二分搜索法来搜索指定数组的范围，以获得指定对象。
`static int`	`binarySearch(Object[] a, Object key)` 使用二分搜索法来搜索指定数组，以获得指定对象。
`static int[]`	`copyOf(int[] original, int newLength)` 复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
`static int[]`	`copyOfRange(int[] original, int from, int to)` 将指定数组的指定范围复制到一个新数组。
`static void`	`fill(Object[] a, int fromIndex, int toIndex, Object val)` 将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
`static void`	`fill(Object[] a, Object val)` 将指定的 Object 引用分配给指定 Object 数组的每个元素。
`static boolean`	`equals(Object[] a, Object[] a2)` 如果两个指定的 Objects 数组彼此相等，则返回 true。
`static boolean`	`deepEquals(Object[] a1, Object[] a2)` 如果两个指定数组彼此是深层相等的，则返回 true。
`static String`	`toString(int[] a)` 返回指定数组内容的字符串表示形式。
`static` `<T> List<T>`	`asList(T... a)` 返回一个受指定数组支持的固定大小的List集合。

枚举(enum)

当一个方法只返回值只有两种情况，我们可以使用Boolean。但如果可能有多种情况？
枚举：一枚一枚可以列举出来的，才建议使用枚举类型。
枚举是一种引用数据类型。
枚举中的每一个值可以看做是常量。

//枚举类
enum Result{
    //SUCCESS 是枚举Result类型中的一个值
    //FAIL 是枚举类中的一个值
    //枚举雷的值，可以看做是"常量"
    SUCCESS,FAIL
}

    //计算两个int 类型数据的商方法
    public static Result divide(int a,int b){
        try {
            int c = a / b;
            return Result.SUCCESS;
        } catch (Exception e){
            return Result.FAIL;
        }
    }

    //计算两个int 类型数据的商
    public static Result divide(int a,int b){
        try {
            int c = a / b;
            return Result.SUCCESS;
        } catch (Exception e){
            return Result.FAIL;
        }
    }

例子

//四季类枚举
public enum Seasom {
    SPRING,SUMMER,AUTUMN,WINTER
}

//颜色枚举类
public enum Color {
    RED,BLUE,YELOW,BLACK
}

一、枚举类的概述

1.枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类
2.当需要定义一组常量时，强烈建议使用枚举类
3.如果枚举类中只一个对象，则可以作为单例模式的实现方式

二、枚举类中的常用方法

构造器私有化 (固定值, 所以不允许外界在创建对象)
对外暴露类中创建的对象(public static final修饰的, 实现底层优化)
只提供get方法, 不提供set方法 (因为枚举对象值通常为只读)

三、创建一个枚举类

enum Week{
    MONDAY(1,"星期一"),
    TUESDAY(2,"星期二"),
    WEDNESDAY(3,"星期三"),
    THURSDAY(4,"星期四"),
    FRIDAY(5,"星期五"),
    SATURDAY(6,"星期六"),
    SUNDAY(7,"星期日");

    private int number;
    private String decription;

    private Week(int number, String decription) {
        this.number = number;
        this.decription = decription;
    }
    //输入number，获取周几
    public static Week getByNumber(int number){
        switch(number){
            case 1:
                return MONDAY;
            case 2:
                return TUESDAY;
            case 3:
                return WEDNESDAY;
            case 4:
                return THURSDAY;
            case 5:
                return FRIDAY;
            case 6:
                return SATURDAY;
            case 7:
                return SUNDAY;
            default:
                return null;
        }
    }

    @Override
    public String toString() {
        return super.toString()+"(" + number + ","+ decription + ")";
    }
}

四、自定义枚举类

/**
 * 一、枚举类的使用
 * 1.枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类
 * 2.当需要定义一组常量时，强烈建议使用枚举类
 * 3.如果枚举类中只有一个对象，则可以作为单例模式的实现方式。
 *
 * 二、如何定义枚举类
 * 方式一：jdk5.0之前，自定义枚举类
 * 方式二：jdk5.0，可以使用enum关键字定义枚举类
 *
 * 三、Enum类中的常用方法：
 *    values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
 *    valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
 *    toString()：返回当前枚举类对象常量的名称
 *
 * 四、使用enum关键字定义的枚举类实现接口的情况
 *   情况一：实现接口，在enum类中实现抽象方法
 *   情况二：让枚举类的对象分别实现接口中的抽象方法
 */
public class SeasonTest {

    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);

    }

}
//自定义枚举类
class Season{
    //1.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //2.私有化类的构造器,并给对象属性赋值
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //3.提供当前枚举类的多个对象：public static final的
    public static final Season SPRING = new Season("春天","春暖花开");
    public static final Season SUMMER = new Season("夏天","夏日炎炎");
    public static final Season AUTUMN = new Season("秋天","秋高气爽");
    public static final Season WINTER = new Season("冬天","冰天雪地");

    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4.其他诉求1：提供toString()
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

使用enum来创建枚举类

当我们使用 enum 关键字开发一个枚举类时，默认会继承 Enum 类, 而且是一个 final 类[如何证明], 使用 javap 工具来演示
传统的 public static final Season2 SPRING = new Season2(“春天”, “温暖”); 简化成 SPRING(“春天”, “温暖”)，这里必须知道，它调用的是哪个构造器.
如果使用无参构造器创建枚举对象，则实参列表和小括号都可以省略
当有多个枚举对象时，使用,间隔，最后有一个分号结尾
枚举对象必须放在枚举类的行首

/**
 * 使用enum关键字定义枚举类
 * 说明：定义的枚举类默认继承于java.lang.Enum类
 */
public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 summer = Season1.SUMMER;
        //toString():返回枚举类对象的名称
        System.out.println(summer.toString());

//        System.out.println(Season1.class.getSuperclass());
        System.out.println("****************");
        //values():返回所有的枚举类对象构成的数组
        Season1[] values = Season1.values();
        for(int i = 0;i < values.length;i++){
            System.out.println(values[i]);
            values[i].show();
        }
        System.out.println("****************");
        Thread.State[] values1 = Thread.State.values();
        for (int i = 0; i < values1.length; i++) {
            System.out.println(values1[i]);
        }

        //valueOf(String objName):返回枚举类中对象名是objName的对象。
        Season1 winter = Season1.valueOf("WINTER");
        //如果没有objName的枚举类对象，则抛异常：IllegalArgumentException
//        Season1 winter = Season1.valueOf("WINTER1");
        System.out.println(winter);
        winter.show();
    }
}

interface Info{
    void show();
}

//使用enum关键字枚举类
enum Season1 implements Info{
    //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    SPRING("春天","春暖花开"){
        @Override
        public void show() {
            System.out.println("春天在哪里？");
        }
    },
    SUMMER("夏天","夏日炎炎"){
        @Override
        public void show() {
            System.out.println("宁夏");
        }
    },
    AUTUMN("秋天","秋高气爽"){
        @Override
        public void show() {
            System.out.println("秋天不回来");
        }
    },
    WINTER("冬天","冰天雪地"){
        @Override
        public void show() {
            System.out.println("大约在冬季");
        }
    };

    //2.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //2.私有化类的构造器,并给对象属性赋值

    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
//    //4.其他诉求1：提供toString()
//
//    @Override
//    public String toString() {
//        return "Season1{" +
//                "seasonName='" + seasonName + '\'' +
//                ", seasonDesc='" + seasonDesc + '\'' +
//                '}';
//    }


//    @Override
//    public void show() {
//        System.out.println("这是一个季节");
//    }
}

焰火青年·

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day20.常用类：Date类、LocalTime、Math类、bigDecimal、Arrays、枚举

JavaSE 常用类
复制链接

扫一扫

专栏目录

`BigDecimal`	`divide(BigDecimal divisor)` 返回一个 BigDecimal，其值为 (this / divisor)，其首选标度为 (this.scale() - divisor.scale())；如果无法表示准确的商值（因为它有无穷的十进制扩展），则抛出 ArithmeticException。
`BigDecimal`	`divide(BigDecimal divisor, int roundingMode)` 返回一个 BigDecimal，其值为 (this / divisor)，其标度为 this.scale()。
`BigDecimal`	`divide(BigDecimal divisor, int scale, int roundingMode)` 返回一个 BigDecimal，其值为 (this / divisor)，其标度为指定标度。

Day20.常用类：Date类、LocalTime、Math类、bigDecimal、Arrays、枚举

日期类(Date)

日期格式化(SimpleDateFormat)

时间戳 (currentTimeMillis方法)

日历类 Calendar

JDK8后日期类(LocalTime)

Math类

数字格式化(DecimalFormat)

大数据类 BigInteger(BigDecimal)

随机数(Random)

数组工具类Arrays

枚举(enum)

一、枚举类的概述

二、枚举类中的常用方法

三、创建一个枚举类

四、自定义枚举类

使用enum来创建枚举类

“相关推荐”对你有帮助么？