时间工具类

[java]代码库
import java.math.BigDecimal;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.*;
 
import org.hibernate.validator.cfg.defs.MinDef;
 
/**
 * Description : 日期工具类
 * Author : miaozh
 * CreateTime : 2016年10月8日 下午4:38:19
 */
public class DateUtils {
 
    private static final ThreadLocal<SimpleDateFormat> threadLocal = new ThreadLocal<SimpleDateFormat>();
 
    private static final Object object = new Object();
 
    /**
     * 获取SimpleDateFormat
     * @param pattern 日期格式
     * @return SimpleDateFormat对象
     * @throws RuntimeException 异常：非法日期格式
     */
    public static SimpleDateFormat getDateFormat(String pattern)
            throws RuntimeException {
        SimpleDateFormat dateFormat = threadLocal.get();
        if (dateFormat == null) {
            synchronized (object) {
                if (dateFormat == null) {
                    dateFormat = new SimpleDateFormat(pattern);
                    dateFormat.setLenient(false);
                    threadLocal.set(dateFormat);
                }
            }
        }
        dateFormat.applyPattern(pattern);
        return dateFormat;
    }
 
    /**
     * 获取日期中的某数值。如获取月份
     * @param date 日期
     * @param dateType 日期格式
     * @return 数值
     */
    private static int getInteger(Date date, int dateType) {
        int num = 0;
        Calendar calendar = Calendar.getInstance();
        if (date != null) {
            calendar.setTime(date);
            num = calendar.get(dateType);
        }
        return num;
    }
 
    /**
     * 增加日期中某类型的某数值。如增加日期
     * @param date 日期字符串
     * @param dateType 类型
     * @param amount 数值
     * @return 计算后日期字符串
     */
    private static String addInteger(String date, int dateType, int amount) {
        String dateString = null;
        DateStyle dateStyle = getDateStyle(date);
        if (dateStyle != null) {
            Date myDate = StringToDate(date, dateStyle);
            myDate = addInteger(myDate, dateType, amount);
            dateString = DateToString(myDate, dateStyle);
        }
        return dateString;
    }
 
    /**
     * 增加日期中某类型的某数值。如增加日期
     * @param date 日期
     * @param dateType 类型
     * @param amount 数值
     * @return 计算后日期
     */
    private static Date addInteger(Date date, int dateType, int amount) {
        Date myDate = null;
        if (date != null) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(dateType, amount);
            myDate = calendar.getTime();
        }
        return myDate;
    }
 
    /**
     * 获取精确的日期
     * @param timestamps 时间long集合
     * @return 日期
     */
    private static Date getAccurateDate(List<Long> timestamps) {
        Date date = null;
        long timestamp = 0;
        Map<Long, long[]> map = new HashMap<Long, long[]>();
        List<Long> absoluteValues = new ArrayList<Long>();
 
        if (timestamps != null && timestamps.size() > 0) {
            if (timestamps.size() > 1) {
                for (int i = 0; i < timestamps.size(); i++) {
                    for (int j = i + 1; j < timestamps.size(); j++) {
                        long absoluteValue = Math.abs(timestamps.get(i)
                                - timestamps.get(j));
                        absoluteValues.add(absoluteValue);
                        long[] timestampTmp = { timestamps.get(i),
                                timestamps.get(j) };
                        map.put(absoluteValue, timestampTmp);
                    }
                }
 
                // 有可能有相等的情况。如2012-11和2012-11-01。时间戳是相等的。此时minAbsoluteValue为0
                // 因此不能将minAbsoluteValue取默认值0
                long minAbsoluteValue = -1;
                if (!absoluteValues.isEmpty()) {
                    minAbsoluteValue = absoluteValues.get(0);
                    for (int i = 1; i < absoluteValues.size(); i++) {
                        if (minAbsoluteValue > absoluteValues.get(i)) {
                            minAbsoluteValue = absoluteValues.get(i);
                        }
                    }
                }
 
                if (minAbsoluteValue != -1) {
                    long[] timestampsLastTmp = map.get(minAbsoluteValue);
 
                    long dateOne = timestampsLastTmp[0];
                    long dateTwo = timestampsLastTmp[1];
                    if (absoluteValues.size() > 1) {
                        timestamp = Math.abs(dateOne) > Math.abs(dateTwo) ? dateOne
                                : dateTwo;
                    }
                }
            } else {
                timestamp = timestamps.get(0);
            }
        }
 
        if (timestamp != 0) {
            date = new Date(timestamp);
        }
        return date;
    }
 
    /**
     * 根据开始时间和结束时间获取间隔的时间（单位/小时）
     * @param startTime
     * @param endTime
     * @return
     */
    public static Double getIntervalHours(String startTime, String endTime){
        BigDecimal startTimeStamp = BigDecimal.valueOf(DateUtils.StringToDate(startTime, DateStyle.HH_MM_SS).getTime());
        BigDecimal endTimeStamp = BigDecimal.valueOf(DateUtils.StringToDate(endTime, DateStyle.HH_MM_SS).getTime());
        BigDecimal hours = endTimeStamp.subtract(startTimeStamp).divide(new BigDecimal(1000*60*60), 2, BigDecimal.ROUND_DOWN);
        return hours.doubleValue();
    }
 
    /**
     * 判断字符串是否为日期字符串
     * @param date 日期字符串
     * @return true or false
     */
    public static boolean isDate(String date) {
        boolean isDate = false;
        if (date != null) {
            if (getDateStyle(date) != null) {
                isDate = true;
            }
        }
        return isDate;
    }
 
    /**
     * 获取日期字符串的日期风格。失敗返回null。
     * @param date 日期字符串
     * @return 日期风格
     */
    public static DateStyle getDateStyle(String date) {
        DateStyle dateStyle = null;
        Map<Long, DateStyle> map = new HashMap<Long, DateStyle>();
        List<Long> timestamps = new ArrayList<Long>();
        for (DateStyle style : DateStyle.values()) {
            if (style.isShowOnly()) {
                continue;
            }
            Date dateTmp = null;
            if (date != null) {
                try {
                    ParsePosition pos = new ParsePosition(0);
                    dateTmp = getDateFormat(style.getValue()).parse(date, pos);
                    if (pos.getIndex() != date.length()) {
                        dateTmp = null;
                    }
                } catch (Exception e) {
                }
            }
            if (dateTmp != null) {
                timestamps.add(dateTmp.getTime());
                map.put(dateTmp.getTime(), style);
            }
        }
        Date accurateDate = getAccurateDate(timestamps);
        if (accurateDate != null) {
            dateStyle = map.get(accurateDate.getTime());
        }
        return dateStyle;
    }
 
    /**
     * 将日期字符串转化为日期。失败返回null。
     * @param date 日期字符串
     * @return 日期
     */
    public static Date StringToDate(String date) {
        DateStyle dateStyle = getDateStyle(date);
        return StringToDate(date, dateStyle);
    }
 
    /**
     * 将日期字符串转化为日期。失败返回null。
     * @param date 日期字符串
     * @param pattern 日期格式
     * @return 日期
     */
    public static Date StringToDate(String date, String pattern) {
        Date myDate = null;
        if (date != null) {
            try {
                myDate = getDateFormat(pattern).parse(date);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return myDate;
    }
 
 
    /**
     * 将日期字符串转化为日期。失败返回null。
     * @param date 日期字符串
     * @param dateStyle 日期风格
     * @return 日期
     */
    public static Date StringToDate(String date, DateStyle dateStyle) {
        Date myDate = null;
        if (dateStyle != null) {
            myDate = StringToDate(date, dateStyle.getValue());
        }
        return myDate;
    }
 
    /**
     * 将日期转化为日期字符串。失败返回null。
     * @param date 日期
     * @param pattern 日期格式
     * @return 日期字符串
     */
    public static String DateToString(Date date, String pattern) {
        String dateString = null;
        if (date != null) {
            try {
                dateString = getDateFormat(pattern).format(date);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return dateString;
    }
 
    /**
     * 将日期转化为日期字符串。失败返回null。
     * @param date 日期
     * @param dateStyle 日期风格
     * @return 日期字符串
     */
    public static String DateToString(Date date, DateStyle dateStyle) {
        String dateString = null;
        if (dateStyle != null) {
            dateString = DateToString(date, dateStyle.getValue());
        }
        return dateString;
    }
 
    /**
     * 将日期字符串转化为另一日期字符串。失败返回null。
     * @param date 旧日期字符串
     * @param newPattern 新日期格式
     * @return 新日期字符串
     */
    public static String StringToString(String date, String newPattern) {
        DateStyle oldDateStyle = getDateStyle(date);
        return StringToString(date, oldDateStyle, newPattern);
    }
 
    /**
     * 将日期字符串转化为另一日期字符串。失败返回null。
     * @param date 旧日期字符串
     * @param newDateStyle 新日期风格
     * @return 新日期字符串
     */
    public static String StringToString(String date, DateStyle newDateStyle) {
        DateStyle oldDateStyle = getDateStyle(date);
        return StringToString(date, oldDateStyle, newDateStyle);
    }
 
    /**
     * 将日期字符串转化为另一日期字符串。失败返回null。
     * @param date 旧日期字符串
     * @param olddPattern 旧日期格式
     * @param newPattern 新日期格式
     * @return 新日期字符串
     */
    public static String StringToString(String date, String olddPattern,
            String newPattern) {
        return DateToString(StringToDate(date, olddPattern), newPattern);
    }
 
    /**
     * 将日期字符串转化为另一日期字符串。失败返回null。
     * @param date 旧日期字符串
     * @param olddDteStyle 旧日期风格
     * @param newParttern 新日期格式
     * @return 新日期字符串
     */
    public static String StringToString(String date, DateStyle olddDteStyle,
            String newParttern) {
        String dateString = null;
        if (olddDteStyle != null) {
            dateString = StringToString(date, olddDteStyle.getValue(),
                    newParttern);
        }
        return dateString;
    }
 
    /**
     * 将日期字符串转化为另一日期字符串。失败返回null。
     * @param date 旧日期字符串
     * @param olddPattern 旧日期格式
     * @param newDateStyle 新日期风格
     * @return 新日期字符串
     */
    public static String StringToString(String date, String olddPattern,
            DateStyle newDateStyle) {
        String dateString = null;
        if (newDateStyle != null) {
            dateString = StringToString(date, olddPattern,
                    newDateStyle.getValue());
        }
        return dateString;
    }
 
    /**
     * 将日期字符串转化为另一日期字符串。失败返回null。
     * @param date 旧日期字符串
     * @param olddDteStyle 旧日期风格
     * @param newDateStyle 新日期风格
     * @return 新日期字符串
     */
    public static String StringToString(String date, DateStyle olddDteStyle,
            DateStyle newDateStyle) {
        String dateString = null;
        if (olddDteStyle != null && newDateStyle != null) {
            dateString = StringToString(date, olddDteStyle.getValue(),
                    newDateStyle.getValue());
        }
        return dateString;
    }
 
    /**
     * 格式化时间
     * @param date
     * @param dateStyle
     * @return 时间
     */
    public static Date dateForMat(Date date, DateStyle dateStyle){
        return StringToDate(DateToString(date, dateStyle),dateStyle);
    }
 
    /**
     * 增加日期的年份。失败返回null。
     * @param date 日期
     * @param yearAmount 增加数量。可为负数
     * @return 增加年份后的日期字符串
     */
    public static String addYear(String date, int yearAmount) {
        return addInteger(date, Calendar.YEAR, yearAmount);
    }
 
    /**
     * 增加日期的值。失败返回null。
     * @param date 日期
     * @param type 添加的类型 年、月、日、时、分、秒
     * @param amount 增加数量
     * @return
     */
    public static Date add (Date date,int type ,int amount) {
        return addInteger(date, type , amount);
    }
 
    /**
     * 增加日期的年份。失败返回null。
     * @param date 日期
     * @param yearAmount 增加数量。可为负数
     * @return 增加年份后的日期
     */
    public static Date addYear(Date date, int yearAmount) {
        return addInteger(date, Calendar.YEAR, yearAmount);
    }
 
    /**
     * 增加日期的月份。失败返回null。
     * @param date 日期
     * @param monthAmount 增加数量。可为负数
     * @return 增加月份后的日期字符串
     */
    public static String addMonth(String date, int monthAmount) {
        return addInteger(date, Calendar.MONTH, monthAmount);
    }
 
    /**
     * 增加日期的月份。失败返回null。
     * @param date 日期
     * @param monthAmount 增加数量。可为负数
     * @return 增加月份后的日期
     */
    public static Date addMonth(Date date, int monthAmount) {
        return addInteger(date, Calendar.MONTH, monthAmount);
    }
 
    /**
     * 增加日期的天数。失败返回null。
     * @param date 日期字符串
     * @param dayAmount 增加数量。可为负数
     * @return 增加天数后的日期字符串
     */
    public static String addDay(String date, int dayAmount) {
        return addInteger(date, Calendar.DATE, dayAmount);
    }
 
    /**
     * 增加日期的天数。失败返回null。
     * @param date 日期
     * @param dayAmount 增加数量。可为负数
     * @return 增加天数后的日期
     */
    public static Date addDay(Date date, int dayAmount) {
        return addInteger(date, Calendar.DATE, dayAmount);
    }
 
    /**
     * 增加日期的小时。失败返回null。
     * @param date 日期字符串
     * @param hourAmount 增加数量。可为负数
     * @return 增加小时后的日期字符串
     */
    public static String addHour(String date, int hourAmount) {
        return addInteger(date, Calendar.HOUR_OF_DAY, hourAmount);
    }
 
    /**
     * 增加日期的小时。失败返回null。
     * @param date 日期
     * @param hourAmount 增加数量。可为负数
     * @return 增加小时后的日期
     */
    public static Date addHour(Date date, int hourAmount) {
        return addInteger(date, Calendar.HOUR_OF_DAY, hourAmount);
    }
 
    /**
     * 增加日期的分钟。失败返回null。
     * @param date 日期字符串
     * @param minuteAmount 增加数量。可为负数
     * @return 增加分钟后的日期字符串
     */
    public static String addMinute(String date, int minuteAmount) {
        return addInteger(date, Calendar.MINUTE, minuteAmount);
    }
 
    /**
     * 增加日期的分钟。失败返回null。
     * @param date 日期
     * @param minuteAmount 增加数量。可为负数
     * @return 增加分钟后的日期
     */
    public static Date addMinute(Date date, int minuteAmount) {
        return addInteger(date, Calendar.MINUTE, minuteAmount);
    }
 
    /**
     * 增加日期的秒钟。失败返回null。
     * @param date 日期字符串
     * @param secondAmount 增加数量。可为负数
     * @return 增加秒钟后的日期字符串
     */
    public static String addSecond(String date, int secondAmount) {
        return addInteger(date, Calendar.SECOND, secondAmount);
    }
 
    /**
     * 增加日期的秒钟。失败返回null。
     * @param date 日期
     * @param secondAmount 增加数量。可为负数
     * @return 增加秒钟后的日期
     */
    public static Date addSecond(Date date, int secondAmount) {
        return addInteger(date, Calendar.SECOND, secondAmount);
    }
 
    /**
     * 获取日期的年份。失败返回0。
     * @param date 日期字符串
     * @return 年份
     */
    public static int getYear(String date) {
        return getYear(StringToDate(date));
    }
 
    /**
     * 获取日期的年份。失败返回0。
     * @param date 日期
     * @return 年份
     */
    public static int getYear(Date date) {
        return getInteger(date, Calendar.YEAR);
    }
 
    /**
     * 获取日期的月份。失败返回0。
     * @param date 日期字符串
     * @return 月份
     */
    public static int getMonth(String date) {
        return getMonth(StringToDate(date));
    }
 
    /**
     * 获取日期的月份。失败返回0。
     * @param date 日期
     * @return 月份
     */
    public static int getMonth(Date date) {
        return getInteger(date, Calendar.MONTH) + 1;
    }
 
    /**
     * 获取日期的天数。失败返回0。
     * @param date 日期字符串
     * @return 天
     */
    public static int getDay(String date) {
        return getDay(StringToDate(date));
    }
 
    /**
     * 获取日期的天数。失败返回0。
     * @param date 日期
     * @return 天
     */
    public static int getDay(Date date) {
        return getInteger(date, Calendar.DATE);
    }
 
    /**
     * 获取日期的小时。失败返回0。
     * @param date 日期字符串
     * @return 小时
     */
    public static int getHour(String date) {
        return getHour(StringToDate(date));
    }
 
    /**
     * 获取日期的小时。失败返回0。
     * @param date 日期
     * @return 小时
     */
    public static int getHour(Date date) {
        return getInteger(date, Calendar.HOUR_OF_DAY);
    }
 
    /**
     * 获取日期的分钟。失败返回0。
     * @param date 日期字符串
     * @return 分钟
     */
    public static int getMinute(String date) {
        return getMinute(StringToDate(date));
    }
 
    /**
     * 获取日期的分钟。失败返回0。
     * @param date 日期
     * @return 分钟
     */
    public static int getMinute(Date date) {
        return getInteger(date, Calendar.MINUTE);
    }
 
    /**
     * 获取日期的秒钟。失败返回0。
     * @param date 日期字符串
     * @return 秒钟
     */
    public static int getSecond(String date) {
        return getSecond(StringToDate(date));
    }
 
    /**
     * 获取日期的秒钟。失败返回0。
     * @param date 日期
     * @return 秒钟
     */
    public static int getSecond(Date date) {
        return getInteger(date, Calendar.SECOND);
    }
 
    /**
     * 获取日期 。默认yyyy-MM-dd格式。失败返回null。
     * @param date 日期字符串
     * @return 日期
     */
    public static String getDate(String date) {
        return StringToString(date, DateStyle.YYYY_MM_DD);
    }
 
    /**
     * 获取日期。默认yyyy-MM-dd格式。失败返回null。
     * @param date 日期
     * @return 日期
     */
    public static String getDate(Date date) {
        return DateToString(date, DateStyle.YYYY_MM_DD);
    }
 
    /**
     * 获取日期的时间。默认HH:mm:ss格式。失败返回null。
     * @param date 日期字符串
     * @return 时间
     */
    public static String getTime(String date) {
        return StringToString(date, DateStyle.HH_MM_SS);
    }
 
    /**
     * 获取日期的时间。默认HH:mm:ss格式。失败返回null。
     * @param date 日期
     * @return 时间
     */
    public static String getTime(Date date) {
        return DateToString(date, DateStyle.HH_MM_SS);
    }
 
    /**
     * 获取日期的星期。失败返回null。
     * @param date 日期字符串
     * @return 星期
     */
    public static Week getWeek(String date) {
        Week week = null;
        DateStyle dateStyle = getDateStyle(date);
        if (dateStyle != null) {
            Date myDate = StringToDate(date, dateStyle);
            week = getWeek(myDate);
        }
        return week;
    }
 
    /**
     * 获取日期的星期。失败返回null。
     * @param date 日期
     * @return 星期
     */
    public static Week getWeek(Date date) {
        Week week = null;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int weekNumber = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        switch (weekNumber) {
        case 0:
            week = Week.SUNDAY;
            break;
        case 1:
            week = Week.MONDAY;
            break;
        case 2:
            week = Week.TUESDAY;
            break;
        case 3:
            week = Week.WEDNESDAY;
            break;
        case 4:
            week = Week.THURSDAY;
            break;
        case 5:
            week = Week.FRIDAY;
            break;
        case 6:
            week = Week.SATURDAY;
            break;
        }
        return week;
    }
 
    /**
     * 获取两个日期相差的天数
     * @param date 日期字符串
     * @param otherDate 另一个日期字符串
     * @return 相差天数。如果失败则返回-1
     */
    public static int getIntervalDays(String date, String otherDate) {
        return getIntervalDays(StringToDate(date), StringToDate(otherDate));
    }
 
    /**
     * @param date 日期
     * @param otherDate 另一个日期
     * @return 相差天数。如果失败则返回-1
     */
    public static int getIntervalDays(Date date, Date otherDate) {
        int num = -1;
        Date dateTmp = DateUtils.StringToDate(DateUtils.getDate(date),
                DateStyle.YYYY_MM_DD);
        Date otherDateTmp = DateUtils.StringToDate(DateUtils.getDate(otherDate),
                DateStyle.YYYY_MM_DD);
        if (dateTmp != null && otherDateTmp != null) {
            long time = Math.abs(dateTmp.getTime() - otherDateTmp.getTime());
            num = (int) (time / (24 * 60 * 60 * 1000));
        }
        return num;
    }
 
    /**
     * @param date 日期
     * @param otherDate 另一个日期
     * @return 相差分钟数。如果失败则返回-1
     */
    public static int getIntervalMinute(Date date, Date otherDate) {
        int num = -1;
        if (date != null && otherDate != null) {
            long time = Math.abs(date.getTime() - otherDate.getTime());
            num = (int) (time / (1000*60));
        }
        return num;
    }
 
 
    /**
     * Description :获取当前时间yyyyMMddHHmmss字符串
     * Author : miaozh
     * CreateTime : 2016年10月10日 下午2:43:39
     * @return String
     */
    public static String getSecondString() {
        return DateToString(new Date(), DateStyle.YYYYMMDDHHMMSS);
    }
 
    /**
     * Description : 获取当前时间yyyyMMddHHmmssSSS字符串
     * Author : miaozh
     * CreateTime : 2016年10月10日 下午2:46:08
     * @return String
     */
    public static String getMillisecondString() {
        return DateToString(new Date(), DateStyle.YYYYMMDDHHMMSSSSS);
    }
 
    /**
     * Description:[返回开始时间到结束的时间段值 例：分段计算时间值,将24小时分为48个时间段，例如：1,2标识00:00到01:00]
     * @param startTime 开始时间9:00
     * @param endTime 结束时间10:30
     * @return
     *
     * Created on 2017/11/3
     * @author: 尹归晋
     */
    public static String splitTime(Date startTime, Date endTime ) {
        //开始时间
        StringBuffer splitTime = new StringBuffer();
        int startHour = DateUtils.getHour(startTime);
        int startMinute = DateUtils.getMinute(startTime);
        int startCount = startHour * 2;
        if (startMinute > 0 ) {
            startCount = startCount + 1;
        }
        //结束时间
        int endHour = DateUtils.getHour(endTime);
        int endMinute = DateUtils.getMinute(endTime);
        int endCount = endHour * 2;
        if (endMinute > 0) {
            endCount = endCount +1;
        }
        //如果结束是00:00 最后时间
        if(endHour == 0 && endMinute == 0) {
            endCount = 48;
        }
        //之所以需要++ 原因在于开始时间为9:00结束时间为9：30，不加1的情况18表示是8:30到9:00的时间段这样是错误的，我需要的是9:00到9:30的所以是19。
        startCount ++;
        endCount ++;
        //如果跨天会议  结束时间的小时小于开始时间的小时认定为跨天会议
        if(endHour < startHour) {
            for (int i = startCount;i < 49; i++) {
                splitTime.append(i);
                splitTime.append(Const.SEPARATOR_COMMA);
            }
            if (endCount != 49) {
                for (int j = 1; j < endCount; j++) {
                    splitTime.append(j);
                    if (j < endCount - 1) {
                        splitTime.append(Const.SEPARATOR_COMMA);
                    }
                }
            }
            return  splitTime.toString();
        }
        //不是跨天会议
        if (startCount == endCount) {
            splitTime.append(startCount);
            return  splitTime.toString();
        }
        for (int i = startCount;i < endCount; i++) {
            splitTime.append(i);
            if (i < endCount - 1) {
                splitTime.append(Const.SEPARATOR_COMMA);
            }
        }
        return  splitTime.toString();
    }
 
 
    /**
     * Description:[返回开始时间到结束的时间段值 例：分段计算时间值,将24小时分为48个时间段，例如：1,2标识00:00到01:00]
     * @param startTime 开始时间9:00
     * @param endTime 结束时间10:30
     * @return
     *
     * Created on 2017/11/3
     * @author: 尹归晋
     */
    public static String splitTime(String startTime, String endTime ) {
        Date startDate = DateUtils.StringToDate(startTime, DateStyle.HH_MM_SS);
        Date endDate = DateUtils.StringToDate(endTime, DateStyle.HH_MM_SS);
        return splitTime(startDate, endDate);
    }
 
    /**
     * Description:[24小时分为48个时间段，根据时间段的数值获取真实的时间 -- 会议开始时间]
     * @param number 24小时分为48个时间段的值
     * @return 数值解析后的真实时间 -- 会议开始时间
     *
     * Created on 2017/11/22
     * @author: 尹归晋
     */
    public static Date numberByStartTime(int number) {
        int i = (number - 1) % 2;
        int hour = (number - 1) / 2;
        int minute = 0;
        if (i > 0) {
            minute = 30;
        }
        String endTime = hour + Const.SEPARATOR_COLON + minute;
        return DateUtils.StringToDate(endTime, DateStyle.HH_MM);
    }
 
    /**
     * Description:[24小时分为48个时间段，根据时间段的数值获取真实的时间 -- 会议结束时间]
     * @param number 24小时分为48个时间段的值
     * @return 数值解析后的真实时间 -- 会议结束时间
     *
     * Created on 2017/11/22
     * @author: 尹归晋
     */
    public static Date numberByEndTime(int number) {
        return addMinute(numberByStartTime(number), 30);
    }
 
    /**
     * Description:[判断两个日期是否相等]
     * @param d1 日期1
     * @param d2 日期2
     * @return
     *
     * Created on 2017/11/3
     * @author: 尹归晋
     */
    public static boolean isSameDate(Date d1, Date d2) {
        if(null == d1 || null == d2)
            return false;
        //return getOnlyDate(d1).equals(getOnlyDate(d2));
        Calendar cal1 = Calendar.getInstance();
        cal1.setTime(d1);
        Calendar cal2 = Calendar.getInstance();
        cal2.setTime(d2);
        return  cal1.get(0) == cal2.get(0) && cal1.get(1) == cal2.get(1) && cal1.get(6) == cal2.get(6);
    }
 
    /**
     * Description:[获取两个时间的时间差]
     * @param date1 时间一
     * @param date2 时间二
     * @param type 获取的类型  天 时 分
     * @return 时间一 减 时间二 的值
     *
     * Created on 2017/11/10
     * @author: 尹归晋
     */
    public static int dayDiff(Date date1, Date date2, int type) {
        long diff = date1.getTime() - date2.getTime();
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff / nh;
        // 计算差多少分钟
        long min = diff / nm;
        if (Calendar.DATE == type) {
            return (int) day;
        } else if (Calendar.HOUR_OF_DAY == type) {
            return (int) hour;
        } else {
            return (int) min;
        }
    }
 
    /**
     * Description:[根据参数时间获取前推的整点时间：列2017-11-22 17:13返回17:00；列2017-11-22 17:59返回17:30]
     * @param date 时间
     * @return 列2017-11-22 17:13返回17:00；列2017-11-22 17:59返回17:30
     *
     * Created on 2017/11/22
     * @author: 尹归晋
     */
    public static Date wholeHour(Date date){
        int hour = DateUtils.getHour(date);
        int minute = DateUtils.getMinute(date);
        if (minute >= 30) {
            minute = 30;
        }else {
            minute = 00;
        }
        String endTime = hour + Const.SEPARATOR_COLON + minute;
        return DateUtils.StringToDate(endTime, DateStyle.HH_MM);
    }
 
 
    /**
     * <p>Description:[计算两个日期相差的月数，不足15天按照半个月计算，超过15天按照一个月计算]</p>
     * Created on 2017年11月28日
     *
     * @param startDate 开始时间
     * @param endDate 结束时间
     * @return 相差的月数0.5的倍数
     * @author 缪志红
     */
    public static double getMonths(Date startDate, Date endDate) {
        int startYear = DateUtils.getYear(startDate);
        int endYear = DateUtils.getYear(endDate);
        int startMonth = DateUtils.getMonth(startDate);
        int endMonth = DateUtils.getMonth(endDate);
        int startDay = DateUtils.getDay(startDate);
        int endDay = DateUtils.getDay(endDate);
        int endLastDay = DateUtils.getLastDay(endDate);
        int startLastDay = DateUtils.getLastDay(startDate);
        int intervalYears = endYear - startYear;
        double intervalMonths;
        int intervalDays;
        if (intervalYears >= 1) {
            intervalDays = (startLastDay - startDay) + endDay + 1;
            intervalMonths = (12.0 - startMonth) + endMonth + 1;
            if (startDay == 1 && endDay == endLastDay) {
                intervalDays = 0;
            } else {
                if (startDay != 1) {
                    intervalMonths -= 1.0;
                } else {
                    intervalDays = endDay;
                }
                if (endDay != endLastDay) {
                    intervalMonths -= 1.0;
                } else {
                    intervalDays = startLastDay - startDay + 1;
                }
            }
        } else {
            intervalMonths = endMonth - startMonth + 1.0;
            if (intervalMonths > 1.0) {
                intervalDays = (startLastDay - startDay) + endDay + 1;
                if (startDay == 1 && endDay == endLastDay) {
                    intervalDays = 0;
                } else {
                    if (startDay != 1) {
                        intervalMonths -= 1.0;
                    } else {
                        intervalDays = endDay;
                    }
                    if (endDay != endLastDay) {
                        intervalMonths -= 1.0;
                    } else {
                        intervalDays = startLastDay - startDay + 1;
                    }
                }
                intervalMonths = intervalMonths < 0.0 ? 0.0 : intervalMonths;
            } else {
                intervalMonths = 0.0;
                intervalDays = endDay - startDay + 1;
            }
 
        }
        if (intervalDays == 0) {
            intervalMonths += 0.0;
        } else if (intervalDays <= 15) {
            intervalMonths += 0.5;
        } else if (intervalDays >= 31) {
            intervalMonths += 1.0;
            if (intervalDays - 31 > 15) {
                intervalMonths += 1.0;
            } else if (intervalDays - 31 >= 1) {
                intervalMonths += 0.5;
            }
        } else {
            intervalMonths += 1.0;
        }
        for (int i = 1; i < intervalYears; i++) {
            intervalMonths += 12.0;
        }
        return intervalMonths;
    }
 
 
 
    /**
     * <p>Description:[计算当前时间所处的拆分时间段]</p>
     * Created on 2017年12月05日
     *
     * @return 拆分时间段Integer值
     * @author 缪志红
     */
    public static Integer getSplitTimeByNow() {
        int hour = DateUtils.getHour(new Date());
        int minute = DateUtils.getMinute(new Date());
        int splitTime = hour * 2 + 1;
        if (minute >= 30) {
            splitTime += 1;
        }
        return splitTime;
    }
 
    /**
     * <p>Description:[计算时间所处的拆分时间段]</p>
     * Created on 2018年1月14日
     *
     * @return 拆分时间段Integer值
     * @author 缪志红
     */
    public static Integer getSplitTime(Date date) {
        int hour = DateUtils.getHour(date);
        int minute = DateUtils.getMinute(date);
        if (minute > 0 && minute < 30) {
            minute = 30;
        }
        int splitTime = hour * 2 + 1;
        if (minute >= 30) {
            splitTime += 1;
        }
        return splitTime;
    }
 
    /**
     * Description:[获取当前月的第一天的日期]
     * @return 当前月第一天
     *
     * Created on 2017/12/15
     * @author: 尹归晋
     */
    public static Date getfirstDate(){
        Calendar c = Calendar.getInstance();
        c.add(Calendar.MONTH, 0);
        c.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天
        return StringToDate(getDateFormat(DateStyle.YYYY_MM_DD.getValue()).format(c.getTime()));
    }
 
    /**
     * Description:[获取当前月的最后一天的日期]
     * @return 当前月的最后一天
     *
     * Created on 2017/12/15
     * @author: 尹归晋
     */
    public static Date getlastDate(){
        Calendar c = Calendar.getInstance();
        c.add(Calendar.MONTH, 0);
        c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
        return StringToDate(getDateFormat(DateStyle.YYYY_MM_DD.getValue()).format(c.getTime()));
    }
 
    /**
     * Description:[获取指定月的最后一天的日期]
     * @return 指定的最后一天
     *
     * Created on 2017/12/15
     * @author: 李瑞丰
     */
    public static int getLastDay(Date date){
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        int lastDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
        return lastDay;
    }
 
    /**
     * Description:[获取指定月的第一天的日期]
     * @return 指定的第一天
     *
     * Created on 2017/12/15
     * @author: 李瑞丰
     */
    public static int getFirstDay(Date date){
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        int firstDay = c.getActualMinimum(Calendar.DAY_OF_MONTH);
        return firstDay;
    }
 
    /**
     * <p>Description:[获取当前日期字符串]</p>
     * Created on 2018/1/2
     *
     * @author 缪志红
     */
    public static String getCurrentDateString() {
        return DateToString(new Date(), DateStyle.YYYY_MM_DD);
    }
 
    /**
     * <p>Description:[获取当前日期]</p>
     * Created on 2018/1/2
     *
     * @author 缪志红
     */
    public static Date getCurrentDate() {
        return StringToDate(getCurrentDateString(), DateStyle.YYYY_MM_DD);
    }
 
 
    /**
     * <p>Description:[时间是否小于当前时间 ]</p>
     * Created on 2017年12月26日
     * @param targetDate 目标日期
     * @param targetTime 目标时间
     * @return
     * @author:[刘香平]
     */
    public static boolean compareNowHours(Date targetDate, Date targetTime){
        Date date = new Date();
        if (targetDate.after(date)) {
            return false;
        }
        Date nowTime = DateUtils.StringToDate(DateUtils.getHour(date) + Const.SEPARATOR_COLON + DateUtils.getMinute(date) + Const.SEPARATOR_COLON + DateUtils.getSecond(date), DateStyle.HH_MM_SS);
        int compare = nowTime.compareTo(targetTime);
        if (compare >= 0) {
            return true;
        }else {
            return false;
        }
    }
 
    /**
     * <p>Description:[获取申请展厅时间列表]</p>
     * Created on 2018/7/27
     *
     * @author 缪志红
     */
    public static List<String> getTimeList() {
        List<String> timeList = new ArrayList<>();
        timeList.add("10:00");
        timeList.add("10:30");
        timeList.add("11:00");
        timeList.add("11:30");
        timeList.add("12:00");
        timeList.add("12:30");
        timeList.add("13:00");
        timeList.add("13:30");
        timeList.add("14:00");
        timeList.add("14:30");
        timeList.add("15:00");
        timeList.add("15:30");
        timeList.add("16:00");
        timeList.add("16:30");
        timeList.add("17:00");
        timeList.add("17:30");
        return timeList;
    }
 
    /**
     * <p>Description:[获取一天中所有的拆分时间]</p>
     * Created on 2018/7/27
     *
     * @author 缪志红
     */
    public static List<Integer> getAllSplitTimes() {
        List<Integer> splitTimes = new ArrayList<>();
        for (int i = 0; i < 48; i++) {
            splitTimes.add(i + 1);
        }
        return splitTimes;
    }
 
    /**
     * <p>Description:[获取某月最大日期]</p>
     * Created on 2018/7/31
     *
     * @author 缪志红
     */
    public static int getMonthMaxDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(getYear(date), getMonth(date) - 1, 1);
        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
    }
 
    /**
     * <p>Description:[获取零点的时间]</p>
     * Created on 2018/8/3
     *
     * @author 缪志红
     */
    public static Date getZeroTimeDate() {
        return StringToDate("00:00:00", DateStyle.HH_MM);
    }
     
    /**
     * <p>Description:[获取当天23点59分59秒的时间]</p>
     * Created on 2018/8/3
     *
     * @author 缪志红
     */
    public static Date getEndTimeDate() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE,59);
        calendar.set(Calendar.SECOND, 59);
        return calendar.getTime();
    }
 
    /**
     * <p>Description:[获取当前时间]</p>
     * Created on 2018/8/16
     *
     * @author 缪志红
     */
    public static Date getCurrentTime() {
        return dateForMat(new Date(), DateStyle.HH_MM);
    }
 
    /**
     * <p>Description:[根据int值获取星期值]</p>
     * Created on 2018/8/31
     *
     * @author 缪志红
     */
    public static String week(int day) {
        String week = "";
        switch (day) {
            case 1:
                week = "星期天";
                break;
            case 2:
                week = "星期一";
                break;
            case 3:
                week = "星期二";
                break;
            case 4:
                week = "星期三";
                break;
            case 5:
                week = "星期四";
                break;
            case 6:
                week = "星期五";
                break;
            case 7:
                week = "星期六";
                break;
        }
        return week;
    }
 
    public static void main(String[] args) {
        System.out.println(getSplitTime(StringToDate("08:30", DateStyle.HH_MM)));
    }
 
    /**
     * <p>Discription:[根据传入的两个时间计算相差几个小时，结果保留一位小数]</p>
     * Created on 2018年09月03日17:21:23
     * @param dateLast date类型的时间1
     * @param dateNext date类型的时间2
     * @return Double 返回保留一位小数的绝对值
     * @author:[石雄朵]
     */
    public static Double calculateHour(Date dateLast, Date dateNext) {
        long millisLast = dateLast.getTime();
        long millisNext = dateNext.getTime();
        double differenceMillis = millisNext - millisLast;
        double hourDouble = differenceMillis/1000/60/60;
        BigDecimal decHour = new BigDecimal(hourDouble);
        hourDouble = decHour.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
        return Math.abs(hourDouble);
    }
    /**
     * 判断是否今天
     * @param ts
     * @return
     */
    public static boolean isToday(long ts) {
        LocalDateTime today = LocalDateTime.of(LocalDate.now(), LocalTime.of(0, 0, 0));
        LocalDateTime tommorrow = today.plusDays(1);
        long todaySecond = today.atZone(ZoneId.systemDefault()).toEpochSecond();
        long tomorrowSeconds = tommorrow.atZone(ZoneId.systemDefault()).toEpochSecond();
        ts = ts/1000;
        return ts >= todaySecond && ts < tomorrowSeconds;
    }
    /**
     * 分钟差
     * @param startTime
     * @param endTime
     * @return
     */
    public static long minuteDiff(Date startTime,Date endTime) {
           long l=endTime.getTime()-startTime.getTime();
           long min=((l/(60*1000)));
           return min;
    }
}
用户注册

用户登录

发表随想

该用户最新代码

编程随想

[java]代码库

网友评论 (发表评论)

发表评论：

评论须知：

扫码下载

输入口令后可复制整站源码
