精华内容
下载资源
问答
  • Java计算时间差、日期差总结

    万次阅读 多人点赞 2018-03-13 18:59:00
    Java计算时间差、日期差总结 最近工作中遇到需要计算时间差,搜索了几种计算时间差的方法,这里总结一下 1、java 7中的日历类Calendar Calendar类使用其静态的getInstance()方法获取一个日历实例,该实例为当前...

    Java计算时间差、日期差总结

    最近工作中遇到需要计算时间差,搜索了几种计算时间差的方法,这里总结一下

    1、java 7中的日历类Calendar

    Calendar类使用其静态的getInstance()方法获取一个日历实例,该实例为当前的时间;如果想改变时间,可以通过其setTime方法传入一个Date对象,即可获得Date对象所表示时间的Calendar对象

    /**
     *使用Calendar对象计算时间差,可以按照需求定制自己的计算逻辑
     * @param strDate
     * @throws ParseException
     */
    public static void calculateTimeDifferenceByCalendar(String strDate) throws ParseException {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
        Date date = formatter.parse(strDate);
    
        Calendar c1 = Calendar.getInstance();   //当前日期
        Calendar c2 = Calendar.getInstance();
        c2.setTime(date);   //设置为另一个时间
    
        int year = c1.get(Calendar.YEAR);
        int oldYear = c2.get(Calendar.YEAR);
    
        //这里只是简单的对两个年份数字进行相减,而没有考虑月份的情况
        System.out.println("传入的日期与今年的年份差为:" + (year - oldYear));
    }

    输出为:

    传入的日期与今年的年份差为:12

    2、java 8中的周期类Period

    通过调用Period类的静态方法between,传入两个待比较的LocalDate对象today与oldDate,得到的Period的对象p中就包含了today与oldDate两个日期相差的年、月、日信息,可以通过p.getYears()等方法取出

    /**
     * 使用java 8的Period的对象计算两个LocalDate对象的时间差,严格按照年、月、日计算,如:2018-03-12 与 2014-05-23 相差 3 年 9 个月 17 天
     * @param year
     * @param month
     * @param dayOfMonth
     */
    public static void calculateTimeDifferenceByPeriod(int year, Month month, int dayOfMonth) {
        LocalDate today = LocalDate.now();
        System.out.println("Today:" + today);
        LocalDate oldDate = LocalDate.of(year, month, dayOfMonth);
        System.out.println("OldDate:" + oldDate);
    
        Period p = Period.between(oldDate, today);
        System.out.printf("目标日期距离今天的时间差:%d 年 %d 个月 %d 天\n", p.getYears(), p.getMonths(), p.getDays());
    }

    输出为:

    Today:2018-03-13
    OldDate:2014-05-23
    目标日期距离今天的时间差:3 年 9 个月 18 天

    3、java 8中的Duration类

    Duration与Period相对应,Period用于处理日期,而Duration计算时间差还可以处理具体的时间,也是通过调用其静态的between方法,该方法的签名是between(Temporal startInclusive, Temporal endExclusive),因此可以传入两个Instant的实例(Instant实现了Temporal接口),并可以以毫秒(toMillis)、秒(getSeconds)等多种形式表示得到的时间差

    public static void calculateTimeDifferenceByDuration() {
        Instant inst1 = Instant.now();  //当前的时间
        System.out.println("Inst1:" + inst1);
        Instant inst2 = inst1.plus(Duration.ofSeconds(10));     //当前时间+10秒后的时间
        System.out.println("Inst2:" + inst2);
        Instant inst3 = inst1.plus(Duration.ofDays(125));       //当前时间+125天后的时间
        System.out.println("inst3:" + inst3);
    
        System.out.println("以毫秒计的时间差:" + Duration.between(inst1, inst2).toMillis());
    
        System.out.println("以秒计的时间差:" + Duration.between(inst1, inst3).getSeconds());
    }

    输出为:

    Inst1:2018-03-13T09:06:00.691Z
    Inst2:2018-03-13T09:06:10.691Z
    inst3:2018-07-16T09:06:00.691Z
    以毫秒计的时间差:10000
    以秒计的时间差:10800000

    4、java 8中的ChronoUnit类

    ChronoUnit的between方法签名为,between(Temporal temporal1Inclusive, Temporal temporal2Exclusive),需要注意的是,如果要以不同的单位展示时间差,between入参中的时间对象必须包含有对应的时间信息,否则会抛出java.time.temporal.UnsupportedTemporalTypeException: Unsupported unit XXX的异常

    /**
     * 使用java 8的ChronoUnit,ChronoUnit可以以多种单位(基本涵盖了所有的,看源码发现竟然还有“FOREVER”这种单位。。)表示两个时间的时间差
     */
    public static void calculateTimeDifferenceByChronoUnit() {
        LocalDate startDate = LocalDate.of(2003, Month.MAY, 9);
        System.out.println("开始时间:" + startDate);
    
        LocalDate endDate = LocalDate.of(2015, Month.JANUARY, 26);
        System.out.println("结束时间:" + endDate);
    
        long daysDiff = ChronoUnit.DAYS.between(startDate, endDate);
        System.out.println("两个时间之间的天数差为:" + daysDiff);
    //  long hoursDiff = ChronoUnit.HOURS.between(startDate, endDate);  //这句会抛出异常,因为LocalDate表示的时间中不包含时分秒等信息
    }

    输出为:

    开始时间:2003-05-09
    结束时间:2015-01-26
    两个时间之间的天数差为:4280

    5、传统的SimpleDateFormat类

    用SimpleDateFormat计算时间差的方法,网上找了一份,自己跑了一遍,可以使用,贴在下面

    /**
    * 用SimpleDateFormat计算时间差
    * @throws ParseException 
    */
    public static void calculateTimeDifferenceBySimpleDateFormat() throws ParseException {
        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm");
        /*天数差*/
        Date fromDate1 = simpleFormat.parse("2018-03-01 12:00");  
        Date toDate1 = simpleFormat.parse("2018-03-12 12:00");  
        long from1 = fromDate1.getTime();  
        long to1 = toDate1.getTime();  
        int days = (int) ((to1 - from1) / (1000 * 60 * 60 * 24));  
        System.out.println("两个时间之间的天数差为:" + days);
    
        /*小时差*/
        Date fromDate2 = simpleFormat.parse("2018-03-01 12:00");  
        Date toDate2 = simpleFormat.parse("2018-03-12 12:00");  
        long from2 = fromDate2.getTime();  
        long to2 = toDate2.getTime();  
        int hours = (int) ((to2 - from2) / (1000 * 60 * 60));
        System.out.println("两个时间之间的小时差为:" + hours);
    
        /*分钟差*/
        Date fromDate3 = simpleFormat.parse("2018-03-01 12:00");  
        Date toDate3 = simpleFormat.parse("2018-03-12 12:00");  
        long from3 = fromDate3.getTime();  
        long to3 = toDate3.getTime();  
        int minutes = (int) ((to3 - from3) / (1000 * 60));  
        System.out.println("两个时间之间的分钟差为:" + minutes);
    }

    输出为:

    两个时间之间的天数差为:11
    两个时间之间的小时差为:264
    两个时间之间的分钟差为:15840

    总结

    传统的SimpleDateFormat和Java 7中的Calendar在使用的时候需要自己写一个计算时间差的逻辑,比较麻烦,但是却比较灵活,方便根据自己具体的需求来定制(比如,我想两个日期的天数差15天就算满一个月,不满15天不算一个月,如2018-01-04到2018-02-20,算2个月的时间差);而Java 8中的几个计算时间差的类更加方便、精确,可以以不同的单位表示得到的时间差,但要注意几个类所包含的时间信息的区别:

    System.out.println(LocalDate.now());        //只包含日期信息
    System.out.println(LocalTime.now());        //只包含时间信息
    System.out.println(LocalDateTime.now());        //包含日期、时间信息

    输出为:

    2018-03-13
    17:13:26.134
    2018-03-13T17:13:26.135

    以上总结的几个方法只是个例子,具体使用的时候可能需要传入一个或者两个时间进行比较,可能会涉及到这些时间对象的相互转换,Instant、Date、LocalDate等等。。。我就不列举了。。。
    另外在使用SimpleDateFormat对String类型的日期进行parse的时候,如果传入的日期为:2017-08-60,这种错误的日期,Java默认会按照日期的信息对其进行转换,formatter.parse("2017-08-60");,得到的日期为2017-09-29,而如果不想进行这种转换,而直接将其判定为输入错误,则可以设置formatter.setLenient(false);,这时就会抛出java.text.ParseException异常了

    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    formatter.setLenient(false);
    try {
        Date date = formatter.parse("2017-08-60");  //抛出转换异常
        System.out.println(date);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    展开全文
  • 主要介绍了Java对日期Date类进行加减运算、年份加减月份加减、时间差等等,在网上查阅资料,加上自己总结的一些关于Date类的工具类
  • java时间差工具类

    2021-02-02 11:29:37
    分享一个我目前在用的时间差工具类,比较实用,方便检测方法的耗时 /** * @author : xuzhennan * @email : xuzhennan@58.com * @date : 2021年01月15日 8:19 上午 */ public class TimeUtils { /** @return 当前...

    分享一个我目前在用的时间差工具类,比较实用,方便检测方法的耗时

    /**
     * @author : xuzhennan
     * @email : xuzhennan@58.com
     * @date : 2021年01月15日 8:19 上午
     */
    public class TimeUtils {
      /** @return 当前毫秒数 */
      public static long nowMs() {
        return System.currentTimeMillis();
      }
    
      /**
       * 当前毫秒与起始毫秒差
       *
       * @param startMillis 开始纳秒数
       * @return 时间差
       */
      public static long diffMs(long startMillis) {
        return diffMs(startMillis, nowMs());
      }
    
      public static long diffMs(long startMillis, long endMIllis) {
        return endMIllis - startMillis;
      }
    }
    

    在项目中的应用,主要是在日志中记录该方法的耗时时长

    logger.info("SpeedFeedMatchPicService jsonResultData statisticalInfo is null cost time:" + TimeUtils.diffMs(startTime));
    
    展开全文
  • 1、java 7中的日历类Calendar Calendar类使用其静态的...*使用Calendar对象计算时间差,可以按照需求定制自己的计算逻辑 * @param strDate * @throws ParseException */ public static void calculateTimeDiff...

    Java计算时间差、日期差的计算:

    1、java 7中的日历类Calendar
    Calendar类使用其静态的getInstance()方法获取一个日历实例,该实例为当前的时间;如果想改变时间,可以通过其setTime方法传入一个Date对象,即可获得Date对象所表示时间的Calendar对象

    /**
     *使用Calendar对象计算时间差,可以按照需求定制自己的计算逻辑
     * @param strDate
     * @throws ParseException
     */
    public static void calculateTimeDifferenceByCalendar(String strDate) throws ParseException {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
        Date date = formatter.parse(strDate);

        Calendar c1 = Calendar.getInstance();   //当前日期
        Calendar c2 = Calendar.getInstance();
        c2.setTime(date);   //设置为另一个时间

        int year = c1.get(Calendar.YEAR);
        int oldYear = c2.get(Calendar.YEAR);

        //这里只是简单的对两个年份数字进行相减,而没有考虑月份的情况
        System.out.println("传入的日期与今年的年份差为:" + (year - oldYear));
    }

    输出为:

    传入的日期与今年的年份差为:12

    2、java 8中的周期类Period
    通过调用Period类的静态方法between,传入两个待比较的LocalDate对象today与oldDate,得到的Period的对象p中就包含了today与oldDate两个日期相差的年、月、日信息,可以通过p.getYears()等方法取出

    /**
     * 使用java 8的Period的对象计算两个LocalDate对象的时间差,严格按照年、月、日计算,如:2018-03-12 与 2014-05-23 相差 3 年 9 个月 17 天
     * @param year
     * @param month
     * @param dayOfMonth
     */
    public static void calculateTimeDifferenceByPeriod(int year, Month month, int dayOfMonth) {
        LocalDate today = LocalDate.now();
        System.out.println("Today:" + today);
        LocalDate oldDate = LocalDate.of(year, month, dayOfMonth);
        System.out.println("OldDate:" + oldDate);

        Period p = Period.between(oldDate, today);
        System.out.printf("目标日期距离今天的时间差:%d 年 %d 个月 %d 天\n", p.getYears(), p.getMonths(), p.getDays());
    }

    输出为:

    Today:2018-03-13
    OldDate:2014-05-23
    目标日期距离今天的时间差:3 年 9 个月 18 天

    3、java 8中的Duration类
    Duration与Period相对应,Period用于处理日期,而Duration计算时间差还可以处理具体的时间,也是通过调用其静态的between方法,该方法的签名是between(Temporal startInclusive, Temporal endExclusive),因此可以传入两个Instant的实例(Instant实现了Temporal接口),并可以以毫秒(toMillis)、秒(getSeconds)等多种形式表示得到的时间差

    public static void calculateTimeDifferenceByDuration() {
        Instant inst1 = Instant.now();  //当前的时间
        System.out.println("Inst1:" + inst1);
        Instant inst2 = inst1.plus(Duration.ofSeconds(10));     //当前时间+10秒后的时间
        System.out.println("Inst2:" + inst2);
        Instant inst3 = inst1.plus(Duration.ofDays(125));       //当前时间+125天后的时间
        System.out.println("inst3:" + inst3);

        System.out.println("以毫秒计的时间差:" + Duration.between(inst1, inst2).toMillis());

        System.out.println("以秒计的时间差:" + Duration.between(inst1, inst3).getSeconds());
    }

    输出为:

    Inst1:2018-03-13T09:06:00.691Z
    Inst2:2018-03-13T09:06:10.691Z
    inst3:2018-07-16T09:06:00.691Z
    以毫秒计的时间差:10000
    以秒计的时间差:10800000

    4、java 8中的ChronoUnit类
    ChronoUnit的between方法签名为,between(Temporal temporal1Inclusive, Temporal temporal2Exclusive),需要注意的是,如果要以不同的单位展示时间差,between入参中的时间对象必须包含有对应的时间信息,否则会抛出java.time.temporal.UnsupportedTemporalTypeException: Unsupported unit XXX的异常

    /**
     * 使用java 8的ChronoUnit,ChronoUnit可以以多种单位(基本涵盖了所有的,看源码发现竟然还有“FOREVER”这种单位。。)表示两个时间的时间差
     */
    public static void calculateTimeDifferenceByChronoUnit() {
        LocalDate startDate = LocalDate.of(2003, Month.MAY, 9);
        System.out.println("开始时间:" + startDate);

        LocalDate endDate = LocalDate.of(2015, Month.JANUARY, 26);
        System.out.println("结束时间:" + endDate);

        long daysDiff = ChronoUnit.DAYS.between(startDate, endDate);
        System.out.println("两个时间之间的天数差为:" + daysDiff);
    //  long hoursDiff = ChronoUnit.HOURS.between(startDate, endDate);  //这句会抛出异常,因为LocalDate表示的时间中不包含时分秒等信息
    }

    输出为:

    开始时间:2003-05-09
    结束时间:2015-01-26
    两个时间之间的天数差为:4280

    5、传统的SimpleDateFormat类
    用SimpleDateFormat计算时间差的方法,网上找了一份,自己跑了一遍,可以使用,贴在下面

    /**
    * 用SimpleDateFormat计算时间差
    * @throws ParseException 
    */
    public static void calculateTimeDifferenceBySimpleDateFormat() throws ParseException {
        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm");
        /*天数差*/
        Date fromDate1 = simpleFormat.parse("2018-03-01 12:00");  
        Date toDate1 = simpleFormat.parse("2018-03-12 12:00");  
        long from1 = fromDate1.getTime();  
        long to1 = toDate1.getTime();  
        int days = (int) ((to1 - from1) / (1000 * 60 * 60 * 24));  
        System.out.println("两个时间之间的天数差为:" + days);

        /*小时差*/
        Date fromDate2 = simpleFormat.parse("2018-03-01 12:00");  
        Date toDate2 = simpleFormat.parse("2018-03-12 12:00");  
        long from2 = fromDate2.getTime();  
        long to2 = toDate2.getTime();  
        int hours = (int) ((to2 - from2) / (1000 * 60 * 60));
        System.out.println("两个时间之间的小时差为:" + hours);

        /*分钟差*/
        Date fromDate3 = simpleFormat.parse("2018-03-01 12:00");  
        Date toDate3 = simpleFormat.parse("2018-03-12 12:00");  
        long from3 = fromDate3.getTime();  
        long to3 = toDate3.getTime();  
        int minutes = (int) ((to3 - from3) / (1000 * 60));  
        System.out.println("两个时间之间的分钟差为:" + minutes);
    }

    输出为:

    两个时间之间的天数差为:11
    两个时间之间的小时差为:264
    两个时间之间的分钟差为:15840

    总结
    传统的SimpleDateFormat和Java 7中的Calendar在使用的时候需要自己写一个计算时间差的逻辑,比较麻烦,但是却比较灵活,方便根据自己具体的需求来定制(比如,我想两个日期的天数差15天就算满一个月,不满15天不算一个月,如2018-01-04到2018-02-20,算2个月的时间差);而Java 8中的几个计算时间差的类更加方便、精确,可以以不同的单位表示得到的时间差,但要注意几个类所包含的时间信息的区别:

    System.out.println(LocalDate.now());        //只包含日期信息
    System.out.println(LocalTime.now());        //只包含时间信息
    System.out.println(LocalDateTime.now());        //包含日期、时间信息

    输出为:

    2018-03-13
    17:13:26.134
    2018-03-13T17:13:26.135

    以上总结的几个方法只是个例子,具体使用的时候可能需要传入一个或者两个时间进行比较,可能会涉及到这些时间对象的相互转换,Instant、Date、LocalDate等等。。。我就不列举了。。。 
    另外在使用SimpleDateFormat对String类型的日期进行parse的时候,如果传入的日期为:2017-08-60,这种错误的日期,Java默认会按照日期的信息对其进行转换,formatter.parse("2017-08-60");,得到的日期为2017-09-29,而如果不想进行这种转换,而直接将其判定为输入错误,则可以设置formatter.setLenient(false);,这时就会抛出java.text.ParseException异常了

    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    formatter.setLenient(false);
    try {
        Date date = formatter.parse("2017-08-60");  //抛出转换异常
        System.out.println(date);
    } catch (ParseException e) {
        e.printStackTrace();
    }


    获取Sting类型格式-日期中的年月日:
    利用java获取当前的时间(String类型,年-月-日 时:分:秒)
            //获取当前的日期
            Date date = new Date();
            //设置要获取的时间类型
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //获取String类型的时间
            String createdate = sdf.format(date);

    将String类型的日期转换成Data类型,然后获取年月日
    package com.java.util;

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

    import com.sun.org.apache.xerces.internal.impl.xpath.regex.ParseException;

    public class Test {

        public static void main(String[] args) throws java.text.ParseException {

            try {
                String times = "2019-3-22";
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                Date date = sdf.parse(times);
                System.out.println(date);

                // 获取String字符串中的年
                SimpleDateFormat y = new SimpleDateFormat("yyyy");
                System.out.println(y.format(date));
                
                // 获取String字符串中的月
                SimpleDateFormat m = new SimpleDateFormat("MM");
                System.out.println(m.format(date));
                
                // 获取String字符串中的日
                SimpleDateFormat d = new SimpleDateFormat("dd");
                System.out.println(d.format(date));
                 

            } catch (ParseException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            /*
             * Date date = new Date(); SimpleDateFormat dateFormat= new
             * SimpleDateFormat("yyyy-MM-dd"); System.out.println(dateFormat.format(date));
             */
        }
    }
     

    展开全文
  • java判断时间差年月日工具类

    千次阅读 2019-05-15 09:59:52
    一、Java 时间比较需求 1.A时间到B时间,相差多少年,月,日。 如:2011-02-02到 2017-03-02,结果为: * 相差 6年,1个月,0天 2.A时间到B时间, 相差年,月,日各是多少。 如:2011-02-02到 2017-03-02,结果...

    一、Java 时间比较需求

    1.A时间到B时间,相差多少年,月,日。

    如:2011-02-02 到  2017-03-02 ,结果为:

     *  相差 6年,1个月,0天

    2.A时间到B时间, 相差年,月,日各是多少。

    如:2011-02-02 到  2017-03-02,结果为:

     *  以年为单位相差为:6

     *  以月为单位相差为:73个月

     *  以日为单位相差为:2220

    3.A时间到B时间,相差多少年

    如:2011-02-02 到  2017-03-02,结果大约为:  

     * 6.1 

    这个需求体现在如我加入公司 3 年 6 个月,也可以说是3.5年。

    不多说,看代码。

     

    二、Java 时间代码实现

    日期比较对象 DayCompare 代码用到了   lombok回头会讲到。如果你不用,其实就是把getter / setter方法自己写一遍,还有构造方法。

    @Data
    @Builder
    public class DayCompare{
        private int year;
        private int month;
        private int day;
    }

     

    2.1 A时间到B时间,相差多少年,月,日。

    /**
     * 计算2个日期之间相差的  相差多少年月日
     * 比如:2011-02-02 到  2017-03-02 相差 6年,1个月,0天
     * @param fromDate
     * @param toDate
     * @return
     */
    public static DayCompare dayComparePrecise(Date fromDate,Date toDate){
        Calendar  from  =  Calendar.getInstance();
        from.setTime(fromDate);
        Calendar  to  =  Calendar.getInstance();
        to.setTime(toDate);
    
        int fromYear = from.get(Calendar.YEAR);
        int fromMonth = from.get(Calendar.MONTH);
        int fromDay = from.get(Calendar.DAY_OF_MONTH);
    
        int toYear = to.get(Calendar.YEAR);
        int toMonth = to.get(Calendar.MONTH);
        int toDay = to.get(Calendar.DAY_OF_MONTH);
        int year = toYear  -  fromYear;
        int month = toMonth  - fromMonth;
        int day = toDay  - fromDay;
        return DayCompare.builder().day(day).month(month).year(year).build();
    }

     

    2.2 A时间到B时间, 相差年,月,日各是多少

    /**
     * 计算2个日期之间相差的  以年、月、日为单位,各自计算结果是多少
     * 比如:2011-02-02 到  2017-03-02
     *                                以年为单位相差为:6年
     *                                以月为单位相差为:73个月
     *                                以日为单位相差为:2220天
     * @param fromDate
     * @param toDate
     * @return
     */
    public static DayCompare dayCompare(Date fromDate,Date toDate){
        Calendar  from  =  Calendar.getInstance();
        from.setTime(fromDate);
        Calendar  to  =  Calendar.getInstance();
        to.setTime(toDate);
        //只要年月
        int fromYear = from.get(Calendar.YEAR);
        int fromMonth = from.get(Calendar.MONTH);
    
        int toYear = to.get(Calendar.YEAR);
        int toMonth = to.get(Calendar.MONTH);
    
        int year = toYear  -  fromYear;
        int month = toYear *  12  + toMonth  -  (fromYear  *  12  +  fromMonth);
        int day = (int) ((to.getTimeInMillis()  -  from.getTimeInMillis())  /  (24  *  3600  *  1000));
        return DayCompare.builder().day(day).month(month).year(year).build();
    }

     

    2.3 A时间到B时间,相差多少年

    /**
     * 计算2个日期相差多少年
     * 列:2011-02-02  ~  2017-03-02 大约相差 6.1 年
     * @param fromDate
     * @param toDate
     * @return
     */
    public static String yearCompare(Date fromDate,Date toDate){
        DayCompare result = dayComparePrecise(fromDate, toDate);
        double month = result.getMonth();
        double year = result.getYear();
        //返回2位小数,并且四舍五入
        DecimalFormat df = new DecimalFormat("######0.0");
        return df.format(year + month / 12);
    }

     

    版权所属:SO JSON在线解析

    原文地址:https://www.sojson.com/blog/260.html

     

     

     

     

     

    展开全文
  • java中如何计算两个时间段的月份差

    千次阅读 2019-06-21 15:48:46
    直接计算,先取得两个日期的年份和月份月份差=(第二年份-第一年份)*12 + 第二月份-第一月份 转载于:https://www.cnblogs.com/pretty-guy/p/3284593.html
  • java中Date计算时间差

    千次阅读 2020-07-17 12:42:14
    1、java 7中的日历类Calendar Calendar类使用其静态的... *使用Calendar对象计算时间差,可以按照需求定制自己的计算逻辑 * @param strDate * @throws ParseException */ public static void calculateTimeD
  • JAVA计算时间差

    2018-12-24 15:11:30
    1.首先需要将类型转为date。 2.调用.getTime()方法进行相减,得出来的是毫秒 Long responseTimeMs = nowDate.getTime() - appStatistical.getCreateTime().getTime();(所得是毫秒) 3.计算小时  ...
  • Java计算两个时间月份差值

    千次阅读 多人点赞 2019-07-18 16:14:01
    普通的写逻辑去判断两个时间相差月份需要写很多逻辑判断,比如年份比较,那么有什么办法可以快速计算呢? 引入依赖: <dependency> <groupId>joda-time</groupId> <artifactId>joda-time&...
  • package com.dz.provider; import java.util.Calendar; import java.util.Date; public class MonthDiff { /** * 获取两个日期相差的月数 */ public static long getMonthDiff(Date d1, Date d2) { ...
  • public static void main(String[] args) { try { String dateFrom = "2019-12-10 13:22:02"; String dateTo = "2019-12-10 13:22:05"; SimpleDateFormat sdf = new SimpleDateFormat(...
  • 1. 算出日期的时间差 public static void main(String[] args) throws Exception { String inTime="2020-6-20 11:30:00";//入住时间 String outTime="2020-6-25 15:40:00";//退房时间 //1.先算 年月日 ...
  • java 获取两个日期相差的月份

    千次阅读 2019-11-11 11:31:29
    前两天要用到获取两个时间之间的月份差,今天总结下。 /** * 获取连个日期之间相差的月份 * @param startDate * @param endDate * @return * @throws ParseException */ private static List getMonth...
  • java实现输入任意两个日期输出月份数和天数,综合考虑闰年、2月等因素,对于整月计算利息或按天数计算利息提供基础工具类。也可以吧内部类独立出来,方便跨包调用,可自行调整。很实用的一个实现。其他百度查到的很...
  • Java 计算时间差之年龄问题

    千次阅读 2015-05-19 15:23:50
    而有时候年龄需要用到周岁(月、天),这种比较具体的时间,如果小于1岁,需要具体到月,小于1月,具体到天,不足一天的按一天算,只是将当前年份减去出生日期的年份往往不准确。  比如,一个人是1999年12月31日...
  • import org.joda.time.DateTime; import org.joda.time.Months; import org.joda.time.format.DateTimeFormat; import org.joda.time.format.DateTimeFormatter;... * 在JAVA中,如何计算两个...
  • Java8中,我们可以使用以下类来计算日期时间差异: 1.Period 2.Duration 3.ChronoUnit 二.Period类 主要是Period类方法getYears(),getMonths()和getDays()来计算. 示例: package insping; import java.time...
  • java 获取月份工具类、时间工具类

    千次阅读 2018-11-29 15:11:50
    月份工具类 package com.avic.common.statics.task; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; import java.util.Date; import ...
  • java计算两个时间(yyyy-MM-dd HH:mm:ss)相差月数两个时间格式可为年月日时分秒
  • JAVA 计算两个日期相差月份

    万次阅读 2018-12-10 17:21:14
    代码如下:  ... System.out.println("相差月份:" + (Math.abs(month + result) + surplus)); } 打印结果: -1 1 相差月份:25 Process finished with exit code 0 参考链接: ...
  • 1.java.util.Calendar  Calendar 类是一个抽象类,它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法...
  • Java比较时间相差几个月

    万次阅读 2017-08-25 16:20:02
    Java比较时间相差几个月
  • java日期时间转日期 长期以来,正确处理日期,时间,时区,夏令时,and年等一直是我的烦恼。 本文并不是一个全面的指南时域,请参阅日期和时间Java中 -更详细,但略有下降,ekhem,日期。 它仍然是相关的,但是...
  • 这是我自己总结出来的 java根据当前日期+指定天数(月份...)得到相应日期以及计算两日期之,希望对大家带来帮助
  • 网上很多资源都没有输出结果是(相差几年几个月几天的代码)希望对大家有帮助 有不足地方 望大家多多指点
  • java计算相隔时间差以及Joda-Time

    万次阅读 2015-11-26 15:30:01
    java: String tt="2015-11-25 18:18:18 - 2015-11-26 12:09:27"; String start=tt.substring(0,19); String end=tt.substring(22,tt.length()); DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss
  • 如何计算两个时间月份差(包括跨年) /** * 获取两个日期相差的月数 */ public static int getMonthDiff(Date d1, Date d2) { Calendar c1 = Calendar.getInstance(); Calendar c2 = Calendar.getInstance();...
  • iOS 自带了控件,可以自动根据日历来计算 2 个时间相差的自然年、月、日、小时、分钟、秒。Java 没有自带此方法,只能自己来算了~ 一、竖式减法实现 我自己写了一个方法,测试了一些时间和 iOS 作对比,暂时...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,245
精华内容 6,098
关键字:

java月份时间差

java 订阅