【JAVA入门】Day21 - 时间类

【JAVA入门】Day21 - 时间类

        Java 中的时间有一些相关类，它们都与时间的编程息息相关。

一、JDK7前的时间相关类

        世界上的时间，是有一个统一的计算标准的。
        曾经的世界时间标准被称作 格林尼治时间 / 格林威治时间 (Greenwich Mean Time)，简称GMT。GMT 的计算核心是：地球自转一天是24小时，太阳直射时为正午12点。但是由于误差太大，现在 GMT 已经被舍弃。
        现在的世界时间标准是利用原子钟规定的，利用铯原子的振动频率计算出来的时间，作为世界标准时间（UTC）。
        中国地处东八区，要在世界标准时间的基础上 + 8小时。

1.1 Date

        Date 类是 JDK 写好的一个 Javabean 类，用来描述时间，精确到毫秒。
        利用空参构造创建的对象，默认表示为系统当前时间。
        利用有参构造创建的对象，表示为指定的时间。

【练习】学习使用Date类。

package DateClass;

import java.util.Date;
import java.util.Random;

public class DateDemo2 {
    public static void main(String[] args) {
        //需求一：打印一年后的时间
        extracted();

        //需求二：比较两个Date对象哪个在前哪个在后
        extracted1();

    }

    private static void extracted() {
        //1.打印时间原点一年后的时间
        Date d1 = new Date(0L);

        //2.获取d1的毫秒值
        long time = d1.getTime();

        //3.加上一年后的毫秒值
        time = time + 1000L * 60 * 60 * 24 * 365;

        //4.把计算后的时间毫秒值，设置回d1中
        d1.setTime(time);

        //5.打印
        System.out.println(d1);
    	}

	    private static void extracted1() {
        Random r = new Random();

        //创建两个时间对象
        Date d1 = new Date(r.nextInt());
        Date d2 = new Date(r.nextInt());

        System.out.println(d1);
        System.out.println(d2);

        long time1 = d1.getTime();
        long time2 = d2.getTime();

        if(time1 > time2) {
            System.out.println("d2在前，d1在后");
        } else if(time2 > time1) {
            System.out.println("d1在前，d2在后");
        } else {
            System.out.println("两时间一样");
        }
   	  }
	}
}

1.2 SimpleDateFormat

         Date 类只能以默认的格式展示，不符合人们的阅读习惯。
        SimpleDateFormat 可以把日期格式化；也可以解析日期，即把字符串表示的时间编程 Date 对象。

         格式化的时间形式的常用模式对应关系如下：

【练习1】练习使用SimpleDateFormat。

package DateClass;

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

public class DateDemo3 {
    public static void main(String[] args) throws ParseException {
        //需求一：格式化时间
        method1();
        //需求二：解析字符串
        method2();
    }

    private static void method2() throws ParseException {
        //1.定义一个字符串用来表示时间
        String str = "2023-11-11 11:11:11";
        //2.利用空参构造创建SimpleDateFormat对象
        //其创建的格式参数要和字符串的格式完全一致
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //解析字符串，变为时间对象
        Date date = sdf.parse(str);
        //打印毫秒值
        System.out.println(date.getTime());
    }

    private static void method1() {
        //1.利用空参构造创建SimpleDateFormat对象，默认格式
        SimpleDateFormat sdf = new SimpleDateFormat();
        Date d1  = new Date(0L);
        String str = sdf.format(d1);
        System.out.println(str);       //1970/1/1 上午8:00

        //2.利用带参构造创建SimpleDateFormat对象，指定格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String str2 = sdf2.format(d1);
        System.out.println(str2);       //1970年01月01日 08:00:00

        //3.格式2
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 EE");
        String str3 = sdf3.format(d1);
        System.out.println(str3);       //1970年01月01日 08时00分00秒 周四
    }
}

【练习2】把一个日期转换为另一种格式。

package DateClass;

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

public class DateDemo4 {
    public static void main(String[] args) throws ParseException {
        /*2000-11-11*/

        String str = "2000-11-11";

        //1.解析字符串为日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf.parse(str);

        //2.格式化日期为年月日
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日");
        String result = sdf1.format(date);

        //3.打印
        System.out.println(result);

    }
}

【练习3】判断两个同学是否秒杀成功。

package DateClass;

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

public class DateDemo5 {
    public static void main(String[] args) throws ParseException {
        /*需求：
        秒杀活动：2023年11月11日 0:0:0
        开始时间：2023年11月11日 0:10:0

        小贾下单付款时间：2023年11月11日 0:01:00
        小皮下单付款时间：2023年11月11日 0:11:00

        计算两个人有没有参加成功
         */

        //1.比较两个时间
        String startStr = "2023年11月11日 0:0:0";
        String endStr = "2023年11月11日 0:10:0";
        String orderStr1 = "2023年11月11日 0:01:0";
        String orderStr2 = "2023年11月11日 0:11:00";

        //2.解析上面的时间，得到Date对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date startDate = sdf.parse(startStr);
        Date endDate = sdf.parse(endStr);
        Date orderDate1 = sdf.parse(orderStr1);
        Date orderDate2 = sdf.parse(orderStr2);

        //3.得到所有时间的毫秒值
        long startTime = startDate.getTime();
        long endTime = endDate.getTime();
        long orderTime1 = orderDate1.getTime();
        long orderTime2 = orderDate2.getTime();

        //4.判断
        if((startTime <= orderTime1)&&(orderTime1 <= endTime)) {
            System.out.println("小贾同学秒杀成功了！");
        }else{
            System.out.println("小贾同学秒杀失败了...");
        }

        if((startTime <= orderTime2)&&(orderTime2 <= endTime)) {
            System.out.println("小皮同学秒杀成功了！");
        }else{
            System.out.println("小皮同学秒杀失败了...");
        }
    }
}

1.3 Calendar

         Calendar 就是日历类，它是时间类的补充，可以单独修改、获取事件中的年，月，日。
         值得注意的是，Calendar 是一个抽象类，它不能直接创建对象。
         我们需要通过一个静态方法来获取当前时间的日历对象。

public static Calendar getInstance()

         Calendar 中常用的方法有这些：

         下面通过一个练习，熟悉一下这些方法。

package DateClass;

import java.util.Calendar;
import java.util.Date;

public class CalenderDemo1 {
    public static void main(String[] args) {
        //1.获取日历对象
        //Calender是一个抽象类，不能直接new，而是通过一个静态方法获取子类对象
        Calendar c = Calendar.getInstance();
        //底层原理：
        //会根据系统的不同时区来获取不同的日历对象
        //把时间中的纪元，年，月，日，时，分，秒，星期，等等放到一个数组当中

        //2.修改一下日历代表的时间为时间原点
        //获取的时间信息有细节
        // 月份范围：0~11，0代表一月，11代表十二月
        // 星期：星期日是第一天，值为1；星期六的值为7
        Date d = new Date(0L);
        c.setTime(d);

        //3.获取日期中某个字段信息
        //参数为int类型
        //0:纪元 1:年 2:月 3:一年中的第几周 ...
        //Java当中，把索引数字都定义为了常量
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DAY_OF_MONTH);
        int week = c.get(Calendar.DAY_OF_WEEK);

        System.out.println(year + ", " + month + ", "+ date+ ", " + getWeek(week));


        //4.修改日历中某个字段
        c.set(Calendar.YEAR, 2000);
        c.set(Calendar.MONTH,12);
        //月份12是指13月，这是不存在的
        //系统会自动把年份调成次年

        //5.为某个字段增加/减少值
        c.add(Calendar.MONTH, -1);

    }

    //传入对应的数字：1~7
    //返回对应的星期
    //查表法：在方法中让数据跟索引产生对应关系
    public static String getWeek(int index) {
        String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
        return arr[index];
    }
}

二、JDK8新增的时间相关类

         JDK8 新增的时间相关类，解决了 JDK7 代码麻烦的问题，而且在安全层面下有了突破。
         JDK7 在多线程环境下会导致数据安全问题产生，而 JDK8 的时间日期对象都是不可变的，解决了这个问题。
         JDK8 主要新增了以下四种类：

2.1 Date 相关类

2.1.1 ZoneId 时区

         时区类常用方法如下。

package DateClass;

import java.time.ZoneId;
import java.util.Set;

public class CalenderDemo2 {
    public static void main(String[] args) {
        /*
        时区
         */

        //1.获取所有的时区名称
        Set<String> zoneIds = ZoneId.getAvailableZoneIds();
        System.out.println(zoneIds);
        System.out.println(zoneIds.size());

        //2.获取当前系统的默认时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId);

        //3.获取指定的时区
        ZoneId zoneId1 = ZoneId.of("Asia/Aqtau");
        System.out.println(zoneId1);
        
    }

2.1.2 Instant 时间戳

        时间戳是一种新的计算时间方法，它可以精确到时间的纳秒值（标准时间）。

package DateClass;

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class DateDemo6 {
    public static void main(String[] args) {
        //1.获取当前时间的Instant对象（标准时间）
        Instant now = Instant.now();
        System.out.println(now);            //2024-08-16T10:35:23.164490400Z

        //2.根据（秒/毫秒/纳秒）获取Instant对象
        //获取原初时间戳
        Instant instant1 = Instant.ofEpochMilli(0L);
        System.out.println(instant1);       //1970-01-01T00:00:00Z

        //获取相较于原初时间一秒后的时间戳
        Instant instant2 = Instant.ofEpochSecond(1L);
        System.out.println(instant2);       //1970-01-01T00:00:01Z

        //获取1秒+1000000000纳秒后的时间
        Instant instant3 = Instant.ofEpochSecond(1L, 1000000000L);
        System.out.println(instant3);       //1970-01-01T00:00:02Z

        //3.指定时区
        //指定时区后再获得当前系统时间，中国在东八区，会自动加上8个小时
        ZonedDateTime zonedDateTime = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        System.out.println(zonedDateTime);    //2024-08-16T18:45:01.710355900+08:00[Asia/Shanghai]

        //4.isXxx 判断
        Instant instant4 = Instant.ofEpochMilli(0L);
        Instant instant5 = Instant.ofEpochMilli(1000L);

        boolean result1 = instant4.isBefore(instant5);
        System.out.println(result1);            //true

        boolean result2 = instant4.isAfter(instant5);
        System.out.println(result2);            //false

        //5.增减时间
        Instant instant6 = Instant.ofEpochMilli(3000L);
        System.out.println(instant6);           //1970-01-01T00:00:03Z

        Instant instant7 = instant6.minusSeconds(1L);
        System.out.println(instant7);           //1970-01-01T00:00:02Z

        Instant instant8 = instant6.plusMillis(5000L);
        System.out.println(instant8);           //1970-01-01T00:00:08Z

    }
}

2.1.3 ZoneDateTime 带时区的时间

        带时区的时间就是带上时区的时间。

package DateClass;

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class DateDemo7 {
    public static void main(String[] args) {
        //1.获取当前带时区的时间对象
        ZonedDateTime now = ZonedDateTime.now();
        System.out.println(now);

        //2.获取指定的带时区时间对象
        //年月日时分秒纳秒方式指定
        ZonedDateTime time1 = ZonedDateTime.of(2023,10,1,11,12,12,0, ZoneId.of("Asia/Shanghai"));
        System.out.println(time1);

        //通过Instant + 时区的方式获取指定时间对象
        Instant instant = Instant.ofEpochMilli(0L);
        ZoneId zoneId = ZoneId.of("Asia/Shanghai");
        ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
        System.out.println(time2);      //1970-01-01T08:00+08:00[Asia/Shanghai]

        //3.withXxx 修改时间系列的方法，可以单独修改年月日等
        ZonedDateTime time3 = time2.withYear(2000);
        System.out.println(time3);      //2000-01-01T08:00+08:00[Asia/Shanghai]

        //4.减少时间
        ZonedDateTime time4 = time3.minusYears(1);
        System.out.println(time4);

        //5.增加时间
        ZonedDateTime time5 = time3.plusYears(1);
        System.out.println(time5);

        //细节：
        //JDK8新增的时间对象都是不可变的
        //如果我们进行任何形式的修改，调用者本身都不会改变，而是会产生一个新的时间
    }
}

2.2 DateTimeFormat 相关类

2.2.1 DateTimeFormatter 时间的格式化和解析类

        两个方法用来时间格式化和解析。被解析的时间对象可以是ZonedDateTime （带时区的时间类对象）。

package DateClass;

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class DateDemo8 {
    public static void main(String[] args) {
        //获取时间对象
        ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));

        //生成对象
        DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EE a");

        //格式化时间对象
        System.out.println(dtf1.format(time));
    }
}

2.3 Calendar 相关类

2.3.1 LocalDate、LocalTime、LocalDateTime

        这三个类是这种关系，LocalDateTime 能表示的最全，年月日时分秒都可以，LocalDate 只能表示年月日，LocalTime 只能表示时分秒。LocalDate 和 LocalTime 之间可以互转。

        LocalDate 类用法如下。

package DateClass;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.MonthDay;

public class LocalDateDemo {
    public static void main(String[] args) {
        //1.获取当前时间的日历对象（包含年月日）
        LocalDate nowDate = LocalDate.now();

        //2.获取指定的时间的日历对象
        LocalDate ldDate = LocalDate.of(2023, 1, 1);
        System.out.println("指定日期:" + ldDate);

        System.out.println("===============================");

        //3.get系列方法获取日历中的每一个属性值
        //获取年
        int year = ldDate.getYear();
        System.out.println("year:" + year);

        //获取月
        //方式一：通过Month对象获取
        Month m = ldDate.getMonth();
        System.out.println(m);
        System.out.println(m.getValue());

        //方式二：用int变量接收
        int month = ldDate.getMonthValue();
        System.out.println(month);

        //获取日
        int day = ldDate.getDayOfMonth();
        System.out.println("day:" + day);

        //获取一年的第几天
        int dayOfYear = ldDate.getDayOfYear();
        System.out.println("dayOfYear:" + dayOfYear);

        //获取星期
        DayOfWeek dayOfWeek = ldDate.getDayOfWeek();
        System.out.println(dayOfWeek);
        System.out.println(dayOfWeek.getValue());

        //is方法表判断
        System.out.println(ldDate.isBefore(ldDate));
        System.out.println(ldDate.isAfter(ldDate));

        //with开头方法表示修改，只能修改年月日
        //修改传回的是一个新的对象
        LocalDate withLocalDate = ldDate.withYear(2000);
        System.out.println(withLocalDate);
        System.out.println(withLocalDate == ldDate); //false

        //minus减少年月日
        LocalDate minusLocalDate = ldDate.minusYears(1);
        System.out.println(minusLocalDate);

        //plus增加年月日
        LocalDate plusLocalDate = ldDate.plusDays(1);
        System.out.println(plusLocalDate);

        //------------------------------
        //判断今天是否是你的生日
        LocalDate birDate = LocalDate.of(2000, 1, 1);
        LocalDate nowDate1 = LocalDate.now();

        //月日对象
        MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
        MonthDay nowMd = MonthDay.of(nowDate1.getMonthValue(), nowDate1.getDayOfMonth());

        System.out.println("今天是你的生日吗？" + birMd.equals(nowMd));
    }
}

        LocalTime 类用法如下。

package DateClass;

import java.time.LocalTime;

public class LocalTimeDemo {
    public static void main(String[] args) {
        //获取本地时间的日历对象（时分秒）
        LocalTime nowTime = LocalTime.now();
        System.out.println("今天的时间:" + nowTime);

        int hour = nowTime.getHour(); //时
        System.out.println("hour:" + hour);

        int minute = nowTime.getMinute();   //分
        System.out.println("minute:" + minute);

        int second = nowTime.getSecond();   //秒
        System.out.println("second:" + second);

        int nano = nowTime.getNano();       //纳秒
        System.out.println("nano:" + nano);

        System.out.println("------------------------");
        System.out.println(LocalTime.of(8, 20, 30)); //时分秒
        LocalTime mTime = LocalTime.of(8, 20, 30, 150);

        //is系列方法
        System.out.println(nowTime.isBefore(mTime));
        System.out.println(nowTime.isAfter(mTime));

        //with系列方法，只能修改时分秒
        System.out.println(nowTime.withHour(10));

        //minus系列
        System.out.println(nowTime.minusHours(10));

        //plus系列
        System.out.println(nowTime.plusHours(10));
    }
}

2.4 JDK8 新增的三个工具类

        它们是：

• Duration：时间间隔（秒，纳秒）
• Period：时间间隔（年，月，日）
• ChronoUnit：时间间隔（所有单位）

        Period - 计算年月日之间的时间间隔。

package DateClass;

import java.time.LocalDate;
import java.time.Period;

public class TimeUtils {
    public static void main(String[] args) {
        //当前本地年月日
        LocalDate today = LocalDate.now();
        System.out.println(today);

        //生日的年月日
        LocalDate birthDate = LocalDate.of(2000, 1, 1);
        System.out.println(birthDate);

        //时间间隔是多少：第二个参数减去第一个参数
        Period period = Period.between(birthDate, today);

        System.out.println("相差的时间间隔对象：" + period);
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());

        //转化为总共差几个月
        System.out.println(period.toTotalMonths());
    }
}

        Duration - 计算时分秒之间的时间间隔

package DateClass;

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;

public class TimeUtils {
    public static void main(String[] args) {
        //当前本地年月日
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        //出生日期的时间对象
        LocalDateTime birthDate = LocalDateTime.of(2000,1,1,0,00,00);
        System.out.println(birthDate);

        Duration duration = Duration.between(birthDate,today);
        System.out.println("相差的时间间隔对象：" + duration);

        System.out.println("========================");
        System.out.println(duration.toDays());
        System.out.println(duration.toHours());
        System.out.println(duration.toMinutes());
        System.out.println(duration.toMillis());
        System.out.println(duration.toNanos());
    }
}

        ChronoUnit - 计算年月日时分秒的时间间隔。

package DateClass;

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class ChronoUnitDemo {
    public static void main(String[] args) {
        //当前时间
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        //生日时间
        LocalDateTime birthDate = LocalDateTime.of(2000,1,1,0,0,0);
        System.out.println(birthDate);

        System.out.println("相差的年数:" + ChronoUnit.YEARS.between(birthDate, today));
        System.out.println("相差的月数:" + ChronoUnit.MONTHS.between(birthDate, today));
        System.out.println("相差的周数:"+ ChronoUnit.WEEKS.between(birthDate, today));
        System.out.println("相差的天数:"+ ChronoUnit.DAYS.between(birthDate, today));
        System.out.println("相差的时数:"+ ChronoUnit.HOURS.between(birthDate, today));
        System.out.println("相差的分数:"+ ChronoUnit.MINUTES.between(birthDate, today));
        System.out.println("相差的秒数:"+ ChronoUnit.SECONDS.between(birthDate, today));
        System.out.println("相差的毫秒数:"+ ChronoUnit.MILLIS.between(birthDate, today));
        System.out.println("相差的微秒数:"+ ChronoUnit.MICROS.between(birthDate, today));
        System.out.println("相差的纳秒数:"+ ChronoUnit.NANOS.between(birthDate, today));
        System.out.println("相差的半天数:"+ ChronoUnit.HALF_DAYS.between(birthDate, today));
        System.out.println("相差的十年数:"+ ChronoUnit.DECADES.between(birthDate, today));
        System.out.println("相差的世纪（百年）数:"+ ChronoUnit.CENTURIES.between(birthDate, today));
        System.out.println("相差的千年数:"+ ChronoUnit.MILLENNIA.between(birthDate, today));
        System.out.println("相差的纪元数:"+ ChronoUnit.ERAS.between(birthDate, today));
    }
}