目录

日期类(Date)

日期格式化(SimpleDateFormat)

时间戳 (currentTimeMillis方法)

日历类 Calendar

JDK8后日期类(LocalTime)

Math类

数字格式化(DecimalFormat)

大数据类 BigInteger(BigDecimal)

随机数(Random)

数组工具类Arrays

枚举(enum)

一、枚举类的概述

二、枚举类中的常用方法

三、创建一个枚举类

四、自定义枚举类

使用enum来创建枚举类

日期类(Date)

java.util.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 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

JDK8后日期类(LocalTime)

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

• java.time – 包含值对象的基础包

• java.time.chrono – 提供对不同的日历系统的访问。

• java.time.format – 格式化和解析时间和日期

• java.time.temporal – 包括底层框架和扩展特性

• java.time.zone – 包含时区支持的类

• LocalDate、LocalTime、LocalDateTime 本地日期类

• 获取时间 

        //获取当前时间
        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

数字格式化(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 = 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

枚举(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("这是一个季节");
//    }
}

最后

以上就是老迟到石头为你收集整理的Day20.常用类：Date类、LocalTime、Math类、bigDecimal、Arrays、枚举日期类(Date)JDK8后日期类(LocalTime)Math类数组工具类Arrays枚举(enum)的全部内容，希望文章能够帮你解决Day20.常用类：Date类、LocalTime、Math类、bigDecimal、Arrays、枚举日期类(Date)JDK8后日期类(LocalTime)Math类数组工具类Arrays枚举(enum)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。