精华内容
下载资源
问答
  • Java8日期时间

    2020-08-10 12:56:49
    文章目录一、日期(LocalDate)二、时间(LocalTime)三、日期时间(LocalDateTime) 一、日期(LocalDate) 对应MySQL数据库的date字段类型 对应Javajava.time.LocalDate 比较:isBefore、isEqual、isAfter...

    一、日期(LocalDate)

    1. 对应MySQL数据库的date字段类型
    2. 对应Java的java.time.LocalDate
    3. 比较:isBefore、isEqual、isAfter(内部使用toEpochDay比较)
    4. 增减年月周天:plus*、minus*
    5. 时间戳(天):toEpochDay

    二、时间(LocalTime)

    1. 对应MySQL数据库的time字段类型
    2. 对应Java的java.time.LocalTime
    3. 增减时分秒:plus*、minus*
    4. 比较:isBefore、equals、isAfter

      (The comparison is based on the time-line position of the time within a day)

    三、日期时间(LocalDateTime)

    1. 对应MySQL数据库的datetime字段类型
    2. 对应Java的java.time.LocalDateTime
    3. 比较方法一:isBefore、isEqual、isAfter(内部是先比较LocalDate,再比较LocalTime)
    4. 比较方法二:localDateTime.toEpochSecond(时间戳比较)
    5. 增减年月周天时分秒:plus*、minus*
    6. 时间戳(秒)
       1、对象转换为时间戳:LocalDateTime.toEpochSecond
       2、时间戳转换为对象:LocalDateTime.ofEpochSecond
    
    1. 格式化
    2. 对象转换为字符串
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateTimeFormatter.format(localDateTime);
    
    1. 字符串转换为对象
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime localDateTime = LocalDateTime.parse(dateTime, dateTimeFormatter);
    
    展开全文
  • java8日期时间

    2019-09-26 20:37:20
    ###与时间有关的5个包* java.time* java.time.chrono* java.time.format* java.time.temporal* java.time.zone###java.time下的类* Clock* Duration* Instant* LocalDate* LocalDateTime* LocalTime* MonthDay* ...

    ###与时间有关的5个包
    * java.time
    * java.time.chrono
    * java.time.format
    * java.time.temporal
    * java.time.zone
    ###java.time下的类
    * Clock
    * Duration
    * Instant
    * LocalDate
    * LocalDateTime
    * LocalTime
    * MonthDay
    * OffsetDateTime
    * OffsetTime
    * Period
    * Year
    * YearMonth
    * ZonedDateTime
    * ZoneId
    * ZoneOffset

    下面对以上类进行分类:

    LocalDate包含年月日,以为与时区有关系,所以加上local这个前缀.

    LocalTime包含时分秒毫秒纳秒,与时区有关系.

    LocalDateTime包含LocalDate和LocalTime中的全部属性,与时区有关系.

    MonthDay表示月日,Year表示年,YearMonth表示年月,三者与时区无关.

    Duration和Period都表示一段时间,Duration表示时分秒上的差异,Period表示两个LocalDate之间的差异.

    此外,java.time还包括两个枚举DayOfWeek和Month,一个异常DateTimeException.

    其它四个包并不重要,很少用到.学习库函数无需求全责备.
    ###通用特征
    * 值类型,不可变类型
    一旦更改对象,就变成了另外一个对象,而无法在原对象上进行操作.就像java中的String,Integer等不可变类型一样.
    * 大量使用静态方法来生成对象,而不用构造函数
    * 分工明确,例如Year,YearMonth等
    * 日期和时间明显分为两大阵营
    Period用于两个日期之间做差,Duration用于两个时间之间做差.
    * 对给人用的和给机器用的分工明确,Instant和Clock是给机器用的
    * 时区支持完好
    ###LocalDate
    LocalDate和LocalTime都实现了多个接口,其中两个主要接口是相同的:Temporal, TemporalAdjuster.
    LocalDate d=LocalDate.ofEpochDay(365);
    LocalDate d = LocalDate.ofYearDay(2014, 100)
    EpochDay意思是从1970年1月1日到现在过去的天数.
    with类函数意思是替换某个时间属性.
    System.out.println(LocalDate.now().with(MonthDay.of(9, 7)));
    这里的with(TemporalAdjuster adjuster)中,TemporalAdjuster是MonthDay,LocalDate等类的基类.
    TemporalAdjuster子孙繁盛:DayOfWeek, HijrahDate, HijrahEra, Instant, IsoEra, JapaneseDate, JapaneseEra, LocalDate, LocalDateTime, LocalTime, MinguoDate, MinguoEra, Month, MonthDay, OffsetDateTime, OffsetTime, ThaiBuddhistDate, ThaiBuddhistEra, Year, YearMonth, ZoneOffset
    ###与java.util.Date的互相转换

    System.out.println(Date.from(Instant.now()));
    System.out.println(new Date(System.currentTimeMillis()).toInstant());

    ###打印当前各个时区的名称,时间

    ZoneId.getAvailableZoneIds().forEach(x -> { 
      System.out.println(x+" "+ZonedDateTime.now(ZoneId.of(x)));
    });

    ###格式化输出

    System.out.println(DateTimeFormatter.ofPattern("uuuuMMdd").format(LocalDate.now()));
    System.out.println(DateTimeFormatter.ofPattern("yyyyMMdd").format(LocalDate.now()));
    System.out.println(LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
    System.out.println(DateTimeFormatter.BASIC_ISO_DATE.format(LocalDate.now());

    输出为20160909
    对于格式化输出,主要在java.time.format.DateTimeFormater类中进行,这个类规定了如下占位符:

    //公元
    FIELD_MAP.put('G', ChronoField.ERA); // SDF, LDML (different to both for 1/2 chars)
    FIELD_MAP.put('y', ChronoField.YEAR_OF_ERA); // SDF, LDML
    FIELD_MAP.put('u', ChronoField.YEAR); // LDML (different in SDF)
    //Q和q都表示季度
    FIELD_MAP.put('Q', IsoFields.QUARTER_OF_YEAR); // LDML (removed quarter from 310)
    FIELD_MAP.put('q', IsoFields.QUARTER_OF_YEAR); // LDML (stand-alone)
    //M和L都表示月份
    FIELD_MAP.put('M', ChronoField.MONTH_OF_YEAR); // SDF, LDML
    FIELD_MAP.put('L', ChronoField.MONTH_OF_YEAR); // SDF, LDML (stand-alone)
    
    FIELD_MAP.put('D', ChronoField.DAY_OF_YEAR); // SDF, LDML
    FIELD_MAP.put('d', ChronoField.DAY_OF_MONTH); // SDF, LDML
    FIELD_MAP.put('F', ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH); // SDF, LDML
    //E和e和c都表示周几
    FIELD_MAP.put('E', ChronoField.DAY_OF_WEEK); // SDF, LDML (different to both for 1/2 chars)
    FIELD_MAP.put('c', ChronoField.DAY_OF_WEEK); // LDML (stand-alone)
    FIELD_MAP.put('e', ChronoField.DAY_OF_WEEK); // LDML (needs localized week number)
    
    FIELD_MAP.put('a', ChronoField.AMPM_OF_DAY); // SDF, LDML
    FIELD_MAP.put('H', ChronoField.HOUR_OF_DAY); // SDF, LDML
    FIELD_MAP.put('k', ChronoField.CLOCK_HOUR_OF_DAY); // SDF, LDML
    FIELD_MAP.put('K', ChronoField.HOUR_OF_AMPM); // SDF, LDML
    FIELD_MAP.put('h', ChronoField.CLOCK_HOUR_OF_AMPM); // SDF, LDML
    FIELD_MAP.put('m', ChronoField.MINUTE_OF_HOUR); // SDF, LDML
    FIELD_MAP.put('s', ChronoField.SECOND_OF_MINUTE); // SDF, LDML
    FIELD_MAP.put('S', ChronoField.NANO_OF_SECOND); // LDML (SDF uses milli-of-second number)
    FIELD_MAP.put('A', ChronoField.MILLI_OF_DAY); // LDML
    FIELD_MAP.put('n', ChronoField.NANO_OF_SECOND); // 310 (proposed for LDML)
    FIELD_MAP.put('N', ChronoField.NANO_OF_DAY); 

    占位符的意义已经很明确了,占位符的个数不同表达的含义也不相同,如果只出现一个占位符,那么只输出一次.如果有多个连续相同占位符,则在前面补0来凑够位数.这一部分主要在DateTimeFormatter#parseField()函数中描述,这个函数比较混乱,并且没啥意义,无需研读.
    ###计算日期差和时间差
    对于日期类型,使用Period.between(LocalDate,LocalDate)函数;对于时间类型,使用Duration.between(Temporal,Temporal)函数.

    ###其它

        public static void testClock() throws InterruptedException {
            // 时钟提供给我们用于访问某个特定 时区的 瞬时时间、日期 和 时间的。
            Clock c1 = Clock.systemUTC(); // 系统默认UTC时钟(当前瞬时时间
                                            // System.currentTimeMillis())
            System.out.println(c1.millis()); // 每次调用将返回当前瞬时时间(UTC)
            Clock c2 = Clock.systemDefaultZone(); // 系统默认时区时钟(当前瞬时时间)
            System.out.println(c2.millis());
            Clock c31 = Clock.system(ZoneId.of("Europe/Paris")); // 巴黎时区
            System.out.println(c31.millis()); // 每次调用将返回当前瞬时时间(UTC)
            Clock c32 = Clock.system(ZoneId.of("Asia/Shanghai"));// 上海时区
            System.out.println(c32.millis());// 每次调用将返回当前瞬时时间(UTC)
            Clock c4 = Clock.fixed(Instant.now(), ZoneId.of("Asia/Shanghai"));// 固定上海时区时钟
            System.out.println(c4.millis());
            Thread.sleep(1000);
            System.out.println(c4.millis()); // 不变 即时钟时钟在那一个点不动
            Clock c5 = Clock.offset(c1, Duration.ofSeconds(2)); // 相对于系统默认时钟两秒的时钟
            System.out.println(c1.millis());
            System.out.println(c5.millis());
        }
        public static void testInstant() {
            // 瞬时时间 相当于以前的System.currentTimeMillis()
            Instant instant1 = Instant.now();
            System.out.println(instant1.getEpochSecond());// 精确到秒 得到相对于1970-01-01
                                                            // 00:00:00 UTC的一个时间
            System.out.println(instant1.toEpochMilli()); // 精确到毫秒
            Clock clock1 = Clock.systemUTC(); // 获取系统UTC默认时钟
            Instant instant2 = Instant.now(clock1);// 得到时钟的瞬时时间
            System.out.println(instant2.toEpochMilli());
            Clock clock2 = Clock.fixed(instant1, ZoneId.systemDefault()); // 固定瞬时时间时钟
            Instant instant3 = Instant.now(clock2);// 得到时钟的瞬时时间
            System.out.println(instant3.toEpochMilli());// equals instant1
        }
        public static void testLocalDateTime() {
            // 使用默认时区时钟瞬时时间创建 Clock.systemDefaultZone() -->即相对于
            // ZoneId.systemDefault()默认时区
            LocalDateTime now = LocalDateTime.now();
            System.out.println(now);
            // 自定义时区
            LocalDateTime now2 = LocalDateTime.now(ZoneId.of("Europe/Paris"));
            System.out.println(now2);// 会以相应的时区显示日期
            // 自定义时钟
            Clock clock = Clock.system(ZoneId.of("Asia/Dhaka"));
            LocalDateTime now3 = LocalDateTime.now(clock);
            System.out.println(now3);// 会以相应的时区显示日期
            // 不需要写什么相对时间 如java.util.Date 年是相对于1900 月是从0开始
            // 2013-12-31 23:59
            LocalDateTime d1 = LocalDateTime.of(2013, 12, 31, 23, 59);
            // 年月日 时分秒 纳秒
            LocalDateTime d2 = LocalDateTime.of(2013, 12, 31, 23, 59, 59, 11);
            // 使用瞬时时间 + 时区
            Instant instant = Instant.now();
            LocalDateTime d3 = LocalDateTime.ofInstant(Instant.now(),
                    ZoneId.systemDefault());
            System.out.println(d3);
            // 解析String--->LocalDateTime
            LocalDateTime d4 = LocalDateTime.parse("2013-12-31T23:59");
            System.out.println(d4);
            LocalDateTime d5 = LocalDateTime.parse("2013-12-31T23:59:59.999");// 999毫秒
                                                                                // 等价于999000000纳秒
            System.out.println(d5);
            // 使用DateTimeFormatter API 解析 和 格式化
            DateTimeFormatter formatter = DateTimeFormatter
                    .ofPattern("yyyy/MM/dd HH:mm:ss");
            LocalDateTime d6 = LocalDateTime.parse("2013/12/31 23:59:59",
                    formatter);
            System.out.println(formatter.format(d6));
            // 时间获取
            System.out.println(d6.getYear());
            System.out.println(d6.getMonth());
            System.out.println(d6.getDayOfYear());
            System.out.println(d6.getDayOfMonth());
            System.out.println(d6.getDayOfWeek());
            System.out.println(d6.getHour());
            System.out.println(d6.getMinute());
            System.out.println(d6.getSecond());
            System.out.println(d6.getNano());
            // 时间增减
            LocalDateTime d7 = d6.minusDays(1);
            LocalDateTime d8 = d7.plus(1, IsoFields.QUARTER_YEARS);
            // LocalDate 即年月日 无时分秒
            // LocalTime即时分秒 无年月日
            // API和LocalDateTime类似就不演示了
        }
        public static void testZonedDateTime() {
            // 即带有时区的date-time 存储纳秒、时区和时差(避免与本地date-time歧义)。
            // API和LocalDateTime类似,只是多了时差(如2013-12-20T10:35:50.711+08:00[Asia/Shanghai])
            ZonedDateTime now = ZonedDateTime.now();
            System.out.println(now);
            ZonedDateTime now2 = ZonedDateTime.now(ZoneId.of("Europe/Paris"));
            System.out.println(now2);
            // 其他的用法也是类似的 就不介绍了
            ZonedDateTime z1 = ZonedDateTime
                    .parse("2013-12-31T23:59:59Z[Europe/Paris]");
            System.out.println(z1);
        }
        public static void testDuration() {
            // 表示两个瞬时时间的时间段
            Duration d1 = Duration.between(
                    Instant.ofEpochMilli(System.currentTimeMillis() - 12323123),
                    Instant.now());
            // 得到相应的时差
            System.out.println(d1.toDays());
            System.out.println(d1.toHours());
            System.out.println(d1.toMinutes());
            System.out.println(d1.toMillis());
            System.out.println(d1.toNanos());
            // 1天时差 类似的还有如ofHours()
            Duration d2 = Duration.ofDays(1);
            System.out.println(d2.toDays());
        }
        public static void testChronology() {
            // 提供对java.util.Calendar的替换,提供对年历系统的支持
            Chronology c = HijrahChronology.INSTANCE;
            ChronoLocalDateTime d = c.localDateTime(LocalDateTime.now());
            System.out.println(d);
        }
        /**
         * 新旧日期转换
         */
        public static void testNewOldDateConversion() {
            Instant instant = new Date().toInstant();
            Date date = Date.from(instant);
            System.out.println(instant);
            System.out.println(date);
        }
        public static void main(String[] args) throws InterruptedException {
            testClock();
            testInstant();
            testLocalDateTime();
            testZonedDateTime();
            testDuration();
            testChronology();
            testNewOldDateConversion();
        }

     

    转载于:https://www.cnblogs.com/weiyinfu/p/5858098.html

    展开全文
  • 史上最全Java8日期时间工具类

    万次阅读 多人点赞 2020-12-13 14:52:18
    * Java8日期时间工具类 * * @author JourWon * @date 2020/12/13 */ public class LocalDateUtils { /** * 显示年月日时分秒,例如 2015-08-11 09:51:53. */ public static final String DATETIME

    文章目录

    这是我总结的Java8日期工具类,应该是比较全面的,满足日常开发绝大部分需求,分享给大家,有错误之处,还望大神指教。

    /**
     * Java8日期时间工具类
     *
     * @author JourWon
     * @date 2020/12/13
     */
    public class LocalDateUtils {
    
        /**
         * 显示年月日时分秒,例如 2015-08-11 09:51:53.
         */
        public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
    
        /**
         * 仅显示年月日,例如 2015-08-11.
         */
        public static final String DATE_PATTERN = "yyyy-MM-dd";
    
        /**
         * 仅显示时分秒,例如 09:51:53.
         */
        public static final String TIME_PATTERN = "HH:mm:ss";
    
        /**
         * 显示年月日时分秒(无符号),例如 20150811095153.
         */
        public static final String UNSIGNED_DATETIME_PATTERN = "yyyyMMddHHmmss";
    
        /**
         * 仅显示年月日(无符号),例如 20150811.
         */
        public static final String UNSIGNED_DATE_PATTERN = "yyyyMMdd";
    
        /**
         * 春天;
         */
        public static final Integer SPRING = 1;
    
        /**
         * 夏天;
         */
        public static final Integer SUMMER = 2;
    
        /**
         * 秋天;
         */
        public static final Integer AUTUMN = 3;
    
        /**
         * 冬天;
         */
        public static final Integer WINTER = 4;
    
        /**
         * 星期日;
         */
        public static final String SUNDAY = "星期日";
    
        /**
         * 星期一;
         */
        public static final String MONDAY = "星期一";
    
        /**
         * 星期二;
         */
        public static final String TUESDAY = "星期二";
    
        /**
         * 星期三;
         */
        public static final String WEDNESDAY = "星期三";
    
        /**
         * 星期四;
         */
        public static final String THURSDAY = "星期四";
    
        /**
         * 星期五;
         */
        public static final String FRIDAY = "星期五";
    
        /**
         * 星期六;
         */
        public static final String SATURDAY = "星期六";
    
        /**
         * 年
         */
        private static final String YEAR = "year";
    
        /**
         * 月
         */
        private static final String MONTH = "month";
    
        /**
         * 周
         */
        private static final String WEEK = "week";
    
        /**
         * 日
         */
        private static final String DAY = "day";
    
        /**
         * 时
         */
        private static final String HOUR = "hour";
    
        /**
         * 分
         */
        private static final String MINUTE = "minute";
    
        /**
         * 秒
         */
        private static final String SECOND = "second";
    
        /**
         * 获取当前日期和时间字符串.
         *
         * @return String 日期时间字符串,例如 2015-08-11 09:51:53
         */
        public static String getLocalDateTimeStr() {
            return format(LocalDateTime.now(), DATETIME_PATTERN);
        }
    
        /**
         * 获取当前日期字符串.
         *
         * @return String 日期字符串,例如2015-08-11
         */
        public static String getLocalDateStr() {
            return format(LocalDate.now(), DATE_PATTERN);
        }
    
        /**
         * 获取当前时间字符串.
         *
         * @return String 时间字符串,例如 09:51:53
         */
        public static String getLocalTimeStr() {
            return format(LocalTime.now(), TIME_PATTERN);
        }
    
        /**
         * 获取当前星期字符串.
         *
         * @return String 当前星期字符串,例如 星期二
         */
        public static String getDayOfWeekStr() {
            return format(LocalDate.now(), "E");
        }
    
        /**
         * 获取指定日期是星期几
         *
         * @param localDate 日期
         * @return String 星期几
         */
        public static String getDayOfWeekStr(LocalDate localDate) {
            String[] weekOfDays = {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};
            int dayOfWeek = localDate.getDayOfWeek().getValue() - 1;
            return weekOfDays[dayOfWeek];
        }
    
        /**
         * 获取日期时间字符串
         *
         * @param temporal 需要转化的日期时间
         * @param pattern  时间格式
         * @return String 日期时间字符串,例如 2015-08-11 09:51:53
         */
        public static String format(TemporalAccessor temporal, String pattern) {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
            return dateTimeFormatter.format(temporal);
        }
    
        /**
         * 日期时间字符串转换为日期时间(java.time.LocalDateTime)
         *
         * @param localDateTimeStr 日期时间字符串
         * @param pattern          日期时间格式 例如DATETIME_PATTERN
         * @return LocalDateTime 日期时间
         */
        public static LocalDateTime parseLocalDateTime(String localDateTimeStr, String pattern) {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
            return LocalDateTime.parse(localDateTimeStr, dateTimeFormatter);
        }
    
        /**
         * 日期字符串转换为日期(java.time.LocalDate)
         *
         * @param localDateStr 日期字符串
         * @param pattern      日期格式 例如DATE_PATTERN
         * @return LocalDate 日期
         */
        public static LocalDate parseLocalDate(String localDateStr, String pattern) {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
            return LocalDate.parse(localDateStr, dateTimeFormatter);
        }
    
        /**
         * 获取指定日期时间加上指定数量日期时间单位之后的日期时间.
         *
         * @param localDateTime 日期时间
         * @param num           数量
         * @param chronoUnit    日期时间单位
         * @return LocalDateTime 新的日期时间
         */
        public static LocalDateTime plus(LocalDateTime localDateTime, int num, ChronoUnit chronoUnit) {
            return localDateTime.plus(num, chronoUnit);
        }
    
        /**
         * 获取指定日期时间减去指定数量日期时间单位之后的日期时间.
         *
         * @param localDateTime 日期时间
         * @param num           数量
         * @param chronoUnit    日期时间单位
         * @return LocalDateTime 新的日期时间
         */
        public static LocalDateTime minus(LocalDateTime localDateTime, int num, ChronoUnit chronoUnit) {
            return localDateTime.minus(num, chronoUnit);
        }
    
        /**
         * 根据ChronoUnit计算两个日期时间之间相隔日期时间
         *
         * @param start      开始日期时间
         * @param end        结束日期时间
         * @param chronoUnit 日期时间单位
         * @return long 相隔日期时间
         */
        public static long getChronoUnitBetween(LocalDateTime start, LocalDateTime end, ChronoUnit chronoUnit) {
            return Math.abs(start.until(end, chronoUnit));
        }
    
        /**
         * 根据ChronoUnit计算两个日期之间相隔年数或月数或天数
         *
         * @param start      开始日期
         * @param end        结束日期
         * @param chronoUnit 日期时间单位,(ChronoUnit.YEARS,ChronoUnit.MONTHS,ChronoUnit.WEEKS,ChronoUnit.DAYS)
         * @return long 相隔年数或月数或天数
         */
        public static long getChronoUnitBetween(LocalDate start, LocalDate end, ChronoUnit chronoUnit) {
            return Math.abs(start.until(end, chronoUnit));
        }
    
        /**
         * 获取本年第一天的日期字符串
         *
         * @return String 格式:yyyy-MM-dd 00:00:00
         */
        public static String getFirstDayOfYearStr() {
            return getFirstDayOfYearStr(LocalDateTime.now());
        }
    
        /**
         * 获取本年最后一天的日期字符串
         *
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getLastDayOfYearStr() {
            return getLastDayOfYearStr(LocalDateTime.now());
        }
    
        /**
         * 获取指定日期当年第一天的日期字符串
         *
         * @param localDateTime 指定日期时间
         * @return String 格式:yyyy-MM-dd 00:00:00
         */
        public static String getFirstDayOfYearStr(LocalDateTime localDateTime) {
            return getFirstDayOfYearStr(localDateTime, DATETIME_PATTERN);
        }
    
        /**
         * 获取指定日期当年最后一天的日期字符串
         *
         * @param localDateTime 指定日期时间
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getLastDayOfYearStr(LocalDateTime localDateTime) {
            return getLastDayOfYearStr(localDateTime, DATETIME_PATTERN);
        }
    
        /**
         * 获取指定日期当年第一天的日期字符串,带日期格式化参数
         *
         * @param localDateTime 指定日期时间
         * @param pattern       日期时间格式
         * @return String 格式:yyyy-MM-dd 00:00:00
         */
        public static String getFirstDayOfYearStr(LocalDateTime localDateTime, String pattern) {
            return format(localDateTime.withDayOfYear(1).withHour(0).withMinute(0).withSecond(0), pattern);
        }
    
        /**
         * 获取指定日期当年最后一天的日期字符串,带日期格式化参数
         *
         * @param localDateTime 指定日期时间
         * @param pattern       日期时间格式
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getLastDayOfYearStr(LocalDateTime localDateTime, String pattern) {
            return format(localDateTime.with(TemporalAdjusters.lastDayOfYear()).withHour(23).withMinute(59).withSecond(59), pattern);
        }
    
        /**
         * 获取本月第一天的日期字符串
         *
         * @return String 格式:yyyy-MM-dd 00:00:00
         */
        public static String getFirstDayOfMonthStr() {
            return getFirstDayOfMonthStr(LocalDateTime.now());
        }
    
        /**
         * 获取本月最后一天的日期字符串
         *
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getLastDayOfMonthStr() {
            return getLastDayOfMonthStr(LocalDateTime.now());
        }
    
        /**
         * 获取指定日期当月第一天的日期字符串
         *
         * @param localDateTime 指定日期时间
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getFirstDayOfMonthStr(LocalDateTime localDateTime) {
            return getFirstDayOfMonthStr(localDateTime, DATETIME_PATTERN);
        }
    
        /**
         * 获取指定日期当月最后一天的日期字符串
         *
         * @param localDateTime 指定日期时间
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getLastDayOfMonthStr(LocalDateTime localDateTime) {
            return getLastDayOfMonthStr(localDateTime, DATETIME_PATTERN);
        }
    
        /**
         * 获取指定日期当月第一天的日期字符串,带日期格式化参数
         *
         * @param localDateTime 指定日期时间
         * @return String 格式:yyyy-MM-dd 00:00:00
         */
        public static String getFirstDayOfMonthStr(LocalDateTime localDateTime, String pattern) {
            return format(localDateTime.withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0), pattern);
        }
    
        /**
         * 获取指定日期当月最后一天的日期字符串,带日期格式化参数
         *
         * @param localDateTime 指定日期时间
         * @param pattern       日期时间格式
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getLastDayOfMonthStr(LocalDateTime localDateTime, String pattern) {
            return format(localDateTime.with(TemporalAdjusters.lastDayOfMonth()).withHour(23).withMinute(59).withSecond(59), pattern);
        }
    
        /**
         * 获取本周第一天的日期字符串
         *
         * @return String 格式:yyyy-MM-dd 00:00:00
         */
        public static String getFirstDayOfWeekStr() {
            return getFirstDayOfWeekStr(LocalDateTime.now());
        }
    
        /**
         * 获取本周最后一天的日期字符串
         *
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getLastDayOfWeekStr() {
            return getLastDayOfWeekStr(LocalDateTime.now());
        }
    
        /**
         * 获取指定日期当周第一天的日期字符串,这里第一天为周一
         *
         * @param localDateTime 指定日期时间
         * @return String 格式:yyyy-MM-dd 00:00:00
         */
        public static String getFirstDayOfWeekStr(LocalDateTime localDateTime) {
            return getFirstDayOfWeekStr(localDateTime, DATETIME_PATTERN);
        }
    
        /**
         * 获取指定日期当周最后一天的日期字符串,这里最后一天为周日
         *
         * @param localDateTime 指定日期时间
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getLastDayOfWeekStr(LocalDateTime localDateTime) {
            return getLastDayOfWeekStr(localDateTime, DATETIME_PATTERN);
        }
    
        /**
         * 获取指定日期当周第一天的日期字符串,这里第一天为周一,带日期格式化参数
         *
         * @param localDateTime 指定日期时间
         * @param pattern       日期时间格式
         * @return String 格式:yyyy-MM-dd 00:00:00
         */
        public static String getFirstDayOfWeekStr(LocalDateTime localDateTime, String pattern) {
            return format(localDateTime.with(DayOfWeek.MONDAY).withHour(0).withMinute(0).withSecond(0), pattern);
        }
    
        /**
         * 获取指定日期当周最后一天的日期字符串,这里最后一天为周日,带日期格式化参数
         *
         * @param localDateTime 指定日期时间
         * @param pattern       日期时间格式
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getLastDayOfWeekStr(LocalDateTime localDateTime, String pattern) {
            return format(localDateTime.with(DayOfWeek.SUNDAY).withHour(23).withMinute(59).withSecond(59), pattern);
        }
    
        /**
         * 获取今天开始时间的日期字符串
         *
         * @return String 格式:yyyy-MM-dd 00:00:00
         */
        public static String getStartTimeOfDayStr() {
            return getStartTimeOfDayStr(LocalDateTime.now());
        }
    
        /**
         * 获取今天结束时间的日期字符串
         *
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getEndTimeOfDayStr() {
            return getEndTimeOfDayStr(LocalDateTime.now());
        }
    
        /**
         * 获取指定日期开始时间的日期字符串
         *
         * @param localDateTime 指定日期时间
         * @return String 格式:yyyy-MM-dd 00:00:00
         */
        public static String getStartTimeOfDayStr(LocalDateTime localDateTime) {
            return getStartTimeOfDayStr(localDateTime, DATETIME_PATTERN);
        }
    
        /**
         * 获取指定日期结束时间的日期字符串
         *
         * @param localDateTime 指定日期时间
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getEndTimeOfDayStr(LocalDateTime localDateTime) {
            return getEndTimeOfDayStr(localDateTime, DATETIME_PATTERN);
        }
    
        /**
         * 获取指定日期开始时间的日期字符串,带日期格式化参数
         *
         * @param localDateTime 指定日期时间
         * @param pattern       日期时间格式
         * @return String 格式:yyyy-MM-dd HH:mm:ss
         */
        public static String getStartTimeOfDayStr(LocalDateTime localDateTime, String pattern) {
            return format(localDateTime.withHour(0).withMinute(0).withSecond(0), pattern);
        }
    
        /**
         * 获取指定日期结束时间的日期字符串,带日期格式化参数
         *
         * @param localDateTime 指定日期时间
         * @param pattern       日期时间格式
         * @return String 格式:yyyy-MM-dd 23:59:59
         */
        public static String getEndTimeOfDayStr(LocalDateTime localDateTime, String pattern) {
            return format(localDateTime.withHour(23).withMinute(59).withSecond(59), pattern);
        }
    
        /**
         * 切割日期。按照周期切割成小段日期段。例如: <br>
         *
         * @param startDate 开始日期(yyyy-MM-dd)
         * @param endDate   结束日期(yyyy-MM-dd)
         * @param period    周期(天,周,月,年)
         * @return 切割之后的日期集合
         * <li>startDate="2019-02-28",endDate="2019-03-05",period="day"</li>
         * <li>结果为:[2019-02-28, 2019-03-01, 2019-03-02, 2019-03-03, 2019-03-04, 2019-03-05]</li><br>
         * <li>startDate="2019-02-28",endDate="2019-03-25",period="week"</li>
         * <li>结果为:[2019-02-28,2019-03-06, 2019-03-07,2019-03-13, 2019-03-14,2019-03-20,
         * 2019-03-21,2019-03-25]</li><br>
         * <li>startDate="2019-02-28",endDate="2019-05-25",period="month"</li>
         * <li>结果为:[2019-02-28,2019-02-28, 2019-03-01,2019-03-31, 2019-04-01,2019-04-30,
         * 2019-05-01,2019-05-25]</li><br>
         * <li>startDate="2019-02-28",endDate="2020-05-25",period="year"</li>
         * <li>结果为:[2019-02-28,2019-12-31, 2020-01-01,2020-05-25]</li><br>
         */
        public static List<String> listDateStrs(String startDate, String endDate, String period) {
            List<String> result = new ArrayList<>();
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(DATE_PATTERN);
            LocalDate end = LocalDate.parse(endDate, dateTimeFormatter);
            LocalDate start = LocalDate.parse(startDate, dateTimeFormatter);
            LocalDate tmp = start;
            switch (period) {
                case DAY:
                    while (start.isBefore(end) || start.isEqual(end)) {
                        result.add(start.toString());
                        start = start.plusDays(1);
                    }
                    break;
                case WEEK:
                    while (tmp.isBefore(end) || tmp.isEqual(end)) {
                        if (tmp.plusDays(6).isAfter(end)) {
                            result.add(tmp.toString() + "," + end);
                        } else {
                            result.add(tmp.toString() + "," + tmp.plusDays(6));
                        }
                        tmp = tmp.plusDays(7);
                    }
                    break;
                case MONTH:
                    while (tmp.isBefore(end) || tmp.isEqual(end)) {
                        LocalDate lastDayOfMonth = tmp.with(TemporalAdjusters.lastDayOfMonth());
                        if (lastDayOfMonth.isAfter(end)) {
                            result.add(tmp.toString() + "," + end);
                        } else {
                            result.add(tmp.toString() + "," + lastDayOfMonth);
                        }
                        tmp = lastDayOfMonth.plusDays(1);
                    }
                    break;
                case YEAR:
                    while (tmp.isBefore(end) || tmp.isEqual(end)) {
                        LocalDate lastDayOfYear = tmp.with(TemporalAdjusters.lastDayOfYear());
                        if (lastDayOfYear.isAfter(end)) {
                            result.add(tmp.toString() + "," + end);
                        } else {
                            result.add(tmp.toString() + "," + lastDayOfYear);
                        }
                        tmp = lastDayOfYear.plusDays(1);
                    }
                    break;
                default:
                    break;
            }
            return result;
        }
    
        public static void main(String[] args) {
            System.out.println(getLocalDateTimeStr());
            System.out.println(getLocalDateStr());
            System.out.println(getLocalTimeStr());
            System.out.println(getDayOfWeekStr());
            System.out.println(getDayOfWeekStr(LocalDate.now()));
    
            System.out.println("========");
            System.out.println(format(LocalDate.now(), UNSIGNED_DATE_PATTERN));
    
            System.out.println("========");
            System.out.println(parseLocalDateTime("2020-12-13 11:14:12", DATETIME_PATTERN));
            System.out.println(parseLocalDate("2020-12-13", DATE_PATTERN));
    
            System.out.println("========");
            System.out.println(plus(LocalDateTime.now(), 3, ChronoUnit.HOURS));
            System.out.println(minus(LocalDateTime.now(), 4, ChronoUnit.DAYS));
    
            System.out.println("========");
            System.out.println(getChronoUnitBetween(LocalDateTime.now(), parseLocalDateTime("2020-12-12 12:03:12", DATETIME_PATTERN), ChronoUnit.MINUTES));
            System.out.println(getChronoUnitBetween(LocalDate.now(), parseLocalDate("2021-12-12", DATE_PATTERN), ChronoUnit.WEEKS));
    
            System.out.println("========");
            System.out.println(getFirstDayOfYearStr());
            System.out.println(getFirstDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
            System.out.println(getFirstDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
    
            System.out.println(getLastDayOfYearStr());
            System.out.println(getLastDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
            System.out.println(getLastDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
    
            System.out.println("========");
            System.out.println(getFirstDayOfMonthStr());
            System.out.println(getFirstDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
            System.out.println(getFirstDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
    
            System.out.println(getLastDayOfMonthStr());
            System.out.println(getLastDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
            System.out.println(getLastDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
    
            System.out.println("========");
            System.out.println(getFirstDayOfWeekStr());
            System.out.println(getFirstDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
            System.out.println(getFirstDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
    
            System.out.println(getLastDayOfWeekStr());
            System.out.println(getLastDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
            System.out.println(getLastDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
    
            System.out.println("========");
            System.out.println(getStartTimeOfDayStr());
            System.out.println(getStartTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
            System.out.println(getStartTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
    
            System.out.println(getEndTimeOfDayStr());
            System.out.println(getEndTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
            System.out.println(getEndTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
    
            System.out.println("========");
            List<String> dateStrs = listDateStrs("2019-01-30", "2020-12-13", YEAR);
            for (String dateStr : dateStrs) {
                System.out.println(dateStr);
            }
    
            System.out.println("========");
            List<String> dateStrs1 = listDateStrs("2019-01-30", "2020-12-13", MONTH);
            for (String dateStr : dateStrs1) {
                System.out.println(dateStr);
            }
    
            System.out.println("========");
            List<String> dateStrs2 = listDateStrs("2020-12-01", "2020-12-13", DAY);
            for (String dateStr : dateStrs2) {
                System.out.println(dateStr);
            }
        }
    
    }
    
    展开全文
  • java8日期时间API(一)

    千次阅读 2017-10-17 23:28:55
    java8日期时间

    为什么我们需要新的Java日期/时间API?

    • Java的日期/时间类的定义并不一致,在java.util和java.sql的包中都有日期累,此外用于格式化和解析的类在java.text包中定义。

    • java.util.Date同时包含日期和时间,而java.sql.Date仅包含日期,将其纳入java.sql并不合理。

    • 对于时间、时间戳、格式化以及解析,并没有明确定义的类。对于格式化和解析的需求,有java.text.DateFormat抽象类,但通常情况下,SimpleDateFormat类被用于此类需求。

    • 日期类国际化支持的并不是很好。

    Java8日期/时间API

    • 不变性:新的日期/时间API中,所有的类都是不可变的,这对多线程环境有好处。

    • 关注点分离:新的API将人可读的日期时间和机器时间(unix timestamp)明确分离,它为日期(Date)、时间(Time)、日期时间(DateTime)、时间戳(unix timestamp)以及时区定义了不同的类。

    • 清晰:在所有的类中,方法都被明确定义用以完成相同的行为。举个例子,要拿到当前实例我们可以使用now()方法,在所有的类中都定义了format()和parse()方法,而不是像以前那样专门有一个独立的类。为了更好的处理问题,所有的类都使用了工厂模式和策略模式,一旦你使用了其中某个类的方法,与其他类协同工作并不困难。

    • 实用操作:所有新的日期/时间API类都实现了一系列方法用以完成通用的任务,如:加、减、格式化、解析、从日期/时间中提取单独部分,等等。

    Java日期/时间API包

    Java日期/时间API包含以下相应的包。

    • java.time包:这是新的Java日期/时间API的基础包,所有的主要基础类都是这个包的一部分,如:LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration等等。所有这些类都是不可变的和线程安全的,在绝大多数情况下,这些类能够有效地处理一些公共的需求。

    • java.time.chrono包:这个包为非ISO的日历系统定义了一些泛化的API,我们可以扩展AbstractChronology类来创建自己的日历系统。
      java.time.format包:这个包包含能够格式化和解析日期时间对象的类,在绝大多数情况下,我们不应该直接使用它们,因为java.time包中相应的类已经提供了格式化和解析的方法。

    • java.time.temporal包:这个包包含一些时态对象,我们可以用其找出关于日期/时间对象的某个特定日期或时间,比如说,可以找到某月的第一天或最后一天。你可以非常容易地认出这些方法,因为它们都具有“withXXX”的格式。

    • java.time.zone包:这个包包含支持不同时区以及相关规则的类

    Java日期/时间API示例

    java.time.LocalDate

    LocalDate是一个不可变的类,它表示默认格式(yyyy-MM-dd)的日期,

    public static void main(String[] args) {
            // 当前日期yyyy-MM-dd
            LocalDate localDate1 = LocalDate.now();
            System.out.println(localDate1);
            // 创建一个日期
            LocalDate localDate2 = LocalDate.of(2017, 10, 17);
            System.out.println(localDate2);
            // 获取指定时区的当前时间
            LocalDate localDate3 = LocalDate.now(ZoneId.of("Asia/Kolkata"));
            System.out.println(localDate3);
            // 格林威治时间+天数
            LocalDate localDate4 = LocalDate.ofEpochDay(365);
            System.out.println(localDate4);
            // 某年的第几天的日期
            LocalDate localDate5 = LocalDate.ofYearDay(2017, 200);
            System.out.println(localDate5);
        }

    java.time.LocalTime

    LocalTime是一个不可变的类,它的实例代表一个符合人类可读格式的时间,默认格式是hh:mm:ss.zzz。

    public static void main(String[] args) {
            //当前时间
            LocalTime time = LocalTime.now();
            System.out.println("Current Time="+time);
    
            // 创建当前时间
            LocalTime specificTime = LocalTime.of(12,20,25,40);
            System.out.println("Specific Time of Day="+specificTime);
    
            // 获取指定时区当前时间
            LocalTime timeKolkata = LocalTime.now(ZoneId.of("Asia/Kolkata"));
            System.out.println("Current Time in IST="+timeKolkata);
    
            // 当天多少秒的时间
            LocalTime specificSecondTime = LocalTime.ofSecondOfDay(10000);
            System.out.println("10000th second time= "+specificSecondTime);
        }

    java.time.LocalDateTime

    LocalDateTime是一个不可变的日期-时间对象,它表示一组日期-时间,默认格式是yyyy-MM-dd-HH-mm-ss.zzz。它提供了一个工厂方法,接收LocalDate和LocalTime输入参数,创建LocalDateTime实例。

    public static void main(String[] args) {
            // 当前日期时间
            LocalDateTime today = LocalDateTime.now();
            System.out.println("Current DateTime="+today);
    
            // 当前日期时间
            today = LocalDateTime.of(LocalDate.now(), LocalTime.now());
            System.out.println("Current DateTime="+today);
    
            // 指定时间日期时间
            LocalDateTime specificDate = LocalDateTime.of(2014, Month.JANUARY, 1, 10, 10, 30);
            System.out.println("Specific Date="+specificDate);
    
            // 当前指定时区日期时间
            LocalDateTime todayKolkata = LocalDateTime.now(ZoneId.of("Asia/Kolkata"));
            System.out.println("Current Date in IST="+todayKolkata);
    
            // 格林威治后多少分钟的日期时间
            LocalDateTime dateFromBase = LocalDateTime.ofEpochSecond(10000, 0, ZoneOffset.UTC);
            System.out.println("10000th second time from 01/01/1970= "+dateFromBase);
        }

    java.time.Instant

    Instant类是用在机器可读的时间格式上的,它以Unix时间戳的形式存储日期时间。

    public static void main(String[] args) {
            // 当前时间戳
            Instant timestamp = Instant.now();
            System.out.println("Current Timestamp = "+timestamp); // Current Timestamp = 2017-10-17T15:10:50.064Z
    
            Instant specificTime = Instant.ofEpochMilli(timestamp.toEpochMilli()); // Specific Time = 2017-10-17T15:10:50.064Z
            System.out.println("Specific Time = "+specificTime);
    
            Duration thirtyDay = Duration.ofDays(30);
            System.out.println(thirtyDay); // PT720H
        }

    日期API工具

    大多数日期/时间API类都实现了一系列工具方法,如:加/减天数、周数、月份数,等等。还有其他的工具方法能够使用TemporalAdjuster调整日期,并计算两个日期间的周期。

    public static void main(String[] args) {
            LocalDate today = LocalDate.now();
            // 根据当前日期获取其他日期
            // 闰年
            System.out.println("Year "+today.getYear()+" is Leap Year? "+today.isLeapYear());
            // 在某个日期之前
            System.out.println("Today is before 01/01/2015? "+today.isBefore(LocalDate.of(2015,1,1)));
            // 根据LocalDate创建LocalDateTime
            System.out.println("Current Time="+today.atTime(LocalTime.now()));
            // 加多少天 多少周 多少月
            System.out.println("10 days after today will be "+today.plusDays(10));
            System.out.println("3 weeks after today will be "+today.plusWeeks(3));
            System.out.println("20 months after today will be "+today.plusMonths(20));
            // 减多少天 多少周 多少月
            System.out.println("10 days before today will be "+today.minusDays(10));
            System.out.println("3 weeks before today will be "+today.minusWeeks(3));
            System.out.println("20 months before today will be "+today.minusMonths(20));
            // 当天月第一天日期
            System.out.println("First date of this month= "+today.with(TemporalAdjusters.firstDayOfMonth()));
            // 当天年最后一天日期
            LocalDate lastDayOfYear = today.with(TemporalAdjusters.lastDayOfYear());
            System.out.println("Last date of this year= "+lastDayOfYear);
    

    旧的日期时间支持

    旧的日期/时间类已经在几乎所有的应用程序中使用,因此做到向下兼容是必须的。这也是为什么会有若干工具方法帮助我们将旧的类转换为新的类,反之亦然。

    public static void main(String[] args) {
    
            //Date to Instant
            Instant timestamp = new Date().toInstant();
            //Now we can convert Instant to LocalDateTime or other similar classes
            LocalDateTime date = LocalDateTime.ofInstant(timestamp, 
                            ZoneId.of(ZoneId.SHORT_IDS.get("PST")));
            System.out.println("Date = "+date);
    
            //Calendar to Instant
            Instant time = Calendar.getInstance().toInstant();
            System.out.println(time);
            //TimeZone to ZoneId
            ZoneId defaultZone = TimeZone.getDefault().toZoneId();
            System.out.println(defaultZone);
    
            //ZonedDateTime from specific Calendar
            ZonedDateTime gregorianCalendarDateTime = new GregorianCalendar().toZonedDateTime();
            System.out.println(gregorianCalendarDateTime);
    
            //Date API to Legacy classes
            Date dt = Date.from(Instant.now());
            System.out.println(dt);
    
            TimeZone tz = TimeZone.getTimeZone(defaultZone);
            System.out.println(tz);
    
            GregorianCalendar gc = GregorianCalendar.from(gregorianCalendarDateTime);
            System.out.println(gc);
    
        }
    

    Date与LocalDateTime、LocalDate、LocalTime互转

    // 01. java.util.Date --> java.time.LocalDateTime
    public void UDateToLocalDateTime() {
        java.util.Date date = new java.util.Date();
        Instant instant = date.toInstant();
        ZoneId zone = ZoneId.systemDefault();
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
    }
    
    // 02. java.util.Date --> java.time.LocalDate
    public void UDateToLocalDate() {
        java.util.Date date = new java.util.Date();
        Instant instant = date.toInstant();
        ZoneId zone = ZoneId.systemDefault();
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
        LocalDate localDate = localDateTime.toLocalDate();
    }
    
    // 03. java.util.Date --> java.time.LocalTime
    public void UDateToLocalTime() {
        java.util.Date date = new java.util.Date();
        Instant instant = date.toInstant();
        ZoneId zone = ZoneId.systemDefault();
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
        LocalTime localTime = localDateTime.toLocalTime();
    }
    
    
    // 04. java.time.LocalDateTime --> java.util.Date
    public void LocalDateTimeToUdate() {
        LocalDateTime localDateTime = LocalDateTime.now();
        ZoneId zone = ZoneId.systemDefault();
        Instant instant = localDateTime.atZone(zone).toInstant();
        java.util.Date date = Date.from(instant);
    }
    
    
    // 05. java.time.LocalDate --> java.util.Date
    public void LocalDateToUdate() {
        LocalDate localDate = LocalDate.now();
        ZoneId zone = ZoneId.systemDefault();
        Instant instant = localDate.atStartOfDay().atZone(zone).toInstant();
        java.util.Date date = Date.from(instant);
    }
    
    // 06. java.time.LocalTime --> java.util.Date
    public void LocalTimeToUdate() {
        LocalTime localTime = LocalTime.now();
        LocalDate localDate = LocalDate.now();
        LocalDateTime localDateTime = LocalDateTime.of(localDate, localTime);
        ZoneId zone = ZoneId.systemDefault();
        Instant instant = localDateTime.atZone(zone).toInstant();
        java.util.Date date = Date.from(instant);
    }
    展开全文
  • java8日期时间API

    2020-06-16 22:03:08
    java8日期时间API 为什么要使用java8的日期时间API,因为以前用的Date,Calendar都是线程不安全的! 演示线程不安全 public class TestSimpleDateFormat { /** * 使用之前的时间API,会发生线程不安全的问题...
  • Java8日期时间API作业 Java8日期时间API的课后作业 根据说明分别实现 根据MeetingSystemV3的说明在脑洞会议系统v2.0的基础上实现新增需求
  • 说明 日期 年月日如何确定?...  java8日期时间api,实现了jsr310, 新api的设计原则是清晰,流式,不可变对象(线程安全),可扩展。关于api的使用网上有很多,这里就不再赘述。本文说一日期时间相关...
  • import java.time.*; import java.time.format.DateTimeFormatter; import java.time.temporal.ChronoUnit; import java.util.Date; /** ... * @Description java8日期时间处理工具类 * @Author ...
  • Temporal 是java8日期时间框架的一个接口 , Instant , LocalDate , LocalTime , LocalDateTime , ZonedDateTime ,OffsetDateTime都implements了它, Temporal 的一些实现类 public final class Instant
  • Java8日期时间API

    千次阅读 多人点赞 2020-12-12 23:56:51
    文章目录Java 8以前日期时间API存在的问题关于时间和时区GMT和UTC时区Unix时间戳Java 中的 Unix 时间LocalDate、LocalTime、LocalDateTime获取对象的方法常用方法与获取相关的方法(get系类的方法)转换的方法判断的...
  • Java8日期时间用法

    2021-04-25 19:00:47
    Java8增加了新的日期和时间类:LocalDate、LocalTime、Instant、Duration 以及 Period,这些类都包含在 java.time包中。新API基于ISO标准日历系统,java.time包下的所有类都是不可变类型而且线程安全。 Java8提供的...
  • java8日期时间api

    2021-04-26 22:07:31
    鉴于之前的java的时间工具类很不好用,java8给出了localDateTime,localDate,localTime这3个工具类用于处理时间。在mybatis中也可以把date转换为localDateTime,这个可以参照我之前的文章。 localDateTime使用例子 ...
  • public class Java8日期时间时区toString查看 { public static void pln(Object o) { System.out.println(o.getClass().getSimpleName()+" 的toString()样式="+o); } public static void main(String ...
  • java8日期时间相关

    2020-02-23 22:58:16
    java8时间相关api一. java8时间相关api出现的原因二. LocalDate, LocalTime, LocalDateTime的使用1. 解释:2. 学习点:3. 代码示例三. Instant1. 解释2. 学习点3. 代码示例四. DateTimeFormatter 日期格式化类1. 解释:...
  • Java8日期时间API详解

    2020-10-30 17:34:07
    Java8已经发布很长时间了,但是仍然有很多小伙伴不熟悉Java8的日期时间API。今天我们来一起学习一下。 首先了解几个概念,也就是日期时间在Java中所体现的几种形式,这几种形式是可以相互转换的。: 时间戳: long ...
  • 一、大厂如何使用Java8日期时间? Java8前,处理日期时间时,使用的“三大件” Date Calender SimpleDateFormat 以声明时间戳、使用日历处理日期和格式化解析日期时间。但这些类的API可读性差、使用繁琐,且非线程...
  • Java8中的时间日期API,LocalDateTime、LocalDate、LocalTime 工作这么久了,对于Java中时间日期的操作一直很蛋疼,一会用Date,...一,Java8日期时间API产生的前因后果 1.1 为什么要重新定义一套日期时间API ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 465
精华内容 186
关键字:

java8日期时间

java 订阅