java獲取本週 上週的全部日期

package com.power.common;

import org.apache.commons.lang3.time.DateFormatUtils;

import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;

/**
 * 日期工具類, 繼承org.apache.commons.lang.time.DateUtils類
 */
public class DateUtil extends org.apache.commons.lang3.time.DateUtils {

    private static String[] parsePatterns = {"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm"};

    /**
     * 獲得當前日期字符串 格式（yyyy-MM-dd）
     */
    public static String getDate() {
        return getDate("yyyy-MM-dd");
    }

    /**
     * 獲得當前日期字符串 格式（yyyy-MM-dd） pattern能夠爲："yyyy-MM-dd" "HH:mm:ss" "E"
     */
    public static String getDate(String pattern) {
        return DateFormatUtils.format(new Date(), pattern);
    }

    /**
     * 獲得日期字符串 默認格式（yyyy-MM-dd） pattern能夠爲："yyyy-MM-dd" "HH:mm:ss" "E"
     */
    public static String formatDate(Date date, Object... pattern) {
        String formatDate = null;
        if (pattern != null && pattern.length > 0) {
            formatDate = DateFormatUtils.format(date, pattern[0].toString());
        } else {
            formatDate = DateFormatUtils.format(date, "yyyy-MM-dd");
        }
        return formatDate;
    }

    /**
     * 獲得日期時間字符串，轉換格式（yyyy-MM-dd HH:mm:ss）
     */
    public static String formatDateTime(Date date) {
        return formatDate(date, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 獲得當前時間字符串 格式（HH:mm:ss）
     */
    public static String getTime() {
        return formatDate(new Date(), "HH:mm:ss");
    }

    /**
     * 獲得當前日期和時間字符串 格式（yyyy-MM-dd HH:mm:ss）
     */
    public static String getDateTime() {
        return formatDate(new Date(), "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 獲得當前年份字符串 格式（yyyy）
     */
    public static String getYear() {
        return formatDate(new Date(), "yyyy");
    }

    /**
     * 獲得上年年份字符串 格式（yyyy）
     */
    public static String getLastYear() {
        Date years = addYears(new Date(), -1);
        return formatDate(years, "yyyy");
    }

    /**
     * 獲得當前月份字符串 格式（MM）
     */
    public static String getMonth() {
        return formatDate(new Date(), "MM");
    }

    /**
     * 獲得當前月份字符串 格式（MM）
     */
    public static String getLastMonth() {
        Date months = addMonths(new Date(), -1);
        return formatDate(months, "MM");
    }

    /**
     * 獲得當天字符串 格式（dd）
     */
    public static String getDay() {
        return formatDate(new Date(), "dd");
    }

    /**
     * 獲得當前星期字符串 格式（E）星期幾
     */
    public static String getWeek() {
        return formatDate(new Date(), "E");
    }

    /**
     * 日期型字符串轉化爲日期 格式
     * { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm",
     * "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm" }
     */
    public static Date parseDate(Object str) {
        if (str == null) {
            return null;
        }
        try {
            return parseDate(str.toString(), parsePatterns);
        } catch (ParseException e) {
            return null;
        }
    }

    /**
     * 獲取過去的天數
     * <p>
     * param date
     * return
     */
    public static long pastDays(Date date) {
        long t = new Date().getTime() - date.getTime();
        return t / (24 * 60 * 60 * 1000);
    }

    /**
     * 獲取過去的小時
     * <p>
     * param date
     * return
     */
    public static long pastHour(Date date) {
        long t = new Date().getTime() - date.getTime();
        return t / (60 * 60 * 1000);
    }

    /**
     * 獲取過去的分鐘
     * <p>
     * param date
     * return
     */
    public static long pastMinutes(Date date) {
        long t = new Date().getTime() - date.getTime();
        return t / (60 * 1000);
    }

    /**
     * 轉換爲時間（天,時:分:秒.毫秒）
     * <p>
     * param timeMillis
     * return
     */
    public static String formatDateTime(long timeMillis) {
        long day = timeMillis / (24 * 60 * 60 * 1000);
        long hour = (timeMillis / (60 * 60 * 1000) - day * 24);
        long min = ((timeMillis / (60 * 1000)) - day * 24 * 60 - hour * 60);
        long s = (timeMillis / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
        long sss = (timeMillis - day * 24 * 60 * 60 * 1000 - hour * 60 * 60 * 1000 - min * 60 * 1000 - s * 1000);
        return (day > 0 ? day + "," : "") + hour + ":" + min + ":" + s + "." + sss;
    }

    /**
     * 獲取兩個日期之間的天數
     * <p>
     * param before
     * param after
     * return
     */
    public static double getDistanceOfTwoDate(Date before, Date after) {
        long beforeTime = before.getTime();
        long afterTime = after.getTime();
        return (afterTime - beforeTime) / (1000 * 60 * 60 * 24);
    }

    /**
     * 獲得某年某周的第一天
     * <p>
     * param year
     * param week
     * return
     */
    public static Date getFirstDayOfWeek(int year, int week) {
        week = week - 1;
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR, year);
        calendar.set(Calendar.MONTH, Calendar.JANUARY);
        calendar.set(Calendar.DATE, 1);

        Calendar cal = (Calendar) calendar.clone();
        cal.add(Calendar.DATE, week * 7);

        return getFirstDayOfWeek(cal.getTime());
    }

    /**
     * 獲得某年某周的最後一天
     * <p>
     * param year
     * param week
     * return
     */
    public static Date getLastDayOfWeek(int year, int week) {
        week = week - 1;
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR, year);
        calendar.set(Calendar.MONTH, Calendar.JANUARY);
        calendar.set(Calendar.DATE, 1);
        Calendar cal = (Calendar) calendar.clone();
        cal.add(Calendar.DATE, week * 7);

        return getLastDayOfWeek(cal.getTime());
    }

    /**
     * 取得當前日期所在周的第一天
     * <p>
     * param date
     * return
     */
    public static Date getFirstDayOfWeek(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setFirstDayOfWeek(Calendar.SUNDAY);
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek()); // Sunday
        return calendar.getTime();
    }

    /**
     * 取得當前日期所在周的最後一天
     * <p>
     * param date
     * return
     */
    public static Date getLastDayOfWeek(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setFirstDayOfWeek(Calendar.SUNDAY);
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek() + 6); // Saturday
        return calendar.getTime();
    }

    /**
     * 取得當前日期所在周的前一週最後一天
     * <p>
     * param date
     * return
     */
    public static Date getLastDayOfLastWeek(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return getLastDayOfWeek(calendar.get(Calendar.YEAR), calendar.get(Calendar.WEEK_OF_YEAR) - 1);
    }

    /**
     * 返回指定日期的月的第一天
     * <p>
     * param date
     * return
     */
    public static Date getFirstDayOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), 1);
        return calendar.getTime();
    }

    /**
     * Description:獲取指定日期年的第一天
     */
    public static Date getFirstDayOfYear(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(calendar.get(Calendar.YEAR), Calendar.JANUARY, 1);
        return calendar.getTime();
    }

    /**
     * Description:獲取指定日期年的最後一天
     */
    public static Date getLastDayOfYear(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(calendar.get(Calendar.YEAR), Calendar.DECEMBER, 31);
        return calendar.getTime();
    }

    /**
     * Description:獲取指定日期年的第一天
     */
    public static Date getFirstDayOfLastYear(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(calendar.get(Calendar.YEAR) - 1, Calendar.JANUARY, 1);
        return calendar.getTime();
    }

    /**
     * Description:獲取指定日期年的最後一天
     */
    public static Date getLastDayOfLastYear(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(calendar.get(Calendar.YEAR) - 1, Calendar.DECEMBER, 31);
        return calendar.getTime();
    }

    /**
     * 返回指定年月的月的第一天
     * <p>
     * param year
     * param month
     * return
     */
    public static Date getFirstDayOfMonth(Integer year, Integer month) {
        Calendar calendar = Calendar.getInstance();
        if (year == null) {
            year = calendar.get(Calendar.YEAR);
        }
        if (month == null) {
            month = calendar.get(Calendar.MONTH);
        }
        calendar.set(year, month, 1);
        return calendar.getTime();
    }

    /**
     * 返回指定日期的月的最後一天
     * <p>
     * param date
     * return
     */
    public static Date getLastDayOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), 1);
        calendar.roll(Calendar.DATE, -1);
        return calendar.getTime();
    }

    /**
     * 返回指定年月的月的最後一天
     * <p>
     * param year
     * param month
     * return
     */
    public static Date getLastDayOfMonth(Integer year, Integer month) {
        Calendar calendar = Calendar.getInstance();
        if (year == null) {
            year = calendar.get(Calendar.YEAR);
        }
        if (month == null) {
            month = calendar.get(Calendar.MONTH);
        }
        calendar.set(year, month, 1);
        calendar.roll(Calendar.DATE, -1);
        return calendar.getTime();
    }

    /**
     * Description:返回指定日期的上個月的第一天
     */
    public static Date getFirstDayOfLastMonth(Date date) {
        Date addMonths = addMonths(date, -1);
        return setDays(addMonths, 1);
    }

    /**
     * 返回指定日期的上個月的最後一天
     * <p>
     * param date
     * return
     */
    public static Date getLastDayOfLastMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH) - 1, 1);
        calendar.roll(Calendar.DATE, -1);
        return calendar.getTime();
    }

    /**
     * 返回指定日期的季的第一天
     * <p>
     * param date
     * return
     */
    public static Date getFirstDayOfQuarter(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return getFirstDayOfQuarter(calendar.get(Calendar.YEAR), getQuarterOfYear(date));
    }

    /**
     * 返回指定年季的季的第一天
     * <p>
     * param year
     * param quarter
     * return
     */
    public static Date getFirstDayOfQuarter(Integer year, Integer quarter) {
        Calendar calendar = Calendar.getInstance();
        Integer month;
        if (quarter == 1) {
            month = 1 - 1;
        } else if (quarter == 2) {
            month = 4 - 1;
        } else if (quarter == 3) {
            month = 7 - 1;
        } else if (quarter == 4) {
            month = 10 - 1;
        } else {
            month = calendar.get(Calendar.MONTH);
        }
        return getFirstDayOfMonth(year, month);
    }

    /**
     * 返回當前日期的季的最後一天
     * <p>
     * param date
     * return
     */
    public static Date getLastDayOfQuarter(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return getLastDayOfQuarter(calendar.get(Calendar.YEAR), getQuarterOfYear(date));
    }

    /**
     * 返回指定年季的季的最後一天
     * <p>
     * param year
     * param quarter
     * return
     */
    public static Date getLastDayOfQuarter(Integer year, Integer quarter) {
        Calendar calendar = Calendar.getInstance();
        Integer month;
        if (quarter == 1) {
            month = 3 - 1;
        } else if (quarter == 2) {
            month = 6 - 1;
        } else if (quarter == 3) {
            month = 9 - 1;
        } else if (quarter == 4) {
            month = 12 - 1;
        } else {
            month = calendar.get(Calendar.MONTH);
        }
        return getLastDayOfMonth(year, month);
    }

    /**
     * 返回當前日期的季的第一天
     * <p>
     * param date
     * return
     */
    public static Date getFirstDayOfLastQuarter(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return getFirstDayOfLastQuarter(calendar.get(Calendar.YEAR), getQuarterOfYear(date));
    }

    /**
     * 返回指定日期的上一季的最後一天
     * <p>
     * param date
     * return
     */
    public static Date getLastDayOfLastQuarter(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return getLastDayOfLastQuarter(calendar.get(Calendar.YEAR), getQuarterOfYear(date));
    }

    /**
     * 返回指定年季的上一季的最後一天
     * <p>
     * param year
     * param quarter
     * return
     */
    public static Date getLastDayOfLastQuarter(Integer year, Integer quarter) {
        Calendar calendar = Calendar.getInstance();
        Integer month = new Integer(0);
        if (quarter == 1) {
            month = 12 - 1;
        } else if (quarter == 2) {
            month = 3 - 1;
        } else if (quarter == 3) {
            month = 6 - 1;
        } else if (quarter == 4) {
            month = 9 - 1;
        } else {
            month = calendar.get(Calendar.MONTH);
        }
        return getLastDayOfMonth(year, month);
    }

    /**
     * 返回指定年季的上一季的第一天
     * <p>
     * param year
     * param quarter
     * return
     */
    public static Date getFirstDayOfLastQuarter(Integer year, Integer quarter) {
        Calendar calendar = Calendar.getInstance();
        Integer month = new Integer(0);
        if (quarter == 1) {
            month = 12 - 3;
        } else if (quarter == 2) {
            month = 3 - 3;
        } else if (quarter == 3) {
            month = 6 - 3;
        } else if (quarter == 4) {
            month = 9 - 3;
        } else {
            month = calendar.get(Calendar.MONTH);
        }
        return getFirstDayOfMonth(year, month);
    }

    /**
     * 返回指定日期的季度
     * <p>
     * param date
     * return
     */
    public static int getQuarterOfYear(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.MONTH) / 3 + 1;
    }

    /**
     * Description:獲取當前上一季度
     */
    public static int getLastQuarterOfYear(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.MONTH) / 3;
    }


    public static Date getDateStart(Date date) throws ParseException {
        if (date == null) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        date = sdf.parse(formatDate(date, "yyyy-MM-dd") + " 00:00:00");
        return date;
    }

    public static Date getDateEnd(Date date) throws ParseException {
        if (date == null) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        date = sdf.parse(formatDate(date, "yyyy-MM-dd") + " 23:59:59");
        return date;
    }

    /**
     * 獲取指定日期的星期
     */
    public static String getDateWeek(Date date) {
        return formatDate(date, "E");
    }


    /**
     * 獲取某年某周的星期一
     * <p>
     * param y
     * param w
     * return
     */
    public static Date getBeginDate(Integer y, Integer w) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(y, 0, 1, 0, 0, 0);
        int week = calendar.get(calendar.DAY_OF_WEEK) - 1;
        int days = w * 7 - (8 - week);
        calendar.add(Calendar.DATE, days - 1);
        Date beginDate = calendar.getTime();
        return beginDate;
    }

    /**
     * 獲取某年某周的星期天
     * <p>
     * param y
     * param w
     * return
     */
    public static Date getEndDate(Integer y, Integer w) {
        Date beginDate = getBeginDate(y, w);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(beginDate);
        calendar.add(Calendar.DATE, 6);
        Date endDate = calendar.getTime();
        return endDate;
    }

    /**
     * Description:獲取進行比較的日期整型數字
     */
    public static int getDateInt(String date) {
        return Integer.parseInt(DateFormatUtils.format(DateUtil.parseDate(date), "yyyyMMdd"));
    }

    /**
     * Description:獲取進行比較的日期整型數字
     */
    public static int getDateInt(Date date) {
        return Integer.parseInt(DateFormatUtils.format(date, "yyyyMMdd"));
    }

    /**
     * 日期轉換爲 webservice UTC日期
     *
     * @param date 要轉換的 util 日期
     */
    public static XMLGregorianCalendar dateToWsXML(Date date) {
        GregorianCalendar gregorianCalendar = new GregorianCalendar();
        gregorianCalendar.setTime(date);
        XMLGregorianCalendar xmlGregorianCalendar = null;
        try {
            xmlGregorianCalendar = DatatypeFactory.newInstance().newXMLGregorianCalendar(gregorianCalendar);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return xmlGregorianCalendar;
    }

    /**
     * webservice UTC 日期轉換爲 util 日期
     *
     * @param gc webservice 封裝的 XMLGregorianCalendar 日期類型
     */
    public static Date wsXMLToDate(XMLGregorianCalendar gc) {
        GregorianCalendar gregorianCalendar = gc.toGregorianCalendar();
        return gregorianCalendar.getTime();
    }

    /**
     * 將格式爲 Thu Jun 15 16:29:24 CST 2017 的字符串格式化爲業務中須要的格式日期字符串
     *
     * @param localeEnglishDate 待轉換的格式爲 Thu Jun 15 16:29:24 CST 2017 的日期字符串
     * @param pattern           業務中須要的日期格式
     */
    public static String localeEnglishDateToFormatDate(String localeEnglishDate, String pattern) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.ENGLISH);
        Date parse = null;
        try {
            parse = simpleDateFormat.parse(localeEnglishDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return DateFormatUtils.format(parse, pattern);
    }
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.ENGLISH);
    //根據當前日期獲取本週
    public String getTimeInterval(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);
        }
        // System.out.println("要計算日期爲:" + sdf.format(cal.getTime())); // 輸出要計算日期
        // 設置一個星期的第一天，按中國的習慣一個星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 得到當前日期是一個星期的第幾天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根據日曆的規則，給當前日期減去星期幾與一個星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
        String imptimeBegin = sdf.format(cal.getTime());
        // System.out.println("所在周星期一的日期：" + imptimeBegin);
        cal.add(Calendar.DATE, 6);
        String imptimeEnd = sdf.format(cal.getTime());
        // System.out.println("所在周星期日的日期：" + imptimeEnd);
        return imptimeBegin + "," + imptimeEnd;
    }
    //根據當前日期獲取上週
    public String getLastTimeInterval() {
        Calendar calendar1 = Calendar.getInstance();
        Calendar calendar2 = Calendar.getInstance();
        int dayOfWeek = calendar1.get(Calendar.DAY_OF_WEEK) - 1;
        int offset1 = 1 - dayOfWeek;
        int offset2 = 7 - dayOfWeek;
        calendar1.add(Calendar.DATE, offset1 - 7);
        calendar2.add(Calendar.DATE, offset2 - 7);
        // System.out.println(sdf.format(calendar1.getTime()));// last Monday
        String lastBeginDate = sdf.format(calendar1.getTime());
        // System.out.println(sdf.format(calendar2.getTime()));// last Sunday
        String lastEndDate = sdf.format(calendar2.getTime());
        return lastBeginDate + "," + lastEndDate;
    }
    //根據當前日期獲取下週
    public String getNextTimeInterval() {
        Calendar calendar1 = Calendar.getInstance();
        Calendar calendar2 = Calendar.getInstance();
        int dayOfWeek = calendar1.get(Calendar.DAY_OF_WEEK) - 1;
        int offset1 = 1 - dayOfWeek;
        int offset2 = 7 - dayOfWeek;
        calendar1.add(Calendar.DATE, offset1 + 7);
        calendar2.add(Calendar.DATE, offset2 + 7);
        // System.out.println(sdf.format(calendar1.getTime()));// last Monday
        String lastBeginDate = sdf.format(calendar1.getTime());
        // System.out.println(sdf.format(calendar2.getTime()));// last Sunday
        String lastEndDate = sdf.format(calendar2.getTime());
        return lastBeginDate + "," + lastEndDate;
    }
    public static void main(String[] args) {
        try {
            Date nowDate = new Date();
            Date lastDate = addYears(nowDate, -1);

            System.out.println("01.已 yyyy-MM-dd 格式獲取日期字符串：" + getDate());
            System.out.println("02.已特定日期格式獲取日期字符串：" + getDate("yyyyMMdd"));
            System.out.println("03.已 yyyy-MM-dd HH:mm:ss 日期格式獲取特定日期字符串：" + formatDateTime(nowDate));
            System.out.println("04.已特定日期格式獲取特定日期字符串：" + formatDate(nowDate, "yyyy-MM-dd-HH:mm:ss"));

            System.out.println("05.獲取當前時間小時分秒字符串：" + getTime());
            System.out.println("06.獲取當前時間全字符串：" + getDateTime());
            System.out.println("07.獲取當前年字符串：" + getYear());
            System.out.println("08.獲取去年字符串：" + getLastYear());
            System.out.println("09.獲取當前月字符串：" + getMonth());
            System.out.println("10.獲取上一月字符串：" + getLastMonth());
            System.out.println("11.獲取當前日字符串：" + getDay());
            System.out.println("12.獲取當前星期字符串：" + getWeek());
            System.out.println("13.將日期型字符串轉化爲日期 格式：" + parseDate("yyyy-MM-dd HH:mm:ss"));
            System.out.println("14.入參與當前時間對比獲取過去的天數：" + pastDays(lastDate));
            System.out.println("15.入參與當前時間對比獲取過去的小時：" + pastHour(lastDate));
            System.out.println("16.入參與當前時間對比獲取過去的分鐘：" + pastMinutes(lastDate));
            System.out.println("17.長整型轉換爲時間（天,時:分:秒.毫秒）：" + formatDateTime(222222222));
            System.out.println("18.獲取兩個日期之間相差的天數：" + getDistanceOfTwoDate(lastDate, new Date()));

            System.out.println("19.獲取指定日期年的第一天：" + formatDate(getFirstDayOfYear(nowDate)));
            System.out.println("20.獲取指定日期年的最後一天：" + formatDate(getLastDayOfYear(nowDate)));
            System.out.println("22.獲取指定日期上一年的第一天：" + formatDate(getFirstDayOfLastYear(nowDate)));
            System.out.println("22.獲取指定日期上一年的最後一天：" + formatDate(getLastDayOfLastYear(nowDate)));

            System.out.println("23.獲得某年某周的第一天：" + formatDate(getFirstDayOfWeek(2017, 7)));
            System.out.println("24.獲得某年某周的最後一天：" + formatDate(getLastDayOfWeek(2017, 5)));
            System.out.println("25.獲得指定日期所在周的第一天：" + formatDate(getFirstDayOfWeek(nowDate)));
            System.out.println("26.獲取指定日期所在周的最後一天：" + formatDate(getLastDayOfWeek(nowDate)));
            System.out.println("27.獲取指定日期上週最後一天：" + formatDate(getLastDayOfLastWeek(nowDate)));

            System.out.println("28.獲取指定日期月的第一天：" + formatDate(getFirstDayOfMonth(nowDate)));
            System.out.println("29.獲取指定日期月的最後一天：" + formatDate(getLastDayOfMonth(nowDate)));
            System.out.println("30.獲取指定日期上月第一天：" + formatDate(getFirstDayOfLastMonth(nowDate)));
            System.out.println("31.獲取指定日期上月最後一天：" + formatDate(getLastDayOfLastMonth(nowDate)));
            System.out.println("32.獲取某年某月的第一天：" + formatDate(getFirstDayOfMonth(2016, 11)));
            System.out.println("33.獲取某年某月的最後一天：" + formatDate(getLastDayOfMonth(2016, 11)));

            System.out.println("34.獲取指定日期季度第一天：" + formatDate(getFirstDayOfQuarter(nowDate)));
            System.out.println("35.獲取指定日期季度最後一天：" + formatDate(getLastDayOfQuarter(nowDate)));
            System.out.println("36.獲取某年某月對應季度第一天：" + formatDate(getFirstDayOfQuarter(2016, 1)));
            System.out.println("37.獲取某年某月對應季度最後一天：" + formatDate(getLastDayOfQuarter(2016, 2)));
            System.out.println("38.獲取指定季度上一季度第一天：" + formatDate(getFirstDayOfLastQuarter(nowDate)));
            System.out.println("39.獲取指定季度上一季度最後一天：" + formatDate(getLastDayOfLastQuarter(nowDate)));
            System.out.println("40.獲取某年某月對應上一季度第一天：" + formatDate(getFirstDayOfLastQuarter(2016, 3)));
            System.out.println("41.獲取某年某月對應上一季度最後一天：" + formatDate(getLastDayOfLastQuarter(2016, 4)));

            System.out.println("42.獲取指定日期季度：" + getQuarterOfYear(nowDate));
            System.out.println("43.獲取指定日期上一季度：" + getLastQuarterOfYear(nowDate));
            System.out.println("44.獲取指定日期開始：" + formatDate(getDateStart(nowDate), "yyyy-MM-dd HH:mm:ss"));
            System.out.println("45.獲取指定日期結束：" + formatDate(getDateEnd(nowDate), "yyyy-MM-dd HH:mm:ss"));
            System.out.println("46.獲取指定日期星期：" + getDateWeek(nowDate));
            System.out.println("47.獲取某年某周的第一天：" + formatDate(getBeginDate(2017, 2)));
            System.out.println("48.獲取某年某周的星期天：" + formatDate(getEndDate(2016, 1)));
            System.out.println("49.獲取指定日期字符串的整數：" + getDateInt("2016-07-14"));
            System.out.println("50.獲取指定日期的整數：" + getDateInt(nowDate));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4 測試

public class Text{ 
    public statis void main(string args[]){
        String yz_time=getTimeInterval(new Date());//獲取本週時間
        String array[]=yz_time.split(",");
        String start_time=array[0];//本週第一天
        String end_time=array[1];  //本週最後一天 
          //格式化日期     
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
          Date dBegin = sdf.parse(start_time);  
          Date dEnd = sdf.parse(end_time);  
          List<Date> lDate = findDates(dBegin, dEnd);//獲取這周全部date
          for (Date date : lDate)  
          {  
           System.out.println(sdf.format(date));  
          }
     }
}