精华内容
下载资源
问答
  • 1小时内显示分钟(不到下一个整数,就按当前整数算,例:1分50秒;显示1分钟前);一天内显示小时(规则一样);后面都显示几天前就可以。 public class test(){ DateFormat df = new SimpleDateFormat("yyyy-MM-dd ...
    一分钟内显示“刚刚”;1小时内显示分钟(不到下一个整数,就按当前整数算,例:1分50秒;显示1分钟前);一天内显示小时(规则一样);后面都显示几天前就可以。
    public class test(){
    DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String str1 = "2016-12-15 14:03:10.23";
            try {
                Date date = df.parse(str1);
                long[] times = getDistanceTimes(date);
                if(times[0]>0){
                    System.out.println(times[0]+"天前");
                }else if(times[1]>0){
                    System.out.println(times[1]+"小时前");
                }else if(times[2]>0){
                    System.out.println(times[2]+"分钟前");
                }else{
                    System.out.println(times[3]+"秒前");
                }
            } catch (ParseException e) {
                e.printStackTrace();
            }
        public static long[] getDistanceTimes(Date date) {
            long day = 0;
            long hour = 0;
            long min = 0;
            long sec = 0;
            long diff;
            diff = System.currentTimeMillis() - date.getTime();
            day = diff / (24 * 60 * 60 * 1000);
            hour = (diff / (60 * 60 * 1000) - day * 24);
            min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
            sec = (diff/1000-day*24*60*60-hour*60*60-min*60);
            long[] times = {day, hour, min, sec};
            return times;
        }
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 一、java获取当前时间的集中方式 建议记住固定的api,因为是java的原生api,且在项目中会经常用到,记住之后可以手到擒来,其他的简单的api也建议可以背下来,同理。

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档


    前言

    建议记住固定的api,因为是java的原生api,且在项目中会经常用到,记住之后可以手到擒来,其他的简单的api也建议可以背下来,同理。

    提示:以下是本篇文章正文内容,下面案例可供参考,新手小白:最后有作业哦~如果想锻炼api,可以做一下文章最后的作业。

    一、场景介绍

    java获取当前时间

    场景一:在工作中会经常用到获取当前时间,计算时间差,例如:保存到数据库的时候,除了用数据库函数之外可以给字段赋值之后保存到数据库里面;

    java计算时间差

    场景二:提醒或超时功能,在未来的某一个时间提醒或在未来的某一个时间修改超时状态,那么需要在当前时间加上几天或者几个小时之后再保存的数据库里面。

    二、代码时间

    1.获取当前时间

    代码如下(示例):

    public static void main(String[] args){
            
            //1、用Date对象然后格式化
            Date date1=new Date();
            DateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateStr = dateFormat.format(date1);
            System.out.println(dateStr);  //2020-10-30 17:47:25
    
            //2、用Calendar对象
            Calendar calendar = Calendar.getInstance();
            System.out.println(calendar.getTime().toLocaleString());//2020-10-30 17:47:25
    
            //3、用DateFormat对象
            DateFormat dateTimeInstance = DateFormat.getDateTimeInstance();
            String format = dateTimeInstance.format(new Date());
            System.out.println(format);//2020-10-30 17:47:25
            
            /*请注意Calendar和DateFormat不是new出来的!最好可以记住,以免在使用的时候影响工作效率*/
        }
    

    2.时间计算(加、减)

    时间加法(示例):

    public static void main(String[] args){
             //一、加法时间计算方法可以使用Calendar对象
            Calendar calendar = Calendar.getInstance();
            //初始化日期格式化对象,后面会用到
            DateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //1、获取当前时间:calendar.getTime() api是获取当前时间,打印出来是:Fri Oct 30 18:00:04 CST 2020
            calendar.setTime(calendar.getTime());
            Date nowDate = calendar.getTime();
            String nowDateStr = dateformat.format(nowDate);
            System.out.println(nowDateStr);//当前时间:2020-10-30 18:10:51
            //2、当前时间增加24小时
            calendar.add(Calendar.HOUR, 24);
            Date addition24HourDate = calendar.getTime();
            String addition24DateStr = dateformat.format(addition24HourDate);
            System.out.println(addition24DateStr);//增加小时 2020-10-31 18:10:51
            //3、再增加5分钟
            calendar.add(Calendar.MINUTE, 5);
            Date addition5MinuteDate = calendar.getTime();
            String addition5MinuteDateStr = dateformat.format(addition5MinuteDate);
            System.out.println(addition5MinuteDateStr);//增加分钟 2020-10-31 18:15:51
            //4、再增加1年
            calendar.add(Calendar.YEAR, 1);
            Date addition1YearDate = calendar.getTime();
            String addition1YearDateStr = dateformat.format(addition1YearDate);
            System.out.println(addition1YearDateStr);//增加年 2021-10-31 18:15:51
    
            /*请注意代码中用到的是同一Calendar对象,所以时间是累加,如果是不累加,需要用新的Calendar对象*/
        }
    

    时间减法(示例):

    public static void main(String[] args) throws ParseException {
            //一、时间减法可以用Calendar对象加法中,把第二个参数换成负数可以时间,这边就不列举了;使用第二种方式做时间减法
            //1、指定两个Date对象,业务中可以以参数的形式传递,不用new当前时间。
            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date nowDate = new Date(); //当前时间
            String yesterday = "2020-10-29 12:35:28";
            Date yesterdayDate = dateFormat.parse(yesterday);//假设一个时间,工作业务中可以参数传递的形式来获取。
            //2、时间戳相减
            long yesterdayDateTime = yesterdayDate.getTime();//昨天的时间戳
            long nowDateTime = nowDate.getTime();//当前时间戳
            int result = (int) (nowDateTime - yesterdayDateTime);//毫秒
            //3、换算成秒
            int diffSecond = result / 1000; //1000毫秒等于1秒
            System.out.println(diffSecond); //108296 秒
            //4、换算成分钟
            int diffMinute = result / 1000 / 60;//60秒等于1分钟
            System.out.println(diffMinute);//1805 分钟
            //5、换算成是小时
            int diffHour = result / 1000 / 60 / 60;//60分钟等于1小时
            System.out.println(diffHour);//30小时
            //6、换算成天
            int diffDay = result / 86400000;
            System.out.println(diffDay);//1天
        }
        }
    

    需求

    大神走开,小白留下:
    小白菜鸟,以上就是今天要讲的内容,如果想快速记住api建议思考以下需求,并且完成:
    作业一:在订火车票的时候,如果两辆车发车时间在30分钟之内不允许再定车票,如果大于30分钟才可以订车票。
    作业二:在内部管理系统有一个预约访谈的功能,如果已经在某个时刻预约了一个访谈,那么在这个访谈之后1个小时内不允许再预约第二个访谈,以此类推。
    作业三:在工作中会把获取当前时间 增加年 增加月 增加日 减年 减月 减日 等方法封装为DateUtils类,并且把每个计算封装成为静态方法,请按照今天学习的内容思考,并且完成静态方法类DateUtils的封装。

    展开全文
  • 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();
    }
    展开全文
  • 另外,System类的静态函数public long currentTimeMillis()可以获得系统当前时间,距离1970年1月1日8点的时间差,返回的是毫秒数。 一般将Data类型转换成Calendar类型方便使用。 转换函数: //Date类型转Calendar...

    java中和时间有关的类包括Data类和Canlendar类

    Data类

    1、使用无参构造函数

    Data nowTime = new Date()
    #输出的就是当前的时间
    

    2、带参构造函数这里不再说明

    另外,System类的静态函数public long currentTimeMillis()可以获得系统当前时间,距离1970年1月1日8点的时间差,返回的是毫秒数。

    一般将Data类型转换成Calendar类型方便使用。

    转换函数:
    //Date类型转Calendar类型
        public static Calendar dataToCalendar(Date date) {
            Calendar calendar = Calendar.getInstance();
            calendar.clear();
            calendar.setTime(date);
            return calendar;
        }
    

    Calendar

    初始化calendar实例

    Calendar calendar = Calendar.getInstance();
    

    通过calendar可以获得时间的年月日等信息。

    具体代码如下:

    实现功能:对一特定时间和当前时间的时间差,以最大的时间差输出,次序为:年、月、日、时、分、秒。

    主函数:
    		StringTokenizer fenxi = new StringTokenizer(getTime("2020-07-29 11:37:17"),"|");
            int[] result = new int[2];
            int i = 0;
            while (fenxi.hasMoreTokens()){
                result[i] = Integer.parseInt(fenxi.nextToken());
                i++;
            }
            String[] time_list = {"年","月","天","小时","分钟","秒"};
            System.out.println(""+result[0]+time_list[result[1]]+"前");
    
    public static String getTime(String log_time){
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date time_now = new Date();
            long diff = 0;
            String CountTime = "";
            int year=0,month=0,day=0;
            long hours=0,minutes=0,s=0;
            try {
                Date time_ago = df.parse(log_time);
                diff = time_now.getTime() - time_ago.getTime();
                Calendar  currentTimes =dataToCalendar(time_now);//当前系统时间转Calendar类型
                Calendar  pastTimes =dataToCalendar(time_ago);//查询的数据时间转Calendar类型
                year = currentTimes.get(Calendar.YEAR) - pastTimes.get(Calendar.YEAR);//获取年
                month = currentTimes.get(Calendar.MONTH) - pastTimes.get(Calendar.MONTH);
                day = currentTimes.get(Calendar.DAY_OF_MONTH) - pastTimes.get(Calendar.DAY_OF_MONTH);
                if (month < 0) {
                    month = (month + 12) % 12;//获取月
                    year--;
                }
                if (day < 0) {
                    month -= 1;
                    currentTimes.add(Calendar.MONTH, -1); //减一个月
                    day = day + currentTimes.getActualMaximum(Calendar.DAY_OF_MONTH);//获取日
                }
                long days = diff / (1000 * 60 * 60 * 24);
                hours = (diff-days*(1000 * 60 * 60 * 24))/(1000* 60 * 60); //获取时
                minutes = (diff-days*(1000 * 60 * 60 * 24)-hours*(1000* 60 * 60))/(1000* 60);  //获取分钟
                s=(diff/1000-days*24*60*60-hours*60*60-minutes*60);//获取秒
                CountTime=""+year+"年"+month+"月"+day+"天"+hours+"小时"+minutes+"分"+s+"秒";
            } catch (ParseException e) {
                e.printStackTrace();
            }
            System.out.println(CountTime);
            return year != 0 ? ""+year+"|"+0 :
                   month != 0 ? ""+month+"|"+1 :
                   day != 0 ? ""+day+"|"+2 :
                   hours != 0 ? ""+hours+"|"+3 :
                   minutes != 0 ? ""+minutes+"|"+4 : ""+s+"|"+5 ;
        }
    
    输出结果:2月前
    
    展开全文
  • //获取当前时间 System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss:SSS").format(new Date())); /** * 根据String型时间,获取long型时间,单位毫秒 * @param inVal 时间字符串 * @...
  • java中Date计算时间差

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

    2013-08-01 08:49:47
    很简单的java计算当前日期至指定日期的时间差的程序
  • * 计算传入时间距离当前时间多久 * * @param date * @return */ public static String getTimeDiff(String date) { if (ObjectUtils.isEmpty(date)) { return ""; } StringBuilder sb = new StringBu...
  • java获取当前时间到凌晨0点的秒

    千次阅读 2019-11-02 14:38:59
    上面这段代码存在一个问题,就是如果当前时间超过中午12:00,则返回的结果是当前时间到第二天中午12:00的秒数; 如果当前时间不超过中午12:00,则返回的结果是到第二天凌晨的秒数 解决方案 public Long...
  • System.out.println("当前系统时间为:"+newCurrentTime+"数据中的上报时间:"+oldReportTime+"两个时间差为:"+diff); } 执行结果 获取两个日期相差的天数 /** * 获取两个日期相差的天数 * * @param startDateStr ...
  • java计算时间差及比较时间大小

    千次阅读 2018-11-28 19:37:59
    我现在要获得两个日期,的形式为:XX天XX小时XX分XX秒 方法一: DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); try {  Date d1 = df.parse("2004-03-26 13...
  • Java Calendar 计算时间差

    千次阅读 2016-07-26 14:25:00
    System.out.println("当前时间:"+f.format(now.getTime())); System.out.println("设定时间:"+f.format(c.getTime())); System.out.println("时间差:"+dTime+"天"+hTime%24+"时"+mTime%60+"分"+sTime%60+...
  • @[toc](Java 关于计算程序运行的时间差System类的...System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。 此方法用于计算时间差 public...
  • javaDate 计算时间差

    千次阅读 2018-10-08 12:27:05
    public static String getDatePoor(Date endDate, Date nowDate) { long nd = 1000 * 24 * 60 * 60; long nh = 1000 * 60 * 60; long nm = 1000 * 60;... // 获得两个时间的毫秒时间差异 ...
  • Java日期时间差计算-Hutool

    千次阅读 2020-12-16 15:33:15
    //定义变量记录时间差 String time = ""; Date in = cn.hutool.core.date.DateUtil.parse(“2020-12-14 16:18:16”); Date out = cn.hutool.core.date.DateUtil.parse("2020-12-14 15:20:17"); Long day = ...
  • java计算时间精确到秒

    千次阅读 2019-03-21 15:13:05
    /** ... * @param firstLoginTime 最小的时间 * @param nowTime传递最大的时间 * @return */ public static JSONObject getDistanceTime(String firstLoginTime, String nowTime) { JSONOb...
  • //测试主方法 public static void main(String[] args) { ... //当前系统时间 Date firstTime = df.parse("2004-01-02 11:30:24"); //查询的数据时间 String str=getTime(currentTime ,firstTime );
  • Java中获取一个当前时间毫秒值,比如现在1416725832762-->2014-11-23 14:57:12,实际时间距离北京时间今天0点已经过去将近15个小时,如果直接将这个数对86400000(24个小时的毫秒值)取余,得到的余数换算出来大概...
  • Java 计算分钟

    千次阅读 2018-06-15 16:21:30
    现在的时间是:2018-06-15 16:12:31过去的时间是:2018-06-15 13:40:15计算两者的分钟,现在时间直接获取系统时间,过去时间需要从数据库中查。代码如下:import java.text.DateFormat; import java.text....
  • JAVA 计算String类型的时间差(秒)

    千次阅读 2018-12-29 16:57:00
    * 根据数据库时间查询当前一共创建了多少个订单数量 * 覃光林 * 2018-12-29 11:06:16 */ @RequestMapping("/queryCreateOrderNumber") public String GetCreateOrderNumber() { System.out.println(...
  • java相对时间的工具类,此类中有两个暴露的方法,相对于当前时间的方法和相对于某时间的方法。 返回String,如:2小时前/3天2时13秒/昨天
  • * 得到系统时间到第二天凌晨的时间差 * 返回毫秒数 * @param date * @return */ public static long getSecondDayDifference(Date date) { Calendar cal = Calendar.getInstance(); cal.setTime(date); int ...
  • java算出两个时间差(LocalDateTime)

    千次阅读 2020-11-04 17:29:49
    对象介绍 Object desc format LocalDateTime 日期时间 ...获取当前时间 of 获取指定时间 判断 Prefix is Suffix desc after 是否在传入对象, 之后 before 是否在传入对象, 之前.
  • java实现两个日期时间差算出分钟差

    千次阅读 2020-07-24 15:36:47
    java实现两个日期时间差算出分钟差 1.用代码实现两个时间的分钟差 // 获取时间 LocalDateTime time1 = "2020-06-08 09:28:45"; LocalDateTime time2 = "2020-08-01 16:34:56"; //计算出两个时间的差值 Duration ...
  • Java 计算时间差之年龄问题

    千次阅读 2015-05-19 15:23:50
    年月日天数计算
  • NULL 博文链接:https://mr-lili-1986-163-com.iteye.com/blog/2165773
  • 这是我自己总结出来的 java根据当前日期+指定天数(月份...)得到相应日期以及计算两日期之,希望对大家带来帮助
  • 1.java.util.Calendar  Calendar 类是一个抽象类,它为特定瞬间一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法...
  • java 比较时间大小 现在是2004-03-26 13:31:40 过去是:2004-01-02 11:30:24 要获得两个日期的形式为:XX天XX小时XX分XX秒 方法一: DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:...
  • java中如何计算两个时间段的月份

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 75,226
精华内容 30,090
关键字:

java计算与当前时间差

java 订阅