Day07-Java进阶-JDK7(时间类&日历类) & JDK8(日历类&时间格式类)

最新推荐文章于 2024-05-27 22:32:13 发布

码里码理~

最新推荐文章于 2024-05-27 22:32:13 发布

阅读量209

点赞数 1

分类专栏： JavaEE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_68063226/article/details/137890227

版权

JavaEE 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1. JDK7(时间类&日历类)

1.1 时间API

8版本前后的时间API对比

1.1.1 Date类

package com.itheima.date;

import java.util.Date;

public class DateDemo {
    /*
        Date类: 表示时间的类

        1. 构造方法:

            public Date() : 将当前时间, 封装为Date日期对象
            public Date(long time) : 把时间毫秒值转换成Date日期对象

        2. 常见方法 :

            public long getTime() : 返回从1970年1月1日 00:00:00走到此刻的总的毫秒数
            public void setTime(long time) : 设置日期对象的时间为当前时间毫秒值对应的时间
     */
    public static void main(String[] args) {
        // 将当前时间, 封装为Date日期对象
        Date d1 = new Date();
        System.out.println(d1);

        // 把时间毫秒值转换成Date日期对象
        Date d2 = new Date(1000L);
        System.out.println(d2);

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

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

        Date d3 = new Date();
        d3.setTime(0L);
        System.out.println(d3);
    }
}

1.1.2 SimpleDateFormat类

package com.itheima.format;

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

public class SimpleDateFormatDemo {
    /*
        SimpleDateFormat类 : 用于日期格式化

        1. 构造方法:

            public SimpleDateFormat() : 创建一个日期格式化对象, 使用 [默认模式]
            public SimpleDateFormat(String pattern) : 创建一个日期格式化对象, [手动指定模式]

        2. 常用方法 :

            public final String format(Date date) : 将日期对象, 转换为字符串
            public final Date parse(String sourse) : 将日期字符串, 解析为日期对象
     */
    public static void main(String[] args) throws ParseException {
        // 创建一个日期格式化对象, 使用 [默认模式]
        //SimpleDateFormat simpleDateFormat = new SimpleDateFormat();

        // 创建一个日期格式化对象, [手动指定模式]
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日");

        // 创建Date对象, 封装此刻的时间
        Date date = new Date();

        // 将日期对象, 转换为字符串
        String result = simpleDateFormat.format(date);

        System.out.println(result);

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

        String today = "2024年4月19日";
        Date date1 = simpleDateFormat.parse(today);

        System.out.println(date1);
    }
}

1.1.3 计算生日至今的天数

package com.itheima.test;

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

public class DateTest1 {
    /*
        需求: 计算你来到了这个世界多少天

        分析:
                1. 键盘录入用户的生日 (日期字符串)
                2. 创建SimpleDateFormat对象, 指定模式, 对于将日期字符串解析为Date日期对象 (birthdayDate)
                3. 创建Date日期对象, 封装此刻的时间 (todayDate)
                4. long time = todayDate.getTime() - birthdayDate.getTime();
                5. 将毫秒值转换为天的单位

                    time / 1000 / 60 / 60 / 24;
     */
    public static void main(String[] args) throws ParseException {
        // 1. 键盘录入用户的生日 (日期字符串)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的生日: xxxx年xx月xx日");
        String birthday = sc.nextLine();

        // 2. 创建SimpleDateFormat对象, 指定模式, 对于将日期字符串解析为Date日期对象 (birthdayDate)
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日");
        Date birthdayDate = simpleDateFormat.parse(birthday);

        // 3. 创建Date日期对象, 封装此刻的时间 (todayDate)
        Date todayDate = new Date();

        // 4. long time = todayDate.getTime() - birthdayDate.getTime()
        long time = todayDate.getTime() - birthdayDate.getTime();

        // 5. 将毫秒值转换为天的单位并打印
        System.out.println(time / 1000 / 60 / 60 / 24);
    }

}

1.2 Calendar 类

package com.itheima.calendar;

import java.util.Calendar;

public class CalendarDemo {
    /*
        Calendar : 代表的是系统此刻时间对应的日历, 通过它可以单独获取, 修改时间中的年、月、日、时、分、秒等

        1. 创建对象 :
                public static Calendar getInstance() : 获取当前时间的日历对象
        2. 常用方法 :
                public int get(int field) : 取日历中的某个字段信息

                                get方法的参数 : Calendar类中的静态变量

                                    Calendar.YEAR : 获取年份信息
                                    Calendar.MONTH : 月份是0~11, 记得做+1操作
                                    Calendar.DAY_OF_MONTH :获取日
                                    Calendar.DAY_OF_WEEK : 获取星期, 获取星期的时候, 需要提前设计一个数组
                                    Calendar.DAY_OF_YEAR : 获取一年当中的第几天

                public void set(int field,int value) : 修改日历的某个字段信息
                public void add(int field,int amount) : 为某个字段增加/减少指定的值
     */
    public static void main(String[] args) {

        Calendar c = Calendar.getInstance();

        c.set(Calendar.YEAR,2022);

        System.out.println(c.get(Calendar.YEAR));

    }

    private static void getMethod() {
        // Calendar c : 抽象类
        // Calendar.getInstance() : 获取的是子类对象
        // 1. 获取当前时间的日历对象
        Calendar c = Calendar.getInstance();

        // 2. 调用get方法, 获取指定字段的信息
        int year = c.get(Calendar.YEAR);
        System.out.println(year);   // 2024

        // 注意Calendar类的月份是 0~11, 想要获取常规的月份, 需要对结果 + 1操作
        int month = c.get(Calendar.MONTH);
        System.out.println(month + 1);  // 4

        int day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);    // 19

        // 星期: 日 一 二 三 四 五 六 (国外星期的排法)
        //      1  2  3  4  5  6  7

        char[] weeks = {' ', '日', '一', '二', '三', '四', '五', '六'};
        //               0     1    2     3    4    5     6     7

        int weekIndex = c.get(Calendar.DAY_OF_WEEK);
        System.out.println(weeks[weekIndex]);   // 五

        int dayOfYear = c.get(Calendar.DAY_OF_YEAR);
        System.out.println(dayOfYear);  // 110
    }
}

小案例

package com.itheima.test;

import java.util.Calendar;

public class CalendarTest1 {
    /*
        需求 : 使用程序判断出 2050年3月1日 是否是疯狂星期四
     */
    public static void main(String[] args) {

        // 1. 获取日期对象 (此刻的时间)
        Calendar c = Calendar.getInstance();

        // 2. 调用set方法, 将时间设置为 2050年3月1日
        c.set(2050,2,1);

        char[] weeks = {' ', '日', '一', '二', '三', '四', '五', '六'};
        //               0     1    2     3    4    5     6     7


        // 3. 获取星期
        int weekIndex = c.get(Calendar.DAY_OF_WEEK);

        if (weeks[weekIndex] == '四'){
            System.out.println("今天是疯狂星期四, 我要奢侈一把~");
        }else {
            System.out.println("今天不是疯狂星期四, 吃不起KFC");
        }
    }
}

package com.itheima.test;

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

public class CalendarTest2 {
    /*
        需求 : 键盘录入一个日期字符串, 程序输出这个日期是一年中的第多少天

                1. 使用SimpleDateFormat, 将日期字符串转换为日期对象
                2. 将日期对象, 转换为Calendar对象
                3. 调用get方法, 获取一年中的第几天
     */
    public static void main(String[] args) throws ParseException {
        // 1. 输入日期字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入日期字符串: xxxx年xx月xx日");
        String dateContent = sc.nextLine();

        // 2. 使用SimpleDateFormat, 将日期字符串转换为日期对象
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = simpleDateFormat.parse(dateContent);

        // 3. 将日期对象, 转换为Calendar对象
        Calendar c  = Calendar.getInstance();
        c.setTime(date);

        // 4. 调用get方法, 获取一年中的第几天
        System.out.println("是这一年当中的第"+c.get(Calendar.DAY_OF_YEAR)+"天");

    }
}

2. JDK8(日历类&时间格式类)

2.1 日历类

package com.itheima.distinction;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;

public class Test {
    public static void main(String[] args) {
        // JDK8之前 :
        // 都是可变对象, 修改后会丢失最开始的时间信息
        Date time = new Date();
        System.out.println("修改前获取时间: " + time);
        // 修改
        time.setTime(1000);
        System.out.println("修改后获取的时间:" + time);

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

        // JDK8版本之后 :
        // 都是不可变对象, 修改后会返回新的时间对象, 不会丢失最开始的时间
        LocalDateTime now = LocalDateTime.now();
        System.out.println("修改后获取的时间:" + now);

        LocalDateTime afterTime = now.withYear(2008);
        System.out.println("修改后获取时间" + afterTime);
        System.out.println("修改后获取的时间:" + now);
    }
}

package com.itheima.jdk8;

import java.time.LocalDateTime;

public class Demo {
    /*
        --------------------------------------------------------
        LocalDate、LocalTime、LocalDateTime

        对象的创建方式

        1. now() : 当前时间

        2. of() : 设置时间

        ---------------------------------------------------------
        LocalDateTime 转换LocalDate、LocalTime、LocalDateTime

        1. toLocalDate()
        2. toLocalTime()
     */
    public static void main(String[] args) {
        // 获取此刻的时间对象
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);

        System.out.println(now.getYear() + "年");
        System.out.println(now.getMonth() + "月");
        System.out.println(now.getMonthValue() + "月");
        System.out.println(now.getDayOfMonth() + "日");
        System.out.println(now.getHour() + "时");
        System.out.println(now.getMinute() + "分");
        System.out.println(now.getSecond() + "秒");
        System.out.println(now.getNano() + "纳秒");

        // 获取指定的时间对象
        LocalDateTime of = LocalDateTime.of(2008, 8, 8, 8, 8);
        System.out.println(of);

    }
}

2.2 时间格式化类

2.3 时间类

2.4 工具类

2.4.1 ChronoUnit-多种时间单位的比较

package com.itheima.jdk8.p8_interval;

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

/**
 * ChronoUnit可用于在单个时间单位内测量一段时间，这个工具类是最全的了，可以用于比较所有的时间单位
 */
public class ChronoUnitDemo {
    public static void main(String[] args) {
        // 本地日期时间对象：此刻的
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        // 生日时间
        LocalDateTime birthDate = LocalDateTime.of(2023, 2, 4,
                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));
    }
}

2.4.2 Duration计算日期间隔 (时分秒)

package com.itheima.jdk8.p8_interval;

import java.time.Duration;
import java.time.LocalDateTime;

/**
 * Duration计算日期间隔 (时分秒)
 */
public class DurationDemo {
    public static void main(String[] args) {
        // 此刻日期时间对象
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        // 昨天的日期时间对象
        LocalDateTime otherDate = LocalDateTime.of(2023, 2
                , 4, 0, 0, 0);

        System.out.println(otherDate);

        Duration duration = Duration.between(otherDate, today); // 第二个参数减第一个参数

        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());                 // 两个时间差的纳秒数
    }
}

2.4.3 Period计算日期间隔 (年月日)

package com.itheima.jdk8.p8_interval;

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

/**
 * Period计算日期间隔 (年月日)
 */
public class PeriodDemo {
    public static void main(String[] args) {
        // 此刻年月日
        LocalDate today = LocalDate.now();
        System.out.println(today);

        // 昨天年月日
        LocalDate otherDate = LocalDate.of(2023, 2, 4);
        System.out.println(otherDate);

        //Period对象表示时间的间隔对象
        Period period = Period.between(today, otherDate);    // 第二个参数减第一个参数

        System.out.println(period.getYears());      // 间隔多少年
        System.out.println(period.getMonths());     // 间隔的月份
        System.out.println(period.getDays());       // 间隔的天数
        System.out.println(period.toTotalMonths()); // 总月份
    }
}