jdk1.8日期util类

    简单学习了jdk1.8 java.time包下的时间日期类，编写了常用的DateUtil
    由于类似学习博客很多很全，我也不在过多赘述
    [我学习的博客地址](http://www.jianshu.com/p/19bd58b30660)

package com.ygy.test.date;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;

/**
 * Created by guoyao on 2017/4/26.
 jdk1.8 日期工具类
 */
public class DateUtil {

    //  本util涉及zoneId 都采用系统默认的时区
    private static final ZoneId ZONE_ID_SYSTEM_DEFAULT=ZoneId.systemDefault();

    /** 常用日期格式 **/
    public final static String FORMAT_YYYYMMDD="yyyyMMdd";

    public final static String FORMAT_YYYYMMDDHHMMSS="yyyyMMddHHmmss";

    public final static String DATE_FORMAT="yyyy-MM-dd";

    public final static String SHORT_DATE_FORMAT="MM-dd";

    public final static String SHORT_TIME_FORMAT="HH:mm";



    /**
     * 将指定的时间日期类转为指定格式的String
     * LocalDateTime  yyyy MM dd HH mm ss
     * LocalDate     yyyy MM dd
     * LocalTime     HH mm ss
     * @param temporalAccessor 共同接口
     * @param pattern          自定义转化格式
     * @return
     */
    public static String format(TemporalAccessor temporalAccessor, String pattern) {
        if (temporalAccessor == null) {
            return "";
        }
        DateTimeFormatter formatter=getFormatter(pattern);
        if (formatter != null) {
            return formatter.format(temporalAccessor);
        }
        return "";
    }

    /**
     * 获取日期时间转换器
     * @param pattern 自定义转化格式
     * @return
     */
    public static DateTimeFormatter getFormatter(String pattern) {
        if (isEmpty(pattern)) {
            return null;
        }
        DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ofPattern(pattern);
        return dateTimeFormatter;
    }

    /**
     * 由毫秒值获取默认zoneId的日期时间
     * @param timMillion 时间毫秒值
     * @return
     */
    public static LocalDateTime getDateTime(long timMillion) {
        Instant instant=Instant.ofEpochMilli(timMillion);
        return LocalDateTime.ofInstant(instant, ZONE_ID_SYSTEM_DEFAULT);
    }

    /**
     * 由指定日期时间获默认zoneId取毫秒值
     * @param localDateTime 日期时间
     * @return
     */
    public static long getTimeMillion(LocalDateTime localDateTime) {
        Instant instant=localDateTime.atZone(ZONE_ID_SYSTEM_DEFAULT).toInstant();
        return instant.toEpochMilli();
    }



    /**
     * 将String按照自定格式转化为 LocalDateTime
     * @param dateStr
     * @param pattern
     * @return
     */
    public static LocalDateTime parseDateTime(String dateStr, String pattern) {
        if (isEmpty(dateStr)) {
            return null;
        }
        DateTimeFormatter formatter=getFormatter(pattern);
        if (formatter == null) {
            return null;
        }
        return LocalDateTime.parse(dateStr, formatter);
    }

    /**
     * 将String按照自定格式转化为 LocalDate
     * @param dateStr
     * @param pattern
     * @return
     */
    public static LocalDate parseDate(String dateStr, String pattern) {
        if (isEmpty(dateStr)) {
            return null;
        }
        DateTimeFormatter formatter=getFormatter(pattern);
        if (formatter == null) {
            return null;
        }
        return LocalDate.parse(dateStr, formatter);
    }

    /**
     * 将String按照自定格式转化为 LocalTime
     * @param dateStr
     * @param pattern
     * @return
     */
    public static LocalTime parseTime(String dateStr, String pattern) {
        if (isEmpty(dateStr)) {
            return null;
        }
        DateTimeFormatter formatter=getFormatter(pattern);
        if (formatter == null) {
            return null;
        }
        return LocalTime.parse(dateStr, formatter);
    }

    /**
     * 计算两个时间类的差值（天 小时 分钟 秒 毫秒）LocalDateTime LocalDate LocalTime
     * @param begin 共同接口
     * @param end   共同接口
     * @param type  差值类型（天 小时 分钟 秒 毫秒）
     * @return
     */
    public static Long diffDate(Temporal begin, Temporal end, Type type) {
        Duration duration=Duration.between(begin, end);
        if (type == Type.DAY) {//天
            return duration.toDays();
        } else if (type == Type.HOUR) {//小时
            return duration.toHours();
        } else if (type == Type.MINUTE) {//分钟
            return duration.toMinutes();
        } else if (type == Type.SECOND) {//秒
            return duration.toMillis() / 1000;
        } else {
            return duration.toMillis(); //return 毫秒值
        }
    }

    /**
     * 格式化显示时间
     * 1小时内:刚刚
     * 1<x≤24:小时前
     * ≥24:MM月dd日
     * @param dateTime
     * @return
     */
    public static String timeTips(LocalDateTime dateTime) {
        //取服务端当前时间
        LocalDateTime now=getDateTime(System.currentTimeMillis());
        long diff= diffDate(dateTime, now, Type.HOUR);
        String result="";
        if (diff < 1 && diff >= 0) {
            result="刚刚";
        } else if (diff >= 1 && diff < 24) {
            //final int hour = (int)(diff*1.0f/60);
            result=String.valueOf(diff).concat("小时前");
        } else {
            result=format(dateTime, "MM月dd日");
        }
        return result;
    }


    private static boolean isEmpty(String str) {
        return (str == null || str.trim().isEmpty());
    }

    /**
     * 时间差类型
     */
    public enum Type {
        DAY, HOUR, MINUTE, SECOND, MILLIS
    }

    public static void main(String[] args) {
        // 测试format
        System.out.println(format(LocalDate.now(), "yyyy/MM/dd")); //2017/04/26
        System.out.println(format(LocalDateTime.now(), "yyyy/MM/dd HH:mm:ss"));//2017/04/26 23:31:05
        System.out.println(format(LocalTime.now(), "HH:mm:ss"));//23:31:05

        // 测试毫秒值
        System.out.println(getTimeMillion(LocalDateTime.now().withNano(0)));//1493220665000
        System.out.println(getDateTime(getTimeMillion(LocalDateTime.now().withNano(0)) + 10000));//2017-04-26T23:31:15

        //测试转换
        System.out.println(parseDateTime("20170612091411", "yyyyMMddHHmmss"));//2017-06-12T09:14:11
        System.out.println(parseDate("2017-04-26", "yyyy-MM-dd"));//2017-04-26
        System.out.println(parseTime("15:14:11", "HH:mm:ss"));//15:14:11

        //算差值
        System.out.println(diffDate(LocalTime.now(), LocalTime.now().plusSeconds(1), Type.HOUR));

        //时间格式化
        System.out.println(timeTips(LocalDateTime.now().minusHours(2)));
    }


}