Java 时间 哈喽雨点

import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.LocalTime;
import java.util.*;

public class MyDateUtil {

    /**
     * 秒转化,long  HH:mm  只限00-23:59
     *
     * @param seconds
     * @return
     */
    public static String secLongToTime(long seconds) {
        long hour = seconds / 3600;
        long minute = (seconds - Long.valueOf(hour * 3600)) / 60;

        StringBuffer sb = new StringBuffer();
        if (hour > 0) {
            if (hour > 9) {
                sb.append(hour + ":");
            } else {
                sb.append("0" + hour + ":");
            }
        } else {
            sb.append(hour + "0:");
        }
        if (minute > 0) {
            if (minute > 9) {
                sb.append(minute + "");
            } else {
                sb.append("0" + minute + "");
            }

        } else {
            sb.append(minute + "0");
        }

        return sb.toString();
    }

    public static int DateToDayOfHourMinSec(Date date){
        int hour = date.getHours();
        int min = date.getMinutes();
        int sec = date.getSeconds();
        return hour * 3600 + min * 60 + sec;
    }

    /**
     * 取得格式化效果的系统日期！
     * 格式如：yyyy-MM-dd kk:mm:ss
     */
    public final static String getFormateDate(String formate) {
        SimpleDateFormat f = new SimpleDateFormat(formate);
        return f.format(new Date());
    }

    /**
     * 获取当前时间的秒值
     *
     * @return
     */
    public static long getCurrentTimeSeconds() {
        LocalTime now = LocalTime.now();

        int hour = now.getHour();
        int minute = now.getMinute();
        int seconds = now.getSecond();

        return hour * 60 * 60 + minute * 60 + seconds;
    }

    /**
     * 获取当前时间的秒值
     *
     * @return
     */
    public static int currentTimeInt() {
        String beforeDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        int time = TimeTransUtil.getTimeInteger(beforeDate);
        return time;
    }


    /**
     * 秒转化  HH:mm  只限00-23:59
     * @param seconds
     * @return
     */
    public static String secToTime(int seconds) {
        int hour = seconds / 3600;
        int minute = (seconds - hour * 3600) / 60;

        StringBuffer sb = new StringBuffer();
        if (hour > 0) {
            if(hour >9){
                sb.append(hour + ":");
            }else {
                sb.append("0"+ hour + ":");
            }
        }else  {
            sb.append(hour + "0:");
        }
        if (minute > 0) {
            if(minute >9){
                sb.append(minute + "");
            }else {
                sb.append("0" + minute + "");
            }

        }else{
            sb.append(minute + "0");
        }

        return sb.toString();
    }

    /**
     * 获取默认格式的日期和时间.形如：2007-7-8- 12:23:54
     *
     * @return
     */
    public final static String getDateTime() {
        return getFormateDate("yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 获取默认格式的日期.形如：2007-7-8
     *
     * @return
     */
    public final static String getDate() {
        return getFormateDate("yyyy-MM-dd");
    }

    /**
     * 获取默认格式的日期.形如：2007-7-8
     *
     * @return
     */
    public final static String getDate(Object date) {
        if (date == null || date == "") {
            return "";
        }
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
        return f.format(date);
    }

    /**
     * @param smdate 较小的时间
     * @param bdate  较大的时间
     * @return
     * @throws ParseException
     * @描述:计算两个日期之间相差的天数
     * @方法名: daysBetween
     * @返回类型 int
     * @创建人 fugang
     * @创建时间 2016年10月18日下午5:46:26
     * @修改备注
     */
    public static int daysBetween(Date smdate, Date bdate) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        smdate = sdf.parse(sdf.format(smdate));
        bdate = sdf.parse(sdf.format(bdate));
        Calendar cal = Calendar.getInstance();
        cal.setTime(smdate);
        long time1 = cal.getTimeInMillis();
        cal.setTime(bdate);
        long time2 = cal.getTimeInMillis();
        long between_days = (time2 - time1) / (1000 * 3600 * 24);

        return Integer.parseInt(String.valueOf(between_days));
    }

    /**
     * @param beginDate
     * @param endDate
     * @return
     * @描述:根据开始时间和结束时间返回时间段内的时间集合
     * @方法名: getDatesBetweenTwoDate
     * @返回类型 List<Date>
     * @创建人 fugang
     * @创建时间 2016年10月19日上午10:08:24
     * @修改备注
     */
    public static List<Date> getDatesBetweenTwoDate(Date beginDate, Date endDate) {
        List<Date> lDate = new ArrayList<Date>();
        lDate.add(beginDate);// 把开始时间加入集合
        Calendar cal = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        cal.setTime(beginDate);
        boolean bContinue = true;
        while (bContinue) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            cal.add(Calendar.DAY_OF_MONTH, 1);
            // 测试此日期是否在指定日期之后
            if (endDate.after(cal.getTime())) {
                lDate.add(cal.getTime());
            } else {
                break;
            }
        }
        lDate.add(endDate);// 把结束时间加入集合
        return lDate;
    }

    /**
     * 获取当前的年份
     *
     * @return
     */
    public final static String getYear() {
        return getFormateDate("yyyy");
    }

    /**
     * 获取当前的短年份
     *
     * @return
     */
    public final static String getShortYear() {
        return getFormateDate("yy");
    }

    /**
     * 获取当前的月份
     *
     * @return
     */
    public final static String getMonth() {
        return getFormateDate("MM");
    }

    /**
     * 获取当前的短月份
     *
     * @return
     */
    public final static String getShortMonth() {
        return getFormateDate("M");
    }

    /**
     * 获取当前的日期
     *
     * @return
     */
    public final static String getDay() {
        return getFormateDate("dd");
    }

    /**
     * 获取当前的短日期
     *
     * @return
     */
    public final static String getShortDay() {
        return getFormateDate("d");
    }

    /**
     * 获取默认格式的时间(24小时制).形如：16:23:54
     *
     * @return
     */
    public final static String getTime() {
        return getFormateDate("HH:mm:ss");
    }

    /**
     * 判断指定的字符串是否是正确的日期时间字符串.<br>
     * 该方法支持日期或日期时间的判断.
     *
     * @param dateStr
     */
    public final static boolean isDate(String dateStr) {
        Date dt = parseSimpleDate(dateStr);
        if (dt != null) {
            return true;
        }
        return parseSimpleDateTime(dateStr) != null;

    }

    public static String dateIntegerToDateString(Integer time) {
        long dateTime = (long) time * 1000;
        Date date = new Date(dateTime);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(date);
    }

    public static String dateIntegerToDate(Integer time) {
        long dateTime = (long) time * 1000;
        Date date = new Date(dateTime);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        return sdf.format(date);
    }
    public static String dateIntegerToDatetoString(Integer time) {
        long dateTime = (long) time * 1000;
        Date date = new Date(dateTime);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");

        return sdf.format(date);
    }
    public static  Date getSunday(String week) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
        ParsePosition position = new ParsePosition(0);
        Date date = dateFormat.parse(week,position);
        Calendar cal =Calendar.getInstance();
        cal.setTime(date);
        //判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);//获得当前日期是一个星期的第几天
        if (dayWeek == 1){
            cal.add(Calendar.DAY_OF_WEEK,-1);
        }
        //这种输出的是上个星期周日的日期，因为老外那边把周日当成第一天
        cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
        //增加一个星期，才是我们中国人理解的本周日的日期
        cal.add(Calendar.WEEK_OF_YEAR, 1);
        cal.set(Calendar.HOUR_OF_DAY,23);
        cal.set(Calendar.MINUTE,59);
        cal.set(Calendar.SECOND,59);
        return cal.getTime();
    }
    /**
     * 使用指定的模式来判断字符串是否是日期时间字符串.
     *
     * @param pattern
     * @param dateStr
     * @return
     */
    public final static boolean isDate(String pattern, String dateStr) {
        return parseSimpleDT(pattern, dateStr) != null;
    }

    /**
     * 将指定的日期时间格式的字符串转换成日期对象.
     *
     * @param dateStr
     * @return
     */
    public final static Date parseDateTime(String dateStr) {
        try {
            return DateFormat.getDateTimeInstance().parse(dateStr);
        } catch (ParseException ex) {
            return null;
        }
    }

    /**
     * 将指定日期格式的字符串转换成日期对象.
     *
     * @param dateStr
     * @return
     */
    public final static Date parseDate(String dateStr) {
        try {
            return DateFormat.getDateInstance().parse(dateStr);
        } catch (ParseException ex) {
            return null;
        }
    }

    /**
     * 使用简单化的方式来解析日期时间格式.
     *
     * @param dateStr
     * @return
     */
    public final static Date parseSimpleDateTime(String dateStr) {
        return parseSimpleDT("yyyy-MM-dd HH:mm:ss", dateStr);
    }

    public final static Date parseSimpleDate(String dateStr) {
        return parseSimpleDT("yyyy-MM-dd", dateStr);
    }

    public final static Date parseSimpleTime(String timeStr) {
        return parseSimpleDT("HH:mm:ss", timeStr);
    }

    /**
     * 使用指定的模式来解析字符串日期时间.
     *
     * @param pattern
     * @param dateStr
     * @return
     */
    public final static Date parseSimpleDT(String pattern, String dateStr) {
        try {
            return new SimpleDateFormat(pattern, Locale.US).parse(dateStr);
        } catch (ParseException ex) {
            return null;
        }
    }

    public static Integer getTimeInteger(String time) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Integer dateTime = null;
        try {
            Date date = sdf.parse(time);
            dateTime = (int) (date.getTime() / 1000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return dateTime;
    }

    /**
     * 比较两个日期的大小.返回-1表示date1在date2之前，返回0表示两者相等，返回1
     * 则表示date1在date2之后.
     *
     * @param date1
     * @param date2
     * @return
     */
    public final static int compareDate(Date date1, Date date2) {
        if (date1.before(date2)) {
            return -1;
        }
        if (date1.after(date2)) {
            return 1;
        }
        return 0;
    }

    /**
     * 测试日期date1是否在date2之前.
     *
     * @param date1
     * @param date2
     * @return
     */
    public final static boolean isBefore(Date date1, Date date2) {
        if (date1 == null || date2 == null) {
            return false;
        }
        return date1.before(date2);
    }

    public final static boolean isBeforeNow(Date date1) {
        return isBefore(date1, Calendar.getInstance().getTime());
    }

    /**
     * 测试日期date1是否在date2之后.
     *
     * @param date1
     * @param date2
     * @return
     */
    public final static boolean isAfter(Date date1, Date date2) {
        if (date1 == null || date2 == null) {
            return false;
        }
        return date1.after(date2);
    }

    public final static boolean isAfterNow(Date date1) {
        return isAfter(date1, Calendar.getInstance().getTime());
    }

    /**
     * 测试日期date1和date2是否相等.
     *
     * @param date1
     * @param date2
     * @return
     */
    public final static boolean isEquals(Date date1, Date date2) {
        if (date1 == null || date2 == null) {
            return false;
        }
        return date1.equals(date2);
    }

    public final static boolean isEqualsNow(Date date1) {
        return isEquals(date1, Calendar.getInstance().getTime());
    }

    /**
     * 获取当前日期时间，参数表示在此基础上的偏差，参数依次表示年、月、日、时、分、秒。
     * 为正则表示在此日期上加、为负则表示在此日期上减。
     *
     * @param deviation
     * @return
     */
    public final static Date getNowDate(int... deviation) {
        return setDate(new Date(), deviation);
    }

    /**
     * 在某一指定的日期基础上进行日期的偏差设置，参数意义同getNowDate
     *
     * @param date
     * @param deviation
     * @return
     */
    public final static Date setDate(Date date, int... deviation) {
        Calendar cal = Calendar.getInstance(Locale.US);
        cal.setTime(date);
        if (deviation.length < 1) {
            return cal.getTime();
        }
        final int[] filed = {Calendar.YEAR, Calendar.MONTH, Calendar.DAY_OF_MONTH,
                Calendar.HOUR_OF_DAY, Calendar.MINUTE, Calendar.SECOND};
        for (int i = 0; i < deviation.length; i++) {
            cal.add(filed[i], deviation[i]);
        }
        return cal.getTime();
    }

    /**
     * 对日期时间字符串的提示字符串生成方法.<P>
     * <p>
     * 该方法主要是对日期时间字符串的提示,类似:1分钟前,1小时前等.对于大于1天的,则会提示
     * 1天前,2天前等等这样的提示.
     *
     * @return
     */
    public final static String dateTimeTips(Date dt) {
        Calendar cal = Calendar.getInstance(); // 获取当前日期时间
        long times = cal.getTimeInMillis() - dt.getTime(); // 获取时间差
        if (times <= 60 * 1000L) {
            return "1 分钟前";
        } else if (times <= 60 * 60 * 1000L) {
            return (times / (60 * 1000)) + " 分钟前";
        } else if (times <= 24 * 60 * 60 * 1000L) {
            return (times / (60 * 60 * 1000L)) + " 小时前";
        } else if (times <= 7 * 24 * 60 * 60 * 1000L) {
            return (times / (24 * 60 * 60 * 1000L)) + " 天前";
        } else if (times <= 30 * 24 * 60 * 60 * 1000L) {
            return (times / (7 * 24 * 60 * 60 * 1000L)) + " 星期前";
        } else if (times <= 12 * 30 * 24 * 60 * 60 * 1000L) {
            return (times / (30 * 24 * 60 * 60 * 1000L)) + " 个月前";
        }
        return (times / (12 * 30 * 24 * 60 * 60 * 1000L)) + " 年前";
    }

    public final static String dateTips(String dateStr) {
        Date dt = parseSimpleDate(dateStr);
        if (dt == null) {
            return dateStr;
        }
        return dateTimeTips(dt);
    }

    public final static String dateTimeTips(String dateTime) {
        Date dt = parseSimpleDateTime(dateTime); // 转换成日期时间类型
        if (dt == null) {
            return dateTime;
        }
        return dateTimeTips(dt);
    }


    //获取上一周周一的时间
    public static Date geLastWeekMonday(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getThisWeekMonday(date));
        cal.add(Calendar.DATE, -7);
        return cal.getTime();
    }


    //获取下周周一时间
    public static Date getNextWeekMonday(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getThisWeekMonday(date));
        cal.add(Calendar.DATE, 7);
        return cal.getTime();
    }

    //获取本周周一时间
    public static Date getThisWeekMonday(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        // 获得当前日期是一个星期的第几天
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
        if (1 == dayWeek) {
            cal.add(Calendar.DAY_OF_MONTH, -1);
        }
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
        return cal.getTime();
    }


    /**
     * 获取上周天时间
     * @param date
     * @return
     */
    public static Date  getLastWeekSunday(Date date) {
        Date a = DateUtils.addDays(date, -1);
        Calendar cal = Calendar.getInstance();
        cal.setTime(a);
        cal.set(Calendar.DAY_OF_WEEK, 1);
        return cal.getTime();
    }
}