`
sdfiyon
  • 浏览: 22138 次
  • 性别: Icon_minigender_1
  • 来自: 济南
社区版块
存档分类
最新评论

日期时间工具类

    博客分类：
  • J2EE
javaDateUtils日期时间 
阅读更多

 

package cn.fiyo.base.util;

import java.util.Locale;

import java.util.Date;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class DateUtils {

    /**数据库存储的时间格式串，如yyyymmdd 或yyyymmddHHMiSS*/
    public static final int DB_STORE_DATE = 1;
    /**用连字符-分隔的时间时间格式串，如yyyy-mm-dd 或yyyy-mm-dd HH:Mi:SS*/
    public static final int HYPHEN_DISPLAY_DATE = 2;
    /**用连字符.分隔的时间时间格式串，如yyyy.mm.dd 或yyyy.mm.dd HH:Mi:SS*/
    public static final int DOT_DISPLAY_DATE = 3;
    /**用中文字符分隔的时间格式串，如yyyy年mm月dd 或yyyy年mm月dd HH:Mi:SS*/
    public static final int CN_DISPLAY_DATE = 4;
    /*****数据库存储时间格式串,如yyyymmddHHMissSS**/
    public static final int DB_LONG_DATE = 5;
    

    /**
     * 得到精确到秒的格式化当前时间串
     * @param formatType 时间格式的类型{@link #DB_STORE_DATE},{@link #EN_HTML_DISPLAY_DATE},{@link #CN_HTML_DISPLAY_DATE}
     * @return 当前时间格式化时间串
     */
    public static String getCurrTimeStr(int formatType) {
        return getTimeStr(new Date(), formatType);
    }

    /**
     * 得到精确到秒的格式化时间串
     * @param date 指定时间
     * @param formatType 时间格式的类型{@link #DB_STORE_DATE},{@link #EN_HTML_DISPLAY_DATE},{@link #CN_HTML_DISPLAY_DATE}
     * @return 指定时间的格式化时间串
     */
    public static String getTimeStr(Date date, int formatType) {
        if (formatType < DB_STORE_DATE || formatType > DB_LONG_DATE) {
            throw new IllegalArgumentException("时间格式化类型不是合法的值。");
        } else {
            String formatStr = null;
            switch (formatType) {
            case DB_STORE_DATE:
                formatStr = "yyyyMMddHHmmss";
                break;
            case HYPHEN_DISPLAY_DATE:
                formatStr = "yyyy'-'MM'-'dd HH:mm:ss";
                break;
            case DOT_DISPLAY_DATE:
                formatStr = "yyyy.MM.dd HH:mm:ss";
                break;
            case CN_DISPLAY_DATE:
                formatStr = "yyyy'年'MM'月'dd'日' HH:mm:ss";
                break;
            case DB_LONG_DATE:
                formatStr = "yyyyMMddHHmmssSS";
            }
            SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
            return sdf.format(date);
        }
    }

    /**
     * 得到精确到天的当前格式化日期串
     * @param formatType 时间格式的类型{@link #DB_STORE_DATE},{@link #EN_HTML_DISPLAY_DATE},{@link #CN_HTML_DISPLAY_DATE}
     * @return
     */
    public static String getCurrDateStr(int formatType) {
        return getDateStr(new Date(), formatType);
    }

    /**
     * 得到精确到天的指定时间格式化日期串
     * @param date 指定时间
     * @param formatType 时间格式的类型{@link #DB_STORE_DATE},{@link #EN_HTML_DISPLAY_DATE},{@link #CN_HTML_DISPLAY_DATE}
     * @return 指定时间格式化日期串
     */
    public static String getDateStr(Date date, int formatType) {

        if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
            throw new IllegalArgumentException("时间格式化类型不是合法的值。");
        } else {
            String formatStr = null;
            switch (formatType) {
            case DB_STORE_DATE:
                formatStr = "yyyyMMdd";
                break;
            case HYPHEN_DISPLAY_DATE:
                formatStr = "yyyy-MM-dd";
                break;
            case DOT_DISPLAY_DATE:
                formatStr = "yyyy.MM.dd";
                break;
            case CN_DISPLAY_DATE:
                formatStr = "yyyy'年'MM'月'dd'日'";
                break;
            }
            SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
            return sdf.format(date);
        }
    }

    /**
     * 得到精确到月的当前时间格式化年月串
     * @param formatType 时间格式的类型{@link #DB_STORE_DATE},{@link #EN_HTML_DISPLAY_DATE},{@link #CN_HTML_DISPLAY_DATE}
     * @return 精确到月当前时间格式化年月串
     */
    public static String getYearMonthStr(int formatType) {
        return getYearMonthStr(new Date(), formatType);
    }

    /**
     * 得到精确到月的指定时间格式化年月串
     * @param date 指定的时间
     * @param formatType 时间格式的类型{@link #DB_STORE_DATE},{@link #EN_HTML_DISPLAY_DATE},{@link #CN_HTML_DISPLAY_DATE}
     * @return 精确到月当前时间格式化年月串
     */
    public static String getYearMonthStr(Date date, int formatType) {
        if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
            throw new IllegalArgumentException("时间格式化类型不是合法的值。");
        } else {
            String formatStr = null;
            switch (formatType) {
            case DB_STORE_DATE:
                formatStr = "yyyyMM";
                break;
            case HYPHEN_DISPLAY_DATE:
                formatStr = "yyyy-MM";
                break;
            case DOT_DISPLAY_DATE:
                formatStr = "yyyy.MM";
                break;
            case CN_DISPLAY_DATE:
                formatStr = "yyyy'年'MM'月'";
                break;
            }
            SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
            return sdf.format(date);
        }
    }

    /**
     * 将数据库存储的日期格式串转换为各种显示的格式
     * @param dateStr 最小6位，最大14位的数据库存储格式时间串如:20041212
     * @param formatType 时间格式的类型{@link #DB_STORE_DATE},{@link #EN_HTML_DISPLAY_DATE},{@link #CN_HTML_DISPLAY_DATE}
     * @return 格式化的时间串
     */
    public static String toDisplayStr(String dateStr, int formatType) {
        if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
            throw new IllegalArgumentException("时间格式化类型不是合法的值。");
        }
        if (dateStr == null || dateStr.length() < 6 || dateStr.length() > 14 ||
            formatType == DB_STORE_DATE) {
            return StringUtils.toVisualString(dateStr);
        } else {
            char[] charArr = null;
            switch (formatType) {
            case HYPHEN_DISPLAY_DATE:
                charArr = new char[] {
                          '-', '-', ' ', ':', ':'};
                break;
            case DOT_DISPLAY_DATE:
                charArr = new char[] {
                          '.', '.', ' ', ':', ':'};
                break;
            case CN_DISPLAY_DATE:
                charArr = new char[] {'年','月',' ', ':', ':'};
                break;
            default:
                charArr = new char[] {
                          '-', '-', ' ', ':', ':'};
            }
            try {
                SimpleDateFormat sdf_1 = null;
                SimpleDateFormat sdf_2 = null;
                switch (dateStr.length()) {
                case 6:
                    sdf_1 = new SimpleDateFormat("yyyyMM");
                    sdf_2 = new SimpleDateFormat("yyyy'" + charArr[0] +
                                                 "'MM");
                    break;
                case 8:
                    sdf_1 = new SimpleDateFormat("yyyyMMdd");
                    sdf_2 = new SimpleDateFormat("yyyy'" + charArr[0] +
                                                 "'MM'" + charArr[1] + "'dd");
                    break;
                case 10:
                    sdf_1 = new SimpleDateFormat("yyyyMMddHH");
                    sdf_2 = new SimpleDateFormat("yyyy'" + charArr[0] +
                                                 "'MM'" + charArr[1] + "'dd'" +
                                                 "+charArr[2]" +
                                                 "'HH");
                    break;
                case 12:
                    sdf_1 = new SimpleDateFormat("yyyyMMddHHmm");
                    sdf_2 = new SimpleDateFormat("yyyy'" + charArr[0] +
                                                 "'MM'" + charArr[1] + "'dd'" +
                                                 charArr[2] +
                                                 "'HH'" + charArr[3] + "'mm");
                    break;
                case 14:
                    sdf_1 = new SimpleDateFormat("yyyyMMddHHmmss");
                    sdf_2 = new SimpleDateFormat(
                            "yyyy'" + charArr[0] + "'MM'" + charArr[1] +
                            "'dd'" + charArr[2] + "'HH'" + charArr[3] +
                            "'mm'" + charArr[4] + "'ss");
                    break;
                default:
                    return dateStr;
                }
                return sdf_2.format(sdf_1.parse(dateStr));
            } catch (ParseException ex) {
                return dateStr;
            }
        }
    }

    /**
     * 将显示格式的时间字符串转换为数据库存储的类型
     * @param dateStr 最小4位，最大19位。显示的时间格式时间串如:2004-12-12
     * @return 数据库存储的时间字符串
     */
    public static String toStoreStr(String dateStr) {
        if (dateStr == null || dateStr.trim().equals("")) {
            return "";
        }
        StringBuffer strBuf = new StringBuffer();
        for (int i = 0; i < dateStr.length(); i++) {
            if (dateStr.charAt(i) >= '0' && dateStr.charAt(i) <= '9') {
                strBuf.append(dateStr.charAt(i));
            }
        }
        return strBuf.toString();
    }


    /**
     * <b>功能描述：</b>
     *    把时间转换成14位的字符串，不足位数补充 0 或者 9
     * @param dateStr String
     * @param key int
     * @return String
     */
    public static String toStoreStr14(String dateStr, boolean bMax) {
        if (dateStr == null || dateStr.trim().equals("")) {
            return "";
        }
        StringBuffer strBuf = new StringBuffer(toStoreStr(dateStr));
        String retStr = strBuf.toString();
        if (bMax) {
            retStr = StringUtils.pad(retStr, 14, '9', true);
        } else {
            retStr = StringUtils.pad(retStr, 14, '0', true);
        }
        return retStr;
    }


    /**
     * 将生日存储的时间格式转化为年龄（周岁，小数点后不计）
     * @param birthdayStr 生日字段  "yyyymmdd"
     * @return 年龄
     */
    public static String birthdayToAge(String birthdayStr) {
        if (birthdayStr == null || birthdayStr.length() < 6) {
            return "";
        } else {
            int birthYear = Integer.parseInt(birthdayStr.substring(0, 4));
            int birthMonth = Integer.parseInt(birthdayStr.substring(4, 6));
            Calendar cal = new GregorianCalendar();
            int currYear = cal.get(Calendar.YEAR);
            int currMonth = cal.get(Calendar.MONTH);
            int age = currYear - birthYear;
            age -= (currMonth < birthMonth) ? 1 : 0;
            return "" + age;
        }
    }

    /**
     * 功能描述:
     *    将年龄转换为生日
     * @param age int
     * @return String
     */
    public static String ageToBirthday(int age) {

        String currDateStr = DateUtils.getYearMonthStr(DB_STORE_DATE);
        int currDateInt = Integer.parseInt(currDateStr);
        int ageDateInt = currDateInt - age * 100;
        return String.valueOf(ageDateInt);
    }


    /**
     * 功能描述:
     *    增加一年
     * @param age int
     * @return String
     */
    public static String nextAgeDate(String birDate) {

        int currDateInt = Integer.parseInt(birDate);
        int ageDateInt = currDateInt + 100;
        return String.valueOf(ageDateInt);
    }





    /**
     *
     * @param dateTimeStr String 格式化的时间串
     * @param formatType 数据格式类型 {@link #DB_STORE_DATE},{@link #EN_HTML_DISPLAY_DATE},{@link #CN_HTML_DISPLAY_DATE}
     * @param detal int  增加或减少的时间
     * @param field int 参见Calendar中关于时间字段属性的定义
     * @return String 返回的
     */
    public static String add(String dateTimeStr, int formatType, int detal,
                             int field) {
        if (dateTimeStr == null || dateTimeStr.length() < 6) {
            return dateTimeStr;
        } else {
            try {
                String formatStr = null;
                switch (formatType) {
                case DB_STORE_DATE:
                    formatStr = "yyyyMMddHHmmss";
                    break;
                case HYPHEN_DISPLAY_DATE:
                    formatStr = "yyyy-MM-dd HH:mm:ss";
                    break;
                case DOT_DISPLAY_DATE:
                    formatStr = "yyyy.MM.dd HH:mm:ss";
                    break;
                case CN_DISPLAY_DATE:
                    formatStr = "yyyy'年'MM'月' HH：mm：ss";
                    break;
                default:
                    formatStr = "yyyyMMddHHmmss";
                    break;
                }

                formatStr = formatStr.substring(0, dateTimeStr.length());
                SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
                Date d = sdf.parse(dateTimeStr);
                GregorianCalendar g = new GregorianCalendar();
                g.setTime(d);
                g.add(field, detal);
                d = g.getTime();
                return sdf.format(d);
            } catch (ParseException ex) {
                ex.printStackTrace();
                return dateTimeStr;
            }
        }
    }

//    /**
//     * @param date Date 时间
//     * @param detal int 增加的时间
//     * @param field int 参见Calendar中关于时间字段属性的定义
//     * @return Date
//     */
//    public static Date add(Date date, int detal, int field)
//    {
//        Calendar g = new GregorianCalendar();
//        g.setTime(date);
//        g.add(field, detal);
//        return g.getTime();
//    }
    /**
     * 日期、时间格式化
     * @param date Date
     * 将要被格式化的日期对象
     * @param outFmt String
     * 返回样式，参照类说明，如：yyyy年MM月dd日
     * @return String
     * 格式化后的日期、时间字符串，data为null时返回null，outFmt非法时返回yyyyMMdd格式
     */
    public static String getDateFormat(Date date, String outFmt) {
        if (null == date) {
            return null;
        }
        if (null == outFmt || "".equals(outFmt.trim())) { //outFmt非法
            outFmt = "yyyyMMdd";
        }

        String retu = null;
        SimpleDateFormat dateFormat = null;
        try {
            dateFormat = new SimpleDateFormat(outFmt);
        } catch (IllegalArgumentException iaex) { //outFmt非法
            dateFormat = new SimpleDateFormat("yyyyMMdd");
        }
        retu = dateFormat.format(date);

        dateFormat = null;

        return retu;
    }

    /**
     * 把日期时间对象格式化为yyyyMMdd样式
     * @param date Date
     * 将要被格式化的日期对象
     * @return String
     * 格式化后的日期、时间字符串，如：20041001
     */
    public static String getDateFormat(Date date) {
        return getDateFormat(date, "yyyyMMdd");
    }

    /**
     * 把系统当前日期时间格式化为指定的样式
     * @param outFmt String
     * 返回样式，参照类说明，如：yyyy年MM月dd日
     * @return String
     * 格式化后的日期、时间字符串，如：2004年10月01日
     */
    public static String getDateFormat(String outFmt) {
        return getDateFormat(new Date(), outFmt);
    }

    /**
     * 把系统当前日期时间格式化为默认样式yyyyMMdd
     * @return String
     * 格式化后的日期、时间字符串，如：20041001
     */
    public static String getDateFormat() {
        return getDateFormat(new Date(), "yyyyMMdd");
    }

    /**
     * 日期、时间格式化
     * @param millis long
     * the number of milliseconds（毫秒） since January 1, 1970, 00:00:00 GMT.
     * @param outFmt String
     * 返回样式，参照类说明，如：yyyy年MM月dd日
     * @return String
     * 格式化后的日期、时间字符串
     */
    public static String getDateFormat(long millis, String outFmt) {
        Date d = new Date(millis);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(d);
        String retu = getDateFormat(calendar.getTime(), outFmt);
        calendar = null;
        return retu;
    }

    /**
     * 日期、时间格式化
     * @param datestr String
     * 存在一定格式的日期、时间字符串，如：20041001、200410011503
     * @param inFmt String
     * 对datestr参数格式说明，参照类说明，如：yyyyMMdd、yyyyMMddHHmm
     * @param outFmt String
     * 返回样式，参照类说明，如：yyyy年MM月dd日
     * @throws ParseException 当datestr不能格式化为inFmt格式时抛出此异常
     * @return String
     * 格式化后的日期、时间字符串，如：2004年10月01日、2004年10月01日
     * <BR>输出样式outFmt非法时，使用yyyyMMdd格式输出
     */
    public static String getDateFormat(String datestr, String inFmt,
                                       String outFmt) throws ParseException {
        if (null == datestr || "".equals(datestr.trim())) {
            return datestr;
        }

        if (null == inFmt || "".equals(inFmt.trim())) {
            return datestr;
        }

        if (null == outFmt || "".equals(outFmt.trim())) { //输出样式非法
            outFmt = "yyyyMMdd";
        }

        java.util.Date inDate = getDate(datestr, inFmt);

        if (null == inDate) { //根据inFmt分析datestr时抛出异常
            return datestr;
        }

        String retu = getDateFormat(inDate, outFmt);
        inDate = null;
        return retu;
    }

    /**
     * 把日期时间字符串，按inFmt样式转化为日期对象，然后格式化为默认样式yyyyMMdd
     * @param datestr String
     * 存在一定格式的日期、时间字符串，如：20041001、200410011503
     * @param inFmt String
     * 对datestr参数格式说明，参照类说明，如：yyyyMMdd、yyyyMMddHHmm
     * @throws ParseException 当datestr不能格式化为inFmt格式时抛出此异常
     * @return String
     * 格式化后的日期、时间字符串，如：20041001、20041001
     */
    public static String getDateFormat(String datestr, String inFmt) throws
            ParseException {
        return getDateFormat(datestr, inFmt, "yyyyMMdd");
    }

    /**
     * 根据inFmt的样式，日期时间字符串转化为日期时间对象
     * @param datestr String
     * 日期时间字符串，如：20041001、2004年10月01日 15:03
     * @param format String
     * 对datestr参数格式说明，参照类说明，如yyyyMMdd、yyyy年MM月dd日 HH:mm
     * @throws ParseException 当datestr不能格式化为inFmt格式时抛出此异常
     * @return Date
     * 日期时间对象，格式inFmt非法时，使用yyyyMMdd格式
     */
    public static Date getDate(String datestr, String format){
        if (StringUtils.isEmpty(datestr)) {
            return null;
        }
        if (StringUtils.isEmpty(format)) { //inFmt非法
            format = "yyyyMMdd";
        }

        try {
//依据inFmt格式把日期字符串转化为日期对象
            SimpleDateFormat dateFormat = new SimpleDateFormat(format);
            dateFormat.setLenient(true);
            return dateFormat.parse(datestr);
        } catch (ParseException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * 对日期时间对象进行调整，实现如昨天是几号，去年的今天星期几等.
     * <BR>例子：
     * <pre>
     * <blockquote>
     * 计算去年今天星期几
     * Date date = DateUtils.addDate(new Date(),Calendar.YEAR,-1);
     * System.out.println(DateUtils.getDateFormat(date,"E"));
     * 打印60天后是什么日期，并显示为 yyyy-MM-dd 星期
     * Date date = DateUtils.addDate(new Date(),Calendar.DATE,60);
     * System.out.println(DateUtils.getDateFormat(date,"yyyy-MM-dd E"));
     * </blockquote>
     * </pre>
     * @param date Date
     * 需要调整的日期时间对象
     * @param CALENDARFIELD int
     * 对日期时间对象以什么单位进行调整：
     * <pre>
     * <blockquote>
     * 年 Calendar.YEAR
     * 月 Calendar.MONTH
     * 日 Calendar.DATE
     * 时 Calendar.HOUR
     * 分 Calendar.MINUTE
     * 秒 Calendar.SECOND
     * </blockquote>
     * </pre>
     * @param amount int
     * 调整数量，>0表向后调整（明天，明年），<0表向前调整（昨天，去年）
     * @return Date
     * 调整后的日期时间对象
     */
    public static Date addDate(Date date, int CALENDARFIELD, int amount) {
        if (null == date) {
            return date;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(CALENDARFIELD, amount);
        return calendar.getTime();
    }

    /**
     * 对日期时间对象进行调整.
     * @param datestr String
     * 需要调整的日期时间字符串，它的格式为yyyyMMdd
     * @param CALENDARFIELD int
     * 对日期时间对象以什么单位进行调整
     * @param amount int
     * 调整数量
     * @throws ParseException 当datestr不能格式化为yyyyMMdd格式时抛出此异常
     * @return Date
     * 调整后的日期时间对象
     * @see #addDate(java.util.Date, int, int)
     */
    public static Date addDate(String datestr, int CALENDARFIELD, int amount) throws
            ParseException {
        return addDate(getDate(datestr, "yyyyMMdd"), CALENDARFIELD, amount);
    }

    /**
     * 根据出生日期，计算出在某一个日期的年龄
     * @param birthday Date
     * 出生日期时间对象
     * @param date2 Date
     * 计算日期对象
     * @return int
     * 返回date2那一天出生日期为birthday的年龄，如果birthday大于date2则返回-1
     */
    public static int getAge(Date birthday, Date date2) {
        if (null == birthday || null == date2) {
            return -1;
        }

        if (birthday.after(date2)) { //birthday大于date2
            return -1;
        }

        int ibdYear = StringUtils.getInt(getDateFormat(birthday, "yyyy"), -1);
        int idate2Year = StringUtils.getInt(getDateFormat(date2, "yyyy"), -1);

        if (ibdYear < 0 || idate2Year < 0) {
            return -1;
        }
        if (ibdYear > idate2Year) {
            return -1;
        }

        return idate2Year - ibdYear + 1;
    }

    /**
     * 根据出生日期，计算出当前的年龄
     * @param birthday Date
     * 出生日期时间对象
     * @return int
     * 返回出生日期为birthday的年龄，如果birthday大于当前系统日期则返回-1
     */
    public static int getAge(Date birthday) {
        return getAge(birthday, new Date());
    }

    /**
     * 根据出生日期，计算出当前的年龄
     * @param birthdaystr String
     * 出生日期时间字符串，其格式一定为yyyyMMdd
     * @throws ParseException 当datestr不能格式化为yyyyMMdd格式时抛出此异常
     * @return int
     * 返回出生日期为birthday的年龄，如果birthday大于当前系统日期则返回-1
     */
    public static int getAge(String birthdaystr) throws ParseException {
        return getAge(getDate(birthdaystr, "yyyyMMdd"));
    }


}

 

分享到：
| Json工具类
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java日期时间工具类超级全

    java日期时间工具类超级全。其中包含：获得当前日期 yyyy-MM-dd HH:mm:ss；获取系统当前时间戳；获取当前日期 yy-MM-dd；得到两个时间差 格式yyyy-MM-dd HH:mm:ss；转化long值的日期为yyyy-MM-dd HH:mm:ss.SSS格式的...

    java操作日期时间工具类

    在Java编程语言中，处理日期和...总之，一个良好的日期时间工具类应该简化日期时间的常见操作，提高代码的可读性和可维护性。在Java 8及更高版本中，可以考虑利用`java.time`包提供的新特性来进一步优化工具类的设计。

    自己整理的日期时间工具类

    ### 一、日期时间工具类的作用与应用场景 日期时间工具类主要用于处理日期和时间相关的操作，比如日期的格式化、解析、比较等。在实际开发中，此类工具类十分常见，因为几乎所有的应用都会涉及到日期和时间的处理。...

    java日期时间工具类

    java日期时间工具类,里面主要包括了日期与字符串之间的相互转换，以及输出指定的日期格式

    java 日期时间工具类 日期时间的加减 身份证号上的日期是否小于2岁等

    java 日期时间工具类 日期时间的加减 身份证号上的日期是否小于2岁等

    时间工具类

    时间类型方面很好用的工具类，包括时间类型的转化与计算等

    最全的java时间(日期)工具类

    本文将深入探讨Java中的日期时间工具类，特别是基于给定的"DateUtil.java"文件，我们将聚焦在传统`java.util.Date`和`java.text.SimpleDateFormat`以及Java 8的`java.time`包中的相关类。 首先，我们来看看`java....

    日期时间处理工具类

    这是一个比较全面的处理日期时间的工具类，利用该工具类可以得到你想要的日期时间。里面代码简洁，方法已经封装好，只需要调用即可。自己可以将其打成jar包来用

    Java 日期比较工具类

    Java 日期比较工具类 各种日期操作及计算（ 获取两个日期 间隔天数 间隔月数 格式化日期 ）

    android工具类 26个实用工具类

    3. **日期时间工具类**：例如`DateUtil`，可以方便地进行日期时间的转换，如将日期字符串转化为日期对象，或者计算两个日期之间的差值。 4. **JSON解析工具类**：如`JsonUtil`，用于解析JSON字符串到Java对象，或把...

    Android开发常用工具类

    2. **日期时间工具类**： - `DateUtils`：提供了对日期和时间的处理，如格式化日期、计算两个日期之间的差值、获取当前时间等。 - `TimeUtils`：包含与时间相关的操作，例如将毫秒值转换为友好的显示格式。 3. **...

    最新版工具类

    2. **日期时间工具类**：`DateUtils`或`TimeUtils`，可以帮助开发者进行日期和时间的格式化、比较、计算差值等操作，简化对`java.util.Date`和`java.time`API的使用。 3. **网络请求工具类**：Android应用经常需要...

    操作日期时间的工具类，封装的比较完善

    java写的，操作日期时间的工具类，封装的比较完善，可以获取最小时间， 获取最大时间，获取今天最小时间，获取今天最大时间，获取明天的最小时间，获取明天的最大时间，获取昨天的最小时间，获取昨天的最大时间，...

    java操作工具类

    4. **日期时间工具类**: 这类工具类通常提供了日期时间的格式化、解析、比较、计算等功能，以简化对`Date`和`Calendar`的操作。例如，`DateUtils`可以方便地进行日期时间的加减操作，`DateFormatUtils`则用于格式化...

    android开发各种工具类

    2. **日期时间工具类** (DateTimeUtil) - `getNow()`：获取当前时间戳或格式化的当前日期时间。 - `formatDate()`：将时间戳转换为指定格式的日期字符串。 - `compareDate()`：比较两个日期的先后顺序。 3. **...

    Java工具类

    1. **日期时间工具类**： 这个工具类通常用于处理日期和时间相关的操作，如获取当前日期、格式化日期字符串、计算两个日期之间的差值等。Java 8引入了`java.time`包，提供了更强大的日期和时间API，但这个工具类...

    java常用工具类封装util.rar

    2. **日期时间工具类(DateUtil)**：在Java中，日期和时间操作往往比较复杂，这类工具类会提供方便的方法来解析、格式化日期，进行日期的加减操作等。例如`parse()`用于将字符串转换为日期对象，`format()`则可将日期...

    日期处理工具类

    "日期处理工具类"通常是指一个自定义的类，它封装了一些常用的方法，例如日期格式化、字符串转换为日期以及对日期进行加减操作。这个类可能是开发者为了提高代码复用性和简化日期处理逻辑而创建的。 首先，让我们...

    android 开发常用到的工具类集锦

    4. **日期时间工具类**：处理日期和时间在Android开发中非常常见，例如格式化日期、计算时间差等。Android提供了一些基础的日期时间API，但往往不够灵活，所以开发者会自定义或者使用第三方库如ThreeTenABP，提供更...

    日期转换工具类

    ### 日期转换工具类 #### 知识点概述 本文将详细介绍一个名为`DateTimeUtil`的Java工具类，该类提供了日期格式化和解析的功能。此类利用了`org.joda.time`包中的`DateTime`和`DateTimeFormat`类来实现字符串与日期...

Magicbox
Global site tag (gtag.js) - Google Analytics