获取时间整形（Integer）类型工具类

最新推荐文章于 2023-01-04 16:42:30 发布
最新推荐文章于 2023-01-04 16:42:30 发布
阅读量636 收藏
点赞数
分类专栏： 工具类 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/meser88/article/details/121085076
版权

依赖

    <!-- https://mvnrepository.com/artifact/joda-time/joda-time -->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.10</version>
        </dependency>

官网：https://www.joda.org/joda-time/quickstart.html 

package org.demo.util;


import com.google.common.collect.Lists;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.joda.time.Days;
import org.joda.time.LocalDate;
import org.joda.time.Months;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;

public class JodaTimeUtilAll {

    private static Logger logger = LoggerFactory.getLogger(JodaTimeUtilAll.class);

    /**
     * 当前的年月日 整形
     *
     * @return yyyyMMdd
     */
    public static String getNow() {
        return formatDateTime(new Date());
    }

    /**
     * 当前的年月日 整形
     *
     * @return yyyyMMdd
     */
    public static Integer getNowYmd() {
        DateTime dt = DateTime.now();
        return getYmd(dt);
    }

    /**
     * 当前的年月日+day 整形
     *
     * @return yyyyMMdd
     */
    public static Integer getNowYmd(int day) {
        DateTime dt = DateTime.now();
        dt = dt.plusDays(day);
        return getYmd(dt);
    }

    public static Integer getYmd(DateTime dt) {
        int ymd = dt.getYear() * 100000 + dt.getMonthOfYear() * 1000 + dt.getDayOfMonth() * 10;
        return Integer.valueOf(ymd / 10);
    }


    public static Integer getYmd(LocalDate ld) {
        int ymd = ld.getYear() * 100000 + ld.getMonthOfYear() * 1000 + ld.getDayOfMonth() * 10;
        return Integer.valueOf(ymd / 10);
    }

    /**
     * 当前的年月日+day 整形
     *
     * @return yyyyMMdd
     */
    public static Integer getDateYmd(Integer ymd, int day) {
        LocalDate ld = DateTimeFormat.forPattern("yyyyMMdd").parseLocalDate(String.valueOf(ymd));
        ld = ld.plusDays(day);
        return getYmd(ld);
    }

    /**
     * 当前的年月日+day 整形
     *
     * @return yyyyMMdd
     */
    public static Integer getDateYmdPlusMonth(Integer ymd, int month) {
        LocalDate ld = DateTimeFormat.forPattern("yyyyMMdd").parseLocalDate(String.valueOf(ymd));
        ld = ld.plusMonths(month);
        return getYmd(ld);
    }


    /**
     * 获取日期累加的天数的某个时间
     *
     * @param date 日期
     * @param day  间隔的天数
     * @param hms  开始时间、当前时间、结束时间
     * @return 日期
     */
    public static Date getDatePlusDays(Date date, int day, int hms) {
        DateTime dt = new DateTime(date.getTime());
        if (day != 0) {
            dt = dt.plusDays(day);
        }
        return (hms == 0 ? dt : (hms >= 1 ? dt.millisOfDay().withMaximumValue() :
                dt.millisOfDay().withMinimumValue())).toDate();
    }

    /**
     * 获取日期累加的天数的某个时间
     *
     * @param ymd 日期
     * @param day 间隔的天数
     * @param hms 开始时间、当前时间、结束时间
     * @return 日期
     */
    public static Date getYmdPlusDays(Integer ymd, int day, int hms) {
        DateTime dt = DateTimeFormat.forPattern("yyyyMMdd").parseDateTime(String.valueOf(ymd));
        if (day != 0) {
            dt = dt.plusDays(day);
        }
        return (hms == 0 ? dt : (hms >= 1 ? dt.millisOfDay().withMaximumValue() :
                dt.millisOfDay().withMinimumValue())).toDate();
    }

    /**
     * 获取指定日期的年月日 整形
     *
     * @param date 日期
     * @return yyyyMMdd
     */
    public static Integer getDateYmd(Date date) {
        DateTime dt = new DateTime(date.getTime());
        return getYmd(dt);
    }

    public static Integer getDateYmd(String dateStr, String pattern) {
        Date date = parseDate(dateStr, pattern);
        if (date == null) {
            return null;
        }
        DateTime dt = new DateTime(date.getTime());
        return getYmd(dt);
    }

    /**
     * 获取指定日期的之后的日期
     *
     * @param dateStr 指定日期
     * @param after   +天数
     * @return 返回格式："yy-MM-dd"
     */
    public static String getDayAfterDateYmd(String dateStr, int after) {
        if (StringUtils.isEmpty(dateStr)) {
            return null;
        }
        try {
            Calendar c = Calendar.getInstance();
            Date date = new SimpleDateFormat("yy-MM-dd").parse(dateStr);
            c.setTime(date);
            int day = c.get(Calendar.DATE);
            c.set(Calendar.DATE, day + after);
            return new SimpleDateFormat("yyyy-MM-dd").format(c.getTime());
        } catch (ParseException e) {
            logger.error("获取指定日期之后的日期异常：{}", e);
            return null;
        }
    }

    /**
     * 批次号，追加当前的时分秒
     *
     * @param batchNo 批次号
     * @return 批次号+时分秒
     */
    public static String getBatchNoHms(String batchNo) {
        DateTime dt = DateTime.now();
        StringBuilder builder = new StringBuilder(batchNo);
        builder.append(String.format("%02d", dt.getHourOfDay()))
                .append(String.format("%02d", dt.getMinuteOfHour()))
                .append(String.format("%02d", dt.getSecondOfMinute()));
        return builder.toString();
    }

    public static String currentStackTrace() {
        StringBuilder sb = new StringBuilder();
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        for (StackTraceElement ste : stackTrace) {
            sb.append("\n\t");
            sb.append(ste.toString());
        }

        return sb.toString();
    }

    /**
     * 抽取Map中间某个key，不存在返回默认值
     *
     * @param key          key
     * @param objectMap    map值
     * @param defaultValue 默认值
     * @return value
     */
    public static String getMapValueForKey(String key, Map<String, Object> objectMap,
                                           String defaultValue) {
        Object obj = objectMap.get(key);
        return obj == null ? defaultValue : obj.toString();
    }

    /**
     * 计算耗时操作，单位ms
     */
    public static long countConsume(final long beginTime) {
        return (System.currentTimeMillis() - beginTime);
    }

    public static int asInt(String str, int defaultValue) {
        try {
            return Integer.parseInt(str);
        } catch (Exception e) {
            return defaultValue;
        }
    }

    public static long asLong(String str, long defaultValue) {
        try {
            return Long.parseLong(str);
        } catch (Exception e) {
            return defaultValue;
        }
    }

    public static double asDouble(String str, double defaultValue) {
        try {
            return Double.parseDouble(str);
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * format date
     *
     * @param date 日期
     * @return 日期字符串
     */
    public static String formatDate(Date date) {
        return DateTimeFormat.forPattern("yyyy-MM-dd").print(date.getTime());
    }

    /**
     * format date
     *
     * @param date 日期
     * @return 日期字符串
     */
    public static String formatDateTime(Date date) {
        return DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss").print(date.getTime());
    }

    /**
     * format date
     *
     * @param date 日期
     * @return 日期字符串
     */
    public static String formatDate(Date date, String pattern) {
        return DateTimeFormat.forPattern(pattern).print(date.getTime());
    }

    public static Date parseDate(int date) {
        return parseDate(String.valueOf(date), "yyyyMMdd");
    }

    public static Date parseDate(String date) {
        return parseDate(date, null);
    }

    public static Date parseDate(String date, String pattern) {
        DateTimeFormatter formatter = pattern == null ? DateTimeFormat.forPattern("yyyy-MM-dd") : DateTimeFormat.forPattern(pattern);
        try {
            LocalDate dateTime = formatter.parseLocalDate(date);
            return dateTime.toDate();
        } catch (Exception e) {
            return null;
        }
    }

    public static Date parseDateTime(String date) {
        return parseDateTime(date, null);
    }

    public static Date parseDateTime(String date, String pattern) {
        DateTimeFormatter formatter = pattern == null ? DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss") : DateTimeFormat.forPattern(pattern);
        try {
            DateTime dateTime = formatter.parseDateTime(date);
            return dateTime.toDate();
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 日期间隔多少天
     *
     * @param date1 日期1
     * @param date2 日期2
     * @return 日期1-日期2 所得天数
     */
    public static Integer dateDiff(Integer date1, Integer date2) {
        if (date1 == null || date2 == null) {
            return null;
        }
        return dateDiff(Integer.toString(date1), Integer.toString(date2));
    }

    /**
     * 日期间隔多少天
     *
     * @param date1 日期1
     * @param date2 日期2
     * @return 日期1-日期2 所得天数
     */
    public static Integer dateDiff(String date1, String date2) {
        if (date1 == null || date2 == null) {
            return null;
        }
        try {
            Calendar c = Calendar.getInstance();
            Date dateA = new SimpleDateFormat("yyyyMMdd").parse(date1);
            Date dateB = new SimpleDateFormat("yyyyMMdd").parse(date2);

            long diff = (dateA.getTime() - dateB.getTime()) / 1000L / 60 / 60 / 24;
            return new Long(diff).intValue();
        } catch (ParseException e) {
            logger.error("计算日期间隔天数异常：{}", e.getMessage(), e);
            return null;
        }
    }


    /**
     * 日期间隔多少天
     *
     * @param date1 日期1
     * @param date2 日期2
     * @return 日期1-日期2 所得天数
     */
    public static Integer dateDiff(Date date1, Date date2) {
        if (date1 == null || date2 == null) {
            return null;
        }
        try {
            long diff = (date2.getTime() - date1.getTime()) / 1000L / 60 / 60 / 24;
            return Math.abs(new Long(diff).intValue());
        } catch (Exception e) {
            logger.error("计算日期间隔天数异常：{}", e.getMessage(), e);
            return null;
        }
    }


    /**
     * 计算到期日和当前时间之间相差的天数，对应的延滞阶段和延滞天数
     *
     * @param dueToPayDateTime 到期日
     * @param nowDateTime      当前日期
     * @return 延滞阶段、延滞天数
     */
    public static List<Integer> calculationDelayLevelAndDays(LocalDate dueToPayDateTime, LocalDate nowDateTime) {
        long beginMillis = System.currentTimeMillis();

        List<Integer> resultList = Lists.newArrayListWithCapacity(2);
        // dueToPayDateTime >= nowDateTime，还未逾期跳过
        if (!dueToPayDateTime.isBefore(nowDateTime)) {
            resultList.add(Integer.valueOf(0));
            resultList.add(Integer.valueOf(0));
            return resultList;
        }

        // 计算到期日和当前时间的月份之差
        int months = Months.monthsBetween(dueToPayDateTime, nowDateTime).getMonths();
        LocalDate currentMonthDueToPayDateTime = dueToPayDateTime.plusMonths(months);
        // 对比到期日+月份之差后，是否大于当前时间
        int compareResult = currentMonthDueToPayDateTime.compareTo(nowDateTime);

        int days;
        if (compareResult > 0) {

            // currentMonthDueToPayDateTime > nowDateTime
            // 到期日+月份之差 > 当前时间，计算逾期天数，就是（到期日+月份之差）减一个月后对应的日期和当前日期相差的天数
            days = Days.daysBetween(currentMonthDueToPayDateTime.minusMonths(1), nowDateTime).getDays();
        } else if (compareResult < 0) {

            // currentMonthDueToPayDateTime < nowDateTime
            // 到期日+月份之差 < 当前时间，计算逾期天数，就是（到期日+月份之差）和当前日期相差的天数
            days = Days.daysBetween(currentMonthDueToPayDateTime, nowDateTime).getDays();
            months++;
        } else {

            // currentMonthDueToPayDateTime == nowDateTime
            // 到期日+月份之差 == 当前时间，计算逾期天数，就是（到期日+月份之差）减一个月后对应的日期的当月最对应的总天数
            days = currentMonthDueToPayDateTime.minusMonths(1).dayOfMonth().getMaximumValue();
        }
        resultList.add(months);
        resultList.add(days);

        logger.info("{}-{} M{}/{} times:{}ms.", dueToPayDateTime.toString("yyyyMMdd"),
                nowDateTime.toString("yyyyMMdd"), months, days, (System.currentTimeMillis() - beginMillis));
        return resultList;
    }

    /**
     * 获取下一次跟进时间
     * 当前时间小于等于12:00时，【下次跟进时间】设置为当日14:00；
     *  当前时间大于12:00小于等于18:00时，【下次跟进时间】设置为当日18:00；
     *  当前时间大于18:00小于等于20:00时，【下次跟进时间】设置为当日20:00；
     *  当前时间大于20:00时，【下次跟进时间】设置为次日09:00。
     *
     * @param nextFlowDatetime 下次跟进时间
     * @return 跟进时间
     */
    public static DateTime getNextFlowDatetime(Date nextFlowDatetime) {
        DateTime dateTime = new DateTime();
        if (null != nextFlowDatetime) {
            dateTime = dateTime.withMillis(nextFlowDatetime.getTime());
        }
        int hourOfDay = dateTime.getHourOfDay();
        if (hourOfDay < 12) {
            dateTime = dateTime.withHourOfDay(14);
        } else if (hourOfDay >= 12 && hourOfDay < 18) {
            dateTime = dateTime.withHourOfDay(18);
        } else if (hourOfDay >= 18 && hourOfDay < 20) {
            dateTime = dateTime.withHourOfDay(20);
        } else {
            dateTime = dateTime.plusDays(1);
            dateTime = dateTime.withHourOfDay(9);
        }

        dateTime = dateTime.withMinuteOfHour(0);
        dateTime = dateTime.withSecondOfMinute(0);
        return dateTime;
    }


    /**
     * 判断指定日期是否是周末
     *
     * @param day 指定日期
     * @return
     */
    public static boolean isWeekend(int day) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(DateUtil.parseDate(day));
        return cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY || cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY;
    }

    /**
     * 获取指定日期所在月份的天数
     *
     * @param day
     * @return
     */
    public static int daysOfMonth(int day) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(DateUtil.parseDate(day));
        return cal.getActualMaximum(Calendar.DAY_OF_MONTH);
    }

    /**
     * 获取当前日期是星期几<br>
     *
     * @param day 指定日期
     * @return 返回星期几
     */
    public static String getWeekOfDateXQ(int day) {
        String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        Calendar cal = Calendar.getInstance();
        cal.setTime(DateUtil.parseDate(day));
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (w < 0) {
            w = 0;
        }
        return weekDays[w];
    }

    /**
     * 获取当前日期是周几<br>
     *
     * @param day 指定日期
     * @return 返回周几
     */
    public static String getWeekOfDateZ(int day) {
        String[] weekDays = {"周日", "周一", "周二", "周三", "周四", "周五", "周六"};
        Calendar cal = Calendar.getInstance();
        cal.setTime(DateUtil.parseDate(day));
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (w < 0) {
            w = 0;
        }
        return weekDays[w];
    }


    /**
     * 两个时间间隔多少个小时
     *
     * @param date1 日期1
     * @param date2 日期2
     * @return 间隔小时
     */
    public static Integer hourDiff(Date date1, Date date2) {
        if (date1 == null || date2 == null) {
            return null;
        }
        long diff = (date2.getTime() - date1.getTime()) / 1000L / 60 / 60;
        return Math.abs(new Long(diff).intValue());
    }

    /**
     * 间隔分钟数
     *
     * @param date1 时间1
     * @param date2 时间2
     * @return 时间1-时间2 所得分钟数
     */
    public static Integer minuteDiff(Date date1, Date date2) {
        Long minuteDiff = (date1.getTime() - date2.getTime()) / (1000 * 60);
        return minuteDiff.intValue();
    }

    /**
     * 间隔秒数
     *
     * @param date1 时间1
     * @param date2 时间2
     * @return 时间1-时间2 所得秒数
     */
    public static Integer secondDiff(Date date1, Date date2) {
        Long secondDiff = 0L;
        if (date1.getTime() > date2.getTime()) {
            secondDiff = (date1.getTime() - date2.getTime()) / 1000;
        } else {
            secondDiff = (date2.getTime() - date1.getTime()) / 1000;
        }
        return secondDiff.intValue();
    }

    /**
     * 输入时间+分钟
     *
     * @param date   时间
     * @param minute 分钟数
     * @return 时间+分钟数
     */
    public static Date getDatePlusMinute(Date date, int minute) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MINUTE, minute);
        return cal.getTime();
    }

    /**
     * 获取当前小时
     *
     * @author myx 15919918653 2019/5/29 20:37
     */
    public static int getNowHour() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        return calendar.get(Calendar.HOUR_OF_DAY);
    }

    /**
     * 时间 加N秒
     *
     * @param date
     * @param second
     * @return
     */
    public static Date addSecond(Date date, int second) {
        Calendar calendar = Calendar.getInstance();
        //设置注册开始时间
        calendar.setTime(date);
        calendar.add(Calendar.SECOND, second);
        return calendar.getTime();
    }

    public static void main(String[] args) {
        System.out.println(getNowYmd());
    }
}

package org.demo.util;

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

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

public class DateUtil {
    public static final String DATE_FROMAT_YYYYMMDD = "yyyyMMdd";
    public static final String DATE_FROMAT_YYMMDD = "yyMMdd";
    public static final String TIME_FORMAT_HHMMSS = "HHmmss";

    public DateUtil() {
    }

    public static boolean isWithInDateGap(Date startDate, Date endDate, int gapType, int maxGap) {
        if (startDate == null) {
            throw new IllegalArgumentException("The startDate must not be null");
        } else if (endDate == null) {
            throw new IllegalArgumentException("The endDate must not be null");
        } else if (gapType != 1 && gapType != 2 && gapType != 6) {
            throw new IllegalArgumentException("The value of gapType is invalid");
        } else {
            Calendar start = Calendar.getInstance();
            start.setTime(startDate);
            start.add(gapType, maxGap);
            int compare = start.getTime().compareTo(endDate);
            return compare >= 0;
        }
    }

    public static boolean isWithInDateGap(String startDate, String endDate, int gapType, int maxGap) {
        Date startDateTime = null;
        Date endDateTime = null;

        try {
            startDateTime = DateUtils.parseDate(startDate, new String[]{"yyyyMMdd"});
            endDateTime = DateUtils.parseDate(endDate, new String[]{"yyyyMMdd"});
        } catch (ParseException var7) {
            throw new IllegalArgumentException("日期格式错误,开始日期：" + startDate + ",结束日期：" + endDate, var7);
        }

        return isWithInDateGap(startDateTime, endDateTime, gapType, maxGap);
    }

    public static boolean isWithInDateGap(int startDate, int endDate, int gapType, int maxGap) throws ParseException {
        return isWithInDateGap(DateUtils.parseDate(String.valueOf(startDate), new String[]{"yyyyMMdd"}), DateUtils.parseDate(String.valueOf(endDate), new String[]{"yyyyMMdd"}), gapType, maxGap);
    }

    public static int getCurIntDate() {
        return Integer.parseInt(getCurStringDate());
    }

    public static String getCurStringDate() {
        Date currentDate = new Date();
        SimpleDateFormat formatdate = new SimpleDateFormat("yyyyMMdd");
        return formatdate.format(currentDate);
    }

    public static String getCurDate(String strFormat) {
        Date currentDate = new Date();
        SimpleDateFormat formatdate = new SimpleDateFormat(strFormat);
        return formatdate.format(currentDate);
    }

    public static String getCurStringDateTime() {
        Date currentDate = new Date();
        SimpleDateFormat formatdate = new SimpleDateFormat("yyyyMMddHHmmss");
        return formatdate.format(currentDate);
    }

    public static Long getIntCurIntDateTime() {
        return Long.valueOf(getCurStringDateTime());
    }

    public static String getCurTime() {
        Date currentDate = new Date();
        SimpleDateFormat formatdate = new SimpleDateFormat("HHmmss");
        return formatdate.format(currentDate);
    }

    public static boolean checkDateFormat(int intDate) {
        return checkDateFormat(String.valueOf(intDate));
    }

    public static boolean checkDateFormat(String strDate) {
        return checkDateFormat(strDate, "yyyyMMdd");
    }

    public static boolean checkDateFormat(int intDate, String strFormat) {
        return checkDateFormat(String.valueOf(intDate), "yyyyMMdd");
    }

    public static boolean checkDateFormat(String strDate, String strFormat) {
        try {
            DateUtils.parseDateStrictly(strDate, new String[]{strFormat});
            return true;
        } catch (ParseException var3) {
            return false;
        }
    }

    public static boolean checkTimeFormat(String strDate) {
        return checkTimeFormat(strDate, "HHmmss");
    }

    public static boolean checkTimeFormat(int intDate, String strFormat) {
        return checkTimeFormat(String.valueOf(intDate), "yyyyMMdd");
    }

    public static boolean checkTimeFormat(String strDate, String strFormat) {
        try {
            DateUtils.parseDateStrictly(strDate, new String[]{strFormat});
            return true;
        } catch (ParseException var3) {
            return false;
        }
    }

    public static Date parseDate(String strDate) {
        return parseDate(strDate, "yyyyMMdd");
    }

    public static Date parseDate(String strDate, String strFormat) {
        try {
            return DateUtils.parseDateStrictly(strDate, new String[]{strFormat});
        } catch (ParseException var3) {
            throw new IllegalArgumentException("日期格式错误,日期：" + strDate, var3);
        }
    }

    public static Date parseDate(int intDate, String strFormat) {
        return parseDate(String.valueOf(intDate), strFormat);
    }

    public static Date parseDate(int intDate) {
        return parseDate(String.valueOf(intDate));
    }

    public static String date2String(Date date, String dateFormat) {
        SimpleDateFormat formatdate = new SimpleDateFormat(dateFormat);
        return formatdate.format(date);
    }

    public static String timestamp2String(long date, String dateFormat) {
        SimpleDateFormat formatdate = new SimpleDateFormat(dateFormat);
        return formatdate.format(date);
    }

    public static String date2String(Date date) {
        return date2String(date, "yyyyMMdd");
    }

    public static int date2Int(Date date) {
        String str = date2String(date, "yyyyMMdd");
        return Integer.parseInt(str);
    }

    public static Integer getDateBeforeDay(Integer inputDate, int days) {
        Calendar theCa = Calendar.getInstance();
        theCa.setTime(parseDate(inputDate));
        theCa.add(5, -1 * days);
        Date date = theCa.getTime();
        SimpleDateFormat formatdate = new SimpleDateFormat("yyyyMMdd");
        return Integer.valueOf(formatdate.format(date));
    }

    public static Integer getDateAfterYear(Integer inputDate, int years) {
        Calendar theCa = Calendar.getInstance();
        theCa.setTime(parseDate(inputDate));
        theCa.add(1, years);
        Date date = theCa.getTime();
        SimpleDateFormat formatdate = new SimpleDateFormat("yyyyMMdd");
        return Integer.valueOf(formatdate.format(date));
    }

    public static Integer getDateAfterDay(Integer date, int days) {
        Calendar theCa = Calendar.getInstance();
        theCa.setTime(parseDate(date));
        theCa.add(5, 1 * days);
        Date tempdate = theCa.getTime();
        SimpleDateFormat formatdate = new SimpleDateFormat("yyyyMMdd");
        return Integer.valueOf(formatdate.format(tempdate));
    }
}

码上得天下
关注
专栏目录
Java常用工具类---数字工具类
zhang150114的博客
05-22 2113
package com.jarvis.base.util; import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; import java.util.Random; public class NumericHelper { /** * 描述：通过一个整数i获...
手写MapUtils工具类，实现获取Map值功能
u012867993的博客
03-24 1341
项目开发过程中，会经常对map进行取值操作。其中空指针问题可谓不厌其烦。还好apache提供了一个集合操作的库,commons-collections。其中对java的集合进行了大量的操作功能封装，有兴趣的小伙伴可以下载来试试。 下载地址为：https://commons.apache.org/proper/commons-collections/ 本文仿照apache的Maputils工具类，重...
工具类IntegerUtils
timchen525的专栏
02-04 1170
public class IntegerUtils { /** * 使用说明： * 针对字符串转整形时容易报转化异常 * String s1 = ""; * int i1 = IntegerUtils.StringToInt(s1).orElse(0); // 输出结果用缺省的零来替代 * String s2 = "123";
对时间进行整形
林羽枫
11-26 910
Calendar calendar = Calendar.getInstance(); int y = calendar.get(Calendar.YEAR); int m = calendar.get(Calendar.MONTH)+1; int d = calendar.get(Calendar.DATE); String start = y+"-"+m+"-"+d+" 00:00:0
常用的工具类
m0_53077601的博客
05-30 685
1. Collections java.util包下的Collections类 1.1 排序 List<Integer> list = new ArrayList<>(); list.add(2); list.add(1); list.add(3); Collections.sort(list);//升序 System.out.println(list); Collections.reverse(list);//降序 System.out.pr
java常见类——工具类
RRros的博客
05-17 5000
目录工具类Java开发者写好的类---官方文档 API包装类(封装类)数学相关Math类Random类UUID类BigInteger类BigDecima类 超过了double取值范围DecimalFormatScanner类System类日期相关Date类DateFormat类Calendar类 1.1版本TimeZone字符串String类---->引用类型 java.lang包StringBuffer和StringBuilder知识总结集合相关（ArrayBox LinkedBox
长整型时间转换工具
01-02
长整型时间转换工具就是为了解决这类时间数据的处理问题而设计的。 首先，我们来理解什么是长整型时间。在计算机科学中，长整型通常用来表示大范围的整数，其位数比普通整型要多，因此能存储更大的数值。在处理时间...
任务执行工具类ruoyi(收藏)
huangbaokang的博客
08-16 1805
在研究ruoyi框架的定时任务工程时，觉得工具类编写的不错，收藏下，其实要自己来学，也完全能写出来。研究之后的体会，熟悉一套常用的工具类，对以后工作项目中比较有用，随时拿来用。比如字符串相关操作，人家org.apache.commons.lang3.StringUtils全部都给考虑好了，针对SysJob里的一个invoke_target，如何拿到bean名称，方法名称，参数列表之类的，我们自己来...
java实验报告四-基础类与工具类
weixin_45308118的博客
03-14 1375
一 ，实验目的 1）了解Java中的基础类库； 2）掌握基本数据类型； 3）掌握String类和StringBuffer类的定义和应用； 4）掌握Math类的定义和应用； 5）掌握向量vector的定义和应用。 二，实验原理 （1）生成数据类型包类对象的方法 （2）到基本数据类型数据的方法 （3）数学Math类的应用 （4）String和StringBuffer类的应用 （5）Vector类的应用 三，使用仪器及环境 Eclipse 电脑 四，实验内容与步骤（过程及结果截图） 例子4-1阅读程序，根据注释填
一个简单实用的整型颜色值获取工具ColorDemo
09-05
ColorDemo工具可以显著提高这类操作的效率，减少手动计算的繁琐和错误。 **6. 工程文件** 在提供的压缩包文件中，`ColorDemo.sln`是Visual Studio的解决方案文件，包含了项目的所有配置信息。`ColorDemo.suo`是...
整形转换为时间格式
yanghuifly的博客
10-31 1590
  使用 TimeSpan 类进行     void OnChangetheText(int currenttime)     {         timetext.text = currenttime.ToString();         TimeSpan span = new TimeSpan(0,0,currenttime);         timetext.text = (int...
Integer 时间戳类型不够了
qq_25004825的博客
07-21 306
时间戳
日期格式互转：（整型）时间戳与日期格式转换
cen_cs的专栏
11-11 4493
日期格式互转：（整型）时间戳与日期格式转换
android 时间戳转int,Android的转换INT时间戳人的datetime
weixin_42252435的博客
05-29 702
您好我有使用Int类型(或长期)，我想将其转换为人类读者日期时间webRequest返回时间戳的Android应用程序(根据设备的时区)Android的转换INT时间戳人的datetime例如1175714200转换为GMT：星期三，04四月2007 19:16:40 GMT 您的时区：4/5/2007，3:16:40上午GMT + 8：00我已经使用此功能来转换，但似乎没有返回正确的结果(所有结...
07、java-常用工具类
weixin_43877527的博客
01-04 414
BigInteger和Integer、Long一样，也是不可变类，并且也继承自Number类。老生常谈的问题就是，几乎所有编程语言都会有浮点数精度问题，是因为计算机采用二进制的原因，浮点数无法用二进制数精确表示。Java中为了解决这个问题，和BigInteger类似，BigDecimal可以表示一个任意大小且精度完全准确的浮点数。可以发现在该计算中已经出现了循环，0.6用二进制表示为 0.1001 1001 1001 1001 ……所谓伪随机数，是指只要给定一个初始的种子，产生的随机数序列是完全一样的……
Python 关于时间的处理方法
毛发浓密的猿工
01-12 1869
# 转换成时间格式 time_format = [] for i in data['时间']: print(i) time_format.append(time.strptime(str(i),'%Y%m%d'))
java时间格式处理
qq_41482600的博客
01-28 1317
一、根据当前时间，获取具体的时刻的时间 import java.text.SimpleDateFormat; import java.util.Date; public class getTime { public static void main(String[] args) { SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date time = new Date(ne
java中日期保存为int（Integer）类型
weixin_44975322的博客
07-25 2487
java中日期保存为int（Integer）类型 1，在页面展示，用的是My97Date插件，需要导入相关的js文件 2，开始时间 结束时间 3.后台保存 4，前台页面展示 5最后效果 ...
python 获取时间（各种格式）
热门推荐
鼓浪屿岛与海的博客
06-01 2万+
curr_time=datetime.datetime.now()　　#2019-07-0614:55:56.873893<class'datetime.datetime'> curr_time.year　　#2019<class'int'> curr_time.month　　#7<class'int'> curr_time.day　　#6<class'int'> curr_time.hour　　#14<class'...
java判断integer类型为空工具类
最新发布
06-28
### 回答1： Java中的Integer类型是一个包装类，用于表示包装了一个基本类型int的对象。判断一个Integer对象是否为空，即判断其所包装的int值是否为null，需要使用以下方法： public static boolean isNull(Integer i) { return i == null; } 这里定义了一个叫做"isNull"的静态方法，该方法接受一个Integer类型的参数i，并返回一个boolean类型的值，表示i是否为null。该方法的实现很简单，只需要判断i是否等于null即可。 使用该工具类也很简单，只需要在需要判断的地方调用该方法，并将需要判断的Integer对象作为参数传入即可。例如： Integer num = null; if (IntegerUtil.isNull(num)) { System.out.println("num是空的"); } 这里，我们定义了一个Integer变量num，并将其设置为null，然后调用isNull方法判断num是否为空，并输出相应的信息。如果num是null，将输出"num是空的"。 需要注意的是，这里只能判断Integer对象是否为null，而不能判断其是否为0。如果需要判断一个int值是否为0，应该直接使用"=="运算符。例如： int num = 0; if (num == 0) { System.out.println("num是0"); } ### 回答2： Java是一个面向对象的编程语言，它提供了各种类型的数据类型，包括Integer类型。在Java中，Integer可以表示整型数据，并提供了操作和方法来处理整数。但有时候我们需要判断一个Integer对象是否为null，因为如果我们在一个null对象上执行操作，就会引发NullPointException异常。因此，写一个判断Integer类型是否为空的工具类非常有用。 一个简单的判断Integer类型为空的工具类可以像下面这样： ```java public class IntegerUtils { //判断一个整数是否为空 public static boolean isNull(Integer integer) { return integer == null; } } ``` 上面的代码定义了一个Java类IntegerUtils，其中包含一个静态方法isNull，该方法接受一个Integer类型的参数，并检查该参数是否为空。如果integer为null，则返回true，否则返回false. 使用此工具类可以避免在代码中多次使用if（integer == null）进行整数对象空值的判断，代码更加简洁易懂。 下面是一个示例代码模拟使用IntegerUtils类进行整数空值的判断： ```java public static void main(String[] args) { Integer a = null; Integer b = 12; if (IntegerUtils.isNull(a)) { System.out.println("a is null"); } else { System.out.println("a is not null"); } if (IntegerUtils.isNull(b)) { System.out.println("b is null"); } else { System.out.println("b is not null"); } } ``` 上面的代码首先创建了两个整数变量a和b，其中a为null，b为12。然后使用IntegerUtils类的isNull方法判断这两个整数是否为空。根据输出，我们可以看到a为空，b不为空。 总之，使用IntegerUtils类，我们可以轻松方便地判断一个Integer对象是否为空。这种工具类的编写可以提高代码的可读性和可维护性。 ### 回答3： 在Java中，判断Integer类型为空的方法有很多种，下面介绍两种常见的判断方法。 方法一：使用Objects.isNull()方法 Objects.isNull()方法是Java8中新增的静态工具方法，可以用于判断一个对象是否为null。具体使用方法如下： ```java public static boolean isNull(Integer num) { return Objects.isNull(num); } ``` 方法二：使用Optional类 Optional类是Java8中新增的一个类，用于解决空指针异常问题。具体使用方法如下： ```java public static boolean isNull(Integer num) { return Optional.ofNullable(num).isEmpty(); } ``` 这种方法的优点是可以链式调用，比较简洁。但是，如果不熟悉Optional类的使用方法，可能会导致一些难以排查的问题。 无论使用哪种方法，都需要注意的是，判断Integer类型为空时，不能使用“==”或“!=”运算符进行比较，因为Integer类型是一个包装类型，使用“==”或“!=”运算符比较的是对象的引用，而不是值。正确的比较方法是使用equals()方法进行比较。 总的来说，使用工具类来判断Integer类型是否为空，可以提高代码的可读性和可维护性，减少出错的概率。但是，需要根据具体的业务需求和开发习惯来选择合适的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值