欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

java时间工具类

程序员文章站 2022-05-19 10:32:48
在项目中,很多地方需要根据时间获取相应的数据,将时间格式化,或者时间比较等相关操作。一个良好的工具类不仅可以减少代码冗余,还能促进业务处理,加快进度。 输出结果: ......

在项目中,很多地方需要根据时间获取相应的数据,将时间格式化,或者时间比较等相关操作。一个良好的工具类不仅可以减少代码冗余,还能促进业务处理,加快进度。

/**
 * @author: lxw
 * @date: 2018/12/25 14:36
 * @description: 时间工具类
 */
public class dateutils {
    /**
     * 常用时间格式
     */
    public final static string date_time_pattern = "yyyy-mm-dd hh:mm:ss";

    public final static string month_pattern = "yyyy-mm";

    public final static string date_pattern = "yyyy-mm-dd";

    public final static string hh_mm_ss = "hh:mm:ss";

    public final static string date_pattern_yyyy_mm_dd_hh_mm = "yyyy-mm-dd hh:mm";

    public static string date_time_pattern_yyyy_mm_dd_hh_mm_ss_sss = "yyyymmddhhmmsssss";

    public static string date_time_pattern_yyyy_mm_dd_hh_mm_ss = "yyyymmddhhmmss";

    /**
     * 日期转换格式数组
     */
    public static string[][] regularexp = new string[][]{

            // 默认格式
            {"\\d{4}-((([0][1,3-9]|[1][0-2]|[1-9])-([0-2]\\d|[3][0,1]|[1-9]))|((02|2)-(([1-9])|[0-2]\\d)))\\s+([0,1]\\d|[2][0-3]|\\d):([0-5]\\d|\\d):([0-5]\\d|\\d)",
                    date_time_pattern},
            // 仅日期格式 年月日
            {"\\d{4}-((([0][1,3-9]|[1][0-2]|[1-9])-([0-2]\\d|[3][0,1]|[1-9]))|((02|2)-(([1-9])|[0-2]\\d)))",
                    date_pattern},
            //  带毫秒格式
            {"\\d{4}((([0][1,3-9]|[1][0-2]|[1-9])([0-2]\\d|[3][0,1]|[1-9]))|((02|2)(([1-9])|[0-2]\\d)))([0,1]\\d|[2][0-3])([0-5]\\d|\\d)([0-5]\\d|\\d)\\d{1,3}",
                    date_time_pattern_yyyy_mm_dd_hh_mm_ss_sss}
    };

    /**
     * 日期转换为string类型
     *
     * @param date    日期
     * @param pattern 获取格式
     * @return string
     */
    public static string format(date date, string pattern) {
        if (date != null) {
            simpledateformat df = new simpledateformat(pattern);
            return df.format(date);
        }
        return null;
    }

    /**
     * 日期转换为string类型,并添加或减少相应的天数
     *
     * @param date    日期
     * @param pattern 获取格式
     * @param amount  天数
     * @return string
     */
    public static string format(date date, string pattern, int amount) {
        if (date != null) {
            calendar calendar = calendar.getinstance();
            calendar.settime(date);
            calendar.add(calendar.day_of_month, amount);
            simpledateformat df = new simpledateformat(pattern);
            return df.format(calendar.gettime());
        }
        return null;
    }

    /**
     * 字符串转换成日期
     *
     * @param strdate 日期字符串
     * @param pattern 日期的格式
     * @return data
     */
    public static date stringtodate(string strdate, string pattern) {
        if (stringutils.isblank(strdate)) {
            return null;
        }

        datetimeformatter fmt = datetimeformat.forpattern(pattern);
        return fmt.parselocaldatetime(strdate).todate();
    }

    /**
     * 两个时间之间的天数
     *
     * @param date1
     * @param date2
     * @param pattern 格式
     * @return 天数
     */
    public static long getdays(string date1, string date2, string pattern) {
        simpledateformat formatter = new simpledateformat(pattern);
        if (date1 == null || date1.equals("")) {
            return 0;
        }
        if (date2 == null || date2.equals("")) {
            return 0;
        }
        try {
            date date = formatter.parse(date1);
            date newdate = formatter.parse(date2);
            return (date.gettime() - newdate.gettime()) / (24 * 60 * 60 * 1000);
        } catch (exception e) {
        }
        return 0;
    }

    /**
     * 产生周序列,即得到当前时间所在的年度是第几周
     *
     * @return
     */
    public static string getseqweek() {
        calendar c = calendar.getinstance(locale.china);
        string week = integer.tostring(c.get(calendar.week_of_year));
        if (week.length() == 1) {
            week = "0" + week;
        }
        return week;
    }

    /**
     * 日期格式字符串转换成时间戳
     *
     * @param date_str 字符串日期
     * @param format   日期格式,如:yyyy-mm-dd hh:mm:ss
     * @return
     */
    public static string datetimestamp(string date_str, string format) {
        try {
            simpledateformat sdf = new simpledateformat(format);
            return string.valueof(sdf.parse(date_str).gettime() / 1000);
        } catch (exception e) {
            e.printstacktrace();
        }
        return "";
    }

    /**
     * 获取日期的格式
     *
     * @param date_str 日期格式字符串
     * @return 当前日期格式
     */
    public static string getdateformat(string date_str) {
        string style = null;
        if (org.springframework.util.stringutils.isempty(date_str)) {
            return null;
        }
        boolean b = false;
        for (int i = 0; i < regularexp.length; i++) {
            b = date_str.matches(regularexp[i][0]);
            if (b) {
                style = regularexp[i][1];
            }
        }
        if (org.springframework.util.stringutils.isempty(style)) {
            return null;
        }
        return style;
    }

    /**
     * 转换为时间类型格式
     *
     * @param strdate 日期
     * @return
     */
    public static date strtodate(string strdate) {
        try {
            string strtype = getdateformat(strdate);
            if (strtype == null) {
                return null;
            }
            simpledateformat sf = new simpledateformat(strtype);
            return new date((sf.parse(strdate).gettime()));
        } catch (exception e) {
            return null;
        }
    }

    /**
     * 获取两个字符串时间差
     *
     * @param begintime 开始时间
     * @param endtime   结束时间
     * @return xx小时xx分钟
     */
    public static string timelength(string begintime, string endtime) {
        if (begintime == null || "".equals(begintime)) {
            return "";
        }
        if (endtime == null || "".equals(endtime)) {
            return "";
        }
        date begin = dateutils.strtodate(begintime);
        date end = dateutils.strtodate(endtime);
        if (begin == null || end == null) {
            return "";
        }
        try {
            //除以1000是为了转换成秒
            long between = (end.gettime() - begin.gettime()) / 1000;
            int day = (int) between / (24 * 3600);
            int hour = (int) between % (24 * 3600) / 3600;
            int minute = (int) between % 3600 / 60;
            int currenthour = day * 24 + hour;
            return currenthour + "小时" + minute + "分钟";
        } catch (exception e) {
            return "";
        }
    }

    /**
     * 判断是否润年
     *
     * @param date 日期
     * @return boolean
     */
    public static boolean isleapyear(date date) {
        /**
         * 1.被400整除是闰年
         * 2.不能被4整除则不是闰年
         * 3.能被4整除同时不能被100整除则是闰年
         * 4.能被4整除同时能被100整除则不是闰年
         */
        gregoriancalendar gc = (gregoriancalendar) calendar.getinstance();
        gc.settime(date);
        int year = gc.get(calendar.year);
        if ((year % 400) == 0) {
            return true;
        } else if ((year % 4) == 0) {
            if ((year % 100) == 0) {
                return false;
            } else {
                return true;
            }
        } else {
            return false;
        }
    }

    /**
     * 取得当前时间生成格式为yyyymmddhhmmss+k位随机数
     *
     * @param k 随机数位数
     */
    public static string getno(int k) {
        date date = new date();
        return format(date, date_time_pattern_yyyy_mm_dd_hh_mm_ss) + getrandom(k);
    }

    /**
     * 返回一个随机数
     *
     * @param num 随机生成的位数
     * @return
     */
    public static string getrandom(int num) {
        random random = new random();
        if (num == 0) {
            return "";
        }
        string randomnum = "";
        for (int i = 0; i < num; i++) {
            //取0-9的随机数进行拼接
            randomnum += random.nextint(9);
        }
        return randomnum;
    }

  /**
     * 根据周数,获取开始日期、结束日期
     *
     * @param week 周期  0本周,-1上周,-2上上周,1下周,2下下周
     * @return 返回date[0]开始日期、date[1]结束日期
     */
    public static date[] getweekstartandend(int week) {
        datetime datetime = new datetime();
        localdate date = new localdate(datetime.plusweeks(week));

        date = date.dayofweek().withminimumvalue();
        date begindate = date.todate();
        date enddate = date.plusdays(6).todate();
        return new date[]{begindate, enddate};
    }

    /**
     * 对日期的【秒】进行加/减
     *
     * @param date    日期
     * @param seconds 秒数,负数为减
     * @return 加/减几秒后的日期
     */
    public static date adddateseconds(date date, int seconds) {
        datetime datetime = new datetime(date);
        return datetime.plusseconds(seconds).todate();
    }

    /**
     * 对日期的【分钟】进行加/减
     *
     * @param date    日期
     * @param minutes 分钟数,负数为减
     * @return 加/减几分钟后的日期
     */
    public static date adddateminutes(date date, int minutes) {
        datetime datetime = new datetime(date);
        return datetime.plusminutes(minutes).todate();
    }

    /**
     * 对日期的【小时】进行加/减
     *
     * @param date  日期
     * @param hours 小时数,负数为减
     * @return 加/减几小时后的日期
     */
    public static date adddatehours(date date, int hours) {
        datetime datetime = new datetime(date);
        return datetime.plushours(hours).todate();
    }

    /**
     * 对日期的【天】进行加/减
     *
     * @param date 日期
     * @param days 天数,负数为减
     * @return 加/减几天后的日期
     */
    public static date adddatedays(date date, int days) {
        datetime datetime = new datetime(date);
        return datetime.plusdays(days).todate();
    }

    /**
     * 对日期的【周】进行加/减
     *
     * @param date  日期
     * @param weeks 周数,负数为减
     * @return 加/减几周后的日期
     */
    public static date adddateweeks(date date, int weeks) {
        datetime datetime = new datetime(date);
        return datetime.plusweeks(weeks).todate();
    }

    /**
     * 对日期的【月】进行加/减
     *
     * @param date   日期
     * @param months 月数,负数为减
     * @return 加/减几月后的日期
     */
    public static date adddatemonths(date date, int months) {
        datetime datetime = new datetime(date);
        return datetime.plusmonths(months).todate();
    }

    /**
     * 对日期的【年】进行加/减
     *
     * @param date  日期
     * @param years 年数,负数为减
     * @return 加/减几年后的日期
     */
    public static date adddateyears(date date, int years) {
        datetime datetime = new datetime(date);
        return datetime.plusyears(years).todate();
    }

    /**
     * 比较时间大小
     *
     * @param exprtime 时间1
     * @param times    时间2
     * @return 0:时间相等 1;时间1在时间2之后 -1:时间1在时间2之前
     */
    public static int comparedate(string exprtime, string times) {
        int result = 0;
        //判断时间大小
        if (exprtime != null && !"".equals(exprtime)) {
            dateformat dateformat = new simpledateformat(date_time_pattern);
            try {
                date d1 = dateformat.parse(exprtime);
                date d2 = dateformat.parse(times);
                if (d1.gettime() > d2.gettime()) {
                    system.out.println(d1 + "在" + d2 + "之后");
                    result = 1;
                } else if (d1.gettime() < d2.gettime()) {
                    result = -1;
                    system.out.println(d1 + "在" + d2 + "之前");
                } else {
                    system.out.println(d1 + "=" + d2);
                }
            } catch (parseexception e) {
                e.printstacktrace();
                system.out.println("方法——comparedate异常");
            }
        }
        return result;
    }

    /**
     * 获取距离现在的天数
     *
     * @param exprtime 某天的时间字符串
     * @return 天数
     */
    public static long getdays(string exprtime) {
        date begin = dateutils.strtodate(format(new date(), date_time_pattern));
        date end = dateutils.strtodate(exprtime);
        long between = (end.gettime() - begin.gettime()) / 1000;
        int day = (int) between / (24 * 3600);
        return day;
    }
```
测试类方法:

```
 public static void main(string[] args) {
          date date = new date();
        string datestring = dateutils.format(date, date_time_pattern);
        system.out.println("时间格式转换为:" + datestring);

        string tomorrow = dateutils.format(date, date_time_pattern, 1);
        system.out.println("明天日期:" + tomorrow);

        date stringtodate = dateutils.stringtodate(datestring, date_time_pattern);
        system.out.println("当天日期格式:" + stringtodate);

        boolean flag = dateutils.isleapyear(date);
        system.out.println("当前是否为闰年:" + flag);

        long days = dateutils.getdays(tomorrow, datestring, date_pattern);
        system.out.println("天数相差:" + days + " 天");

        string getseqweek = dateutils.getseqweek();
        system.out.println("今年第 " + getseqweek + " 周");

        string randomnum = dateutils.getno(4);
        system.out.println("编号:" + randomnum);

        string datetimestamp = dateutils.datetimestamp(datestring, date_time_pattern);
        system.out.println("当期时间戳:" + datetimestamp);

        string timelength = dateutils.timelength(datestring, tomorrow);
        system.out.println("相差时间:" + timelength);

        string getdateformat = dateutils.getdateformat(datestring);
        system.out.println("当前日期格式:" + getdateformat);

        string stmpstring = dateutils.stamptodate("1545732716");
        system.out.println("当前日期:" + stmpstring);

        string stmplong = dateutils.stamptodate(1545732716l);
        system.out.println("当前日期:" + stmplong);

        long day = dateutils.getdays("2019-01-01 18:20:20");
        system.out.println("距离当前时间:" + day + "天");
    }

输出结果:

时间格式转换为:2018-12-25 18:21:23
明天日期:2018-12-26 18:21:23
当天日期格式:tue dec 25 18:21:23 cst 2018
当前是否为闰年:false
天数相差:1 天
今年第 52 周
编号:201812251821237084
当期时间戳:1545733283
相差时间:24小时0分钟
当前日期格式:yyyy-mm-dd hh:mm:ss
当前日期:1970-01-19 05:22:12
当前日期:1970-01-19 05:22:12
距离当前时间:6天