日期处理工具类

import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 类名：DateUtil  <br />
 * <p>
 * 功能：

 * 创建时间：2015年12月4日 下午4:44:11  <br />
 * @version 2015年12月4日
 */
public class DateUtil {

    // 缓存
    private static final Map<String, SimpleDateFormat> formats;

    static {
        formats = new HashMap<String, SimpleDateFormat>();

        formats.put("yyyyMMdd", new SimpleDateFormat("yyyyMMdd"));
        formats.put("HHmmss", new SimpleDateFormat("HHmmss"));
        formats.put("yyyyMMddHHmmss", new SimpleDateFormat("yyyyMMddHHmmss"));
        formats.put("yyyyMMddHHmmssSSS", new SimpleDateFormat("yyyyMMddHHmmssSSS"));
    }

    /**
     * 功能：比较两个日期的顺序 <br/>
     *

     * @version 2013-12-28 上午11:20:58 <br/>
     */
    public static int compare(Date one, Date two) {
        return one.compareTo(two);
    }

    /**
     * 功能： <br/>
     *
     * @version 2013-12-4 下午02:06:59 <br/>
     */
    public static Date addDays(Date date, int field) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(Calendar.DAY_OF_MONTH, field);
        return c.getTime();
    }

    /**
     * 功能： <br/>
     *
     * @version 2013-12-4 下午02:06:59 <br/>
     */
    public static Date addHours(Date date, int field) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(Calendar.HOUR, field);
        return c.getTime();
    }

    /**
     * 功能： <br/>
     * @version 2013-12-4 下午02:06:59 <br/>
     */
    public static Date add(Date date, int field, int amount) {
        return add(date, field, amount, null);
    }

    /**
     * 功能： <br/>
     * field like Calendar.SECOND
     *

     * @version 2013-12-4 下午02:06:19 <br/>
     */
    public static Date add(Date date, int field, int amount, TimeZone timeZone) {
        Calendar cal = (timeZone == null ? Calendar.getInstance() : Calendar.getInstance(timeZone));

        cal.setTime(date);

        cal.add(field, amount);

        return cal.getTime();
    }

    /**
     * 功能： <br/>
     * @version 2013-11-27 上午10:01:13 <br/>
     */
    public static Date parseDateTime(String source) throws ParseException {
        return parse(source, "yyyyMMddHHmmss");
    }

    /**
     * 功能： <br/>
     *
     * @version 2013-11-27 上午10:01:28 <br/>
     */
    public static Date parseTime(String source) throws ParseException {
        return parse(source, "HHmmss");
    }

    /**
     * 功能： <br/>
     *
     * @throws ParseException
     * @version 2013-11-27 上午10:00:50 <br/>
     */
    public static Date parseDate(String source) throws ParseException {
        return parse(source, "yyyyMMdd");
    }

    /**
     * 功能： <br/>
     *
     * @version 2013-11-27 上午10:00:17 <br/>
     */
    public static Date parse(String source, String pattern) throws ParseException {
        return getFormat(pattern).parse(source);
    }

    /**
     * 功能：获取获取毫秒值得时间戳 + 0-9 随机数一位 <br/>
     *
     * @version 2013-11-26 下午07:58:17 <br/>
     */
    public static String getRandomCurrentTimeStamp() {
        return formaCurrentTimeStamp(new Date()) + new Random().nextInt(9);
    }

    /**
     * 功能：获取秒值得时间戳 <br/>
     *
     * @version 2013-11-26 下午07:58:17 <br/>
     */
    public static String getTimeStamp() {
        return formatDateTime(new Date());
    }

    /**
     * 功能： 获取毫秒值得时间戳 <br/>
     *
     * @version 2013-11-26 下午07:58:17 <br/>
     */
    public static String getCurrentTimeStamp() {
        return formaCurrentTimeStamp(new Date());
    }

    /**
     * 功能： <br/>
     * @version 2013-11-26 下午07:58:17 <br/>
     */
    public static String formaCurrentTimeStamp(Date date) {
        return format(date, "yyyyMMddHHmmssSSS");
    }

    /**
     * 功能： <br/>
     *
     * @version 2013-11-26 下午07:58:17 <br/>
     */
    public static String formatDateTime(Date date) {
        return format(date, "yyyyMMddHHmmss");
    }

    /**
     * 功能：按默认规则格式化为时间
     * @version 2013-11-26 下午07:57:33 <br/>
     */
    public static String formatTime(Date date) {
        return format(date, "HHmmss");
    }

    /**
     * 功能：按默认规则格式化日期 <br/>
     *
     * @version 2013-11-26 下午07:56:47 <br/>
     */
    public static String formatDate(Date date) {
        return format(date, "yyyyMMdd");
    }

    /**
     * 功能： <br/>
     *
     * @version 2013-11-26 下午07:55:49 <br/>
     */
    public static String format(Date date, String pattern) {
        return getFormat(pattern).format(date);
    }

    /**
     * 功能： <br/>
     *
     * @version 2013-11-27 上午09:59:37 <br/>
     */
    private static SimpleDateFormat getFormat(String pattern) {
        SimpleDateFormat sdf = formats.get(pattern);

        if (null == sdf) {
            formats.put(pattern, sdf = new SimpleDateFormat(pattern));
        }

        // 强制格式匹配
        sdf.setLenient(false);

        return sdf;
    }

    /**
     * 将短时间格式时间转换为字符串 yyyy-MM-dd
     *
     * @param dateDate
     * @return
     */
    public static String dateToStr(Date dateDate) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        String dateString = formatter.format(dateDate);
        return dateString;
    }

    /**
     * 将短时间格式字符串转换为时间 yyyy-MM-dd
     *
     * @param strDate
     * @return
     */
    public static Date strToDate(String strDate) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        ParsePosition pos = new ParsePosition(0);
        Date strtodate = formatter.parse(strDate, pos);
        return strtodate;
    }

    //判断某个时间是否在当前时间的7天之内
    public static Boolean isLatestWeek(Date addtime, Date now) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(now);
        calendar.add(Calendar.DAY_OF_MONTH, -7);
        Date before7days = calendar.getTime();
        if (before7days.getTime() < addtime.getTime()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 返回指定年度的所有周。List中包含的是String[2]对象<br>
     * string[0]本周的开始日期,string[1]是本周的结束日期。<br>
     * 日期的格式为yyyy-MM-dd。<br>
     * 每年的第一个周，必须包含星期一且是完整的七天。<br>
     * 例如：2009年的第一个周开始日期为2009-01-05，结束日期为2009-01-11。 <br>
     * 星期一在哪一年，那么包含这个星期的周就是哪一年的周。<br>
     * 例如：2008-12-29是星期一，2009-01-04是星期日，哪么这个周就是2008年度的最后一个周。<br>
     *
     * @param year 格式 yyyy ，必须大于1900年度 小于9999年
     * @return
     */
    public static List<Date[]> getWeeksByYear(final int year) {
        if (year < 1900 || year > 9999) {
            throw new NullPointerException("年度必须大于等于1900年小于等于9999年");
        }
        //实现思路，首先计算当年有多少个周，然后找到每个周的开始日期和结束日期
        // Calendar calendar = new GregorianCalendar();
        // // 在具有默认语言环境的默认时区内使用当前时间构造一个默认的 GregorianCalendar。
        // calendar.setFirstDayOfWeek(Calendar.MONDAY); //设置每周的第一天为星期一
        // calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY); //每周从周一开始
        // 上面两句代码配合，才能实现，每年度的第一个周，是包含第一个星期一的那个周。
        // calendar.setMinimalDaysInFirstWeek(7); //设置每周最少为7天
        // calendar.set(Calendar.YEAR, year); // 设置年度为指定的年
        // //首先计算当年有多少个周,每年都至少有52个周，个别年度有53个周
        int weeks = getWeekNumByYear(year);
        // System.out.println(year+"共有"+weeks+"个周");
        List<Date[]> result = new ArrayList<Date[]>(weeks);
        for (int i = 1; i <= weeks; i++) {
            Date[] tempWeek = new Date[2];
            tempWeek[0] = getYearWeekFirstDay(year, i);
            tempWeek[1] = getYearWeekEndDay(year, i);
            //或者使用下面的代码，不过发现效率更低
            // tempWeek[0] = getDateAdd(firstWeekDay,(i-1)*7+0);
            // tempWeek[1] = getDateAdd(firstWeekDay,(i-1)*7+6);
            result.add(tempWeek);
            // System.out.println(i+"="+tempWeek[0]+"_"+tempWeek[1]);
        }
        return result;
    }


    /**
     * 计算指定年度共有多少个周。
     *
     * @param year 格式 yyyy ，必须大于1900年度 小于9999年
     * @return
     */
    public static int getWeekNumByYear(final int year) {
        if (year < 1900 || year > 9999) {
            throw new NullPointerException("年度必须大于等于1900年小于等于9999年");
        }
        int result = 52;//每年至少有52个周 ，最多有53个周。
        String date = format(getYearWeekFirstDay(year, 53), "yyyy-MM-dd");

        if (date.substring(0, 4).equals(year + "")) { //判断年度是否相符，如果相符说明有53个周。
            result = 53;
        }
        return result;
    }

    /**
     * 计算某年某周的开始日期
     *
     * @param yearNum 格式 yyyy ，必须大于1900年度 小于9999年
     * @param weekNum 1到52或者53
     * @return 日期，格式为yyyy-MM-dd
     */
    public static Date getYearWeekFirstDay(int yearNum, int weekNum) {
        if (yearNum < 1900 || yearNum > 9999) {
            throw new NullPointerException("年度必须大于等于1900年小于等于9999年");
        }
        Calendar cal = Calendar.getInstance();
        cal.setFirstDayOfWeek(Calendar.MONDAY); //设置每周的第一天为星期一
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);//每周从周一开始
        // 上面两句代码配合，才能实现，每年度的第一个周，是包含第一个星期一的那个周。
        cal.setMinimalDaysInFirstWeek(7); //设置每周最少为7天
        cal.set(Calendar.YEAR, yearNum);
        cal.set(Calendar.WEEK_OF_YEAR, weekNum);

        //分别取得当前日期的年、月、日
        return cal.getTime();
    }

    /**
     * 计算某年某周的结束日期
     *
     * @param yearNum 格式 yyyy ，必须大于1900年度 小于9999年
     * @param weekNum 1到52或者53
     * @return 日期，格式为yyyy-MM-dd
     */
    public static Date getYearWeekEndDay(int yearNum, int weekNum) {
        if (yearNum < 1900 || yearNum > 9999) {
            throw new NullPointerException("年度必须大于等于1900年小于等于9999年");
        }
        Calendar cal = Calendar.getInstance();
        cal.setFirstDayOfWeek(Calendar.MONDAY); //设置每周的第一天为星期一
        cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);//每周从周一开始
        // 上面两句代码配合，才能实现，每年度的第一个周，是包含第一个星期一的那个周。
        cal.setMinimalDaysInFirstWeek(7); //设置每周最少为7天
        cal.set(Calendar.YEAR, yearNum);
        cal.set(Calendar.WEEK_OF_YEAR, weekNum);

        return cal.getTime();
    }

    public static int getWeekNumInYear(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.setTime(date);
        return calendar.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获取当前日期
     *
     * @return
     */
    public static Date getCurrentDate() {
        Date today = new Date();
        return today;
    }

    /**
     * 根据每周的开始结束日期计算每天日期
     *
     * @param startDate
     * @param endDate
     * @return
     * @throws ParseException
     */
    public static Map<String, Date> getBetweenWeeks(Date startDate, Date endDate) {

        Calendar tempStart = Calendar.getInstance();
        tempStart.setTime(startDate);
        Calendar tempEnd = Calendar.getInstance();
        tempEnd.setTime(endDate);
        Map<String, Date> map = new LinkedHashMap<>();
        while (tempStart.before(tempEnd) || tempStart.equals(tempEnd)) {
            int week = tempStart.get(Calendar.DAY_OF_WEEK);
            switch (week) {
                case 1:
                    map.put("sun", tempStart.getTime());
                    break;
                case 2:
                    map.put("mon", tempStart.getTime());
                    break;
                case 3:
                    map.put("tue", tempStart.getTime());
                    break;
                case 4:
                    map.put("wed", tempStart.getTime());
                    break;
                case 5:
                    map.put("thur", tempStart.getTime());
                    break;
                case 6:
                    map.put("fri", tempStart.getTime());
                    break;
                case 7:
                    map.put("sat", tempStart.getTime());
                    break;
            }

            tempStart.add(Calendar.DAY_OF_YEAR, 1);
        }
        return map;
    }


    public static int interval(Date a, Date b) {
        return (int) ((b.getTime() - a.getTime())/1000);
    }
}