精华内容
下载资源
问答
  • 2019-08-19 16:57:26

    写在前面

    java涉及时间比较及差值计算的无非就是Date 、SimpleDateFormat、Calendar三个类,但都没有包含纯粹计算天数差值的方法,要么就是跟业务不匹配(明面上计算的天数,只考虑日期间隔,忽略具体时间的影响),这里记录下在业务需求中获取时间(天数)差值的方案;

    jdk8 之后版本的实现方式(这个实现方式只能计算当月间隔,已废弃)

        public Integer getDayInterval(Date start, Date end){
            LocalDateTime startLocalDateTime = LocalDateTime.ofInstant(start.toInstant(), ZoneId.systemDefault());
            LocalDateTime endLocalDateTime = LocalDateTime.ofInstant(end.toInstant(), ZoneId.systemDefault());
            return Period.between(startLocalDateTime.toLocalDate(), endLocalDateTime.toLocalDate()).getDays();
        }
    

    jdk8之前版本实现方式

        public Integer getDayInterval(Date start, Date end){
            final long nd = 1000 * 24 * 60 * 60;
            Date startDay = new Date(start.getTime() - start.getTime() % nd);
            Date endDay = new Date(end.getTime() - end.getTime() % nd);
            return (int)((endDay.getTime() - startDay.getTime())/nd);
        }
    
    更多相关内容
  • 主要介绍了Java获取时间差(天数差,小时差,分钟差)代码示例,使用SimpleDateFormat来实现的相关代码,具有一定参考价值,需要的朋友可以了解下。
  • 主要为大家详细介绍了java获取两个日期时间差的方法,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了Java获取UTC时间的方法,结合具体实例形式详细分析了Java针对时区、本地时间时间偏移量等相关操作技巧,需要的朋友可以参考下
  • java获取时间段内的月份

    千次阅读 2022-05-05 14:52:28
    Java获取时间段内的月份

    //时间段内的月份
    public static void main(String[] args) {
          String y1 = "2021-11";// 开始时间
          String y2 = "2022-05";// 结束时间
        try {
                Date startDate = new SimpleDateFormat("yyyy-MM").parse(y1); //开始时间 y1 2021-11
                Date endDate = new Date();  //结束时间 当前时间  2022-05
    
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(startDate);
                // 获取开始年份和开始月份
                int startYear = calendar.get(Calendar.YEAR);
                int startMonth = calendar.get(Calendar.MONTH);
                // 获取结束年份和结束月份
                calendar.setTime(endDate);
                int endYear = calendar.get(Calendar.YEAR);
                int endMonth = calendar.get(Calendar.MONTH);
                //
                List<String> list = new ArrayList<String>();
                for (int i = startYear; i <= endYear; i++) {
                    String date = "";
                    if (startYear == endYear) {
                        for (int j = startMonth; j <= endMonth; j++) {
                            if (j < 9) {
                                date = i + "-0" + (j + 1);
                            } else {
                                date = i + "-" + (j + 1);
                            }
                            list.add(date);
                        }
    
                    } else {
                        if (i == startYear) {
                            for (int j = startMonth; j < 12; j++) {
                                if (j < 9) {
                                    date = i + "-0" + (j + 1);
                                } else {
                                    date = i + "-" + (j + 1);
                                }
                                list.add(date);
                            }
                        } else if (i == endYear) {
                            for (int j = 0; j <= endMonth; j++) {
                                if (j < 9) {
                                    date = i + "-0" + (j + 1);
                                } else {
                                    date = i + "-" + (j + 1);
                                }
                                list.add(date);
                            }
                        } else {
                            for (int j = 0; j < 12; j++) {
                                if (j < 9) {
                                    date = i + "-0" + (j + 1);
                                } else {
                                    date = i + "-" + (j + 1);
                                }
                                list.add(date);
                            }
                        }
    
                    }
    
                }
    
                // 所有的月份已经准备好
                //System.out.println(list);
                for(int i = 0;i < list.size();i++){
                    System.out.println(list.get(i));
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            }
    }

     

    展开全文
  • 主要为大家详细介绍了Java获取当前时间年月日的方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java获取时间&时间格式化最全总结

    千次阅读 2020-09-30 09:04:56
    最近遇到很多在Java获取当前时间的问题,有的要求五花八门的,今天总结一下在Java获取时间的方法和时间输出的格式化。

    Java获取时间&时间格式化最全总结

    最近遇到很多在Java里获取当前时间的问题,有的要求五花八门的,今天总结一下在Java中获取时间的方法和时间输出的格式化。

    获取方式

    java.util.Date

    这个是我们最常用的,直接通过util包下得到当前时间通过SimpleDateFormat格式化后输出

    //通过util下的Date包实现
            Date date = new Date();
            SimpleDateFormat dateFormat= new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            System.out.println(dateFormat.format(date));
    

    格式化的输出和不格式化的输出

    image-20200928093839677

    显然不格式化的代码可读性不如格式化后的,在实际开发场景中更需要不同的格式化要求,讲完如何获取之后,后面会讲时间的各种格式化。

    在java8中的新特性里提供了三种时间类LocalDate、LocalTime、LocalDateTime

    *这三个都在java.time包下,后续标题省略包名

    LocalDate

    如果你只需要获取年月日,则用这个再好不过,

    //获取当前年月日
    LocalDate localDate = LocalDate.now();
    System.out.println(localDate);
    

    他的输出就是yyyy-mm-dd

    你也可以通过构造方法构造指定的年月日

    LocalDate localDate1 = LocalDate.of(2077, 7, 17);
    

    image-20200928094535473

    三个参数已经提示的很清晰

    当然,也可以用这个获取单个年月日、星期等

    int year = localDate.getYear();
    int year1 = localDate.get(ChronoField.YEAR);
    Month month = localDate.getMonth();
    int month1 = localDate.get(ChronoField.MONTH_OF_YEAR);
    int day = localDate.getDayOfMonth();
    int day1 = localDate.get(ChronoField.DAY_OF_MONTH);
    DayOfWeek dayOfWeek = localDate.getDayOfWeek();
    int dayOfWeek1 = localDate.get(ChronoField.DAY_OF_WEEK);
    

    月份和星期可以获得指定英文格式,如上。输出结果如下

    image-20200928094921246

    LocalTime

    如果只获取时分秒,那就用这个吧~

    LocalTime localTime = LocalTime.now();
    System.out.println(localTime);
    

    这个也是一样,除了获取当前,也是可以指定附值

    LocalTime localTime1 = LocalTime.of(13, 51, 10);
    System.out.println(localTime1);
    

    输出如下

    image-20200928095322168

    获取范围更小的时分秒

    //获取小时
            int hour = localTime.getHour();
            int hour1 = localTime.get(ChronoField.HOUR_OF_DAY);
            //获取分
            int minute = localTime.getMinute();
            int minute1 = localTime.get(ChronoField.MINUTE_OF_HOUR);
            //获取秒
            int second = localTime.getSecond();
            int second1 = localTime.get(ChronoField.SECOND_OF_MINUTE);
    

    运行如下

    image-20200928095500298

    LocalDateTime

    如果你全都要,那自然是Date+Time=DateTime了

    直接获取

    LocalDateTime now = LocalDateTime.now();
    System.out.println(now);
    DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            System.out.println(now.format(formatter2));
    

    image-20200928095703725

    指定时间

    LocalDateTime localDateTime = LocalDateTime.now();
    LocalDateTime localDateTime1 = LocalDateTime.of(2077, Month.SEPTEMBER, 7, 17, 17, 17);
    LocalDateTime localDateTime2 = LocalDateTime.of(localDate, localTime);
    LocalDateTime localDateTime3 = localDate.atTime(localTime);
    LocalDateTime localDateTime4 = localTime.atDate(localDate);
    //这里的localTime和localDate拿的是上面定义的
    

    image-20200928100139674

    Instant

    拿秒

    我们最熟悉的不过currentTimeMillis,在计算程序运行时间用的比较多,但在java.time包里给我们准备了Instant类,也能拿秒

    // 创建Instant对象
    Instant instant = Instant.now();
    // 获取秒
    long currentSecond = instant.getEpochSecond();
    // 获取毫秒
    long currentMilli = instant.toEpochMilli();
    //常用
    long l = System.currentTimeMillis();
    

    输出情况

    image-20200928100732870

    当然最后这个System类还是牛逼的,毕竟在系统类里。

    时间戳

    格林威治时间1970年01月01日00时00分00秒到现在的总秒数,共10位,单位为秒

    注意:Java生成的时间戳是13位,单位是毫秒

    如果还想拿更精确的秒,System里还有一个nanoTime可以用

    image-20200928103040777

    tips(阿里巴巴开发手册推荐):

    在JDK8中,针对统计时间等场景,推荐使用Instant类

    修改时间

    java.time下的LocalDate、LocalTime、LocalDateTime、Instant类实例的修改方法

    我们直接用LocalDate实例点一下发现他里面封装了很多方法

    image-20200928101301552

    咱这一个一个讲也没必要,大多数都是望文生义,比如plusDays,那自然是在当前日期加天数,得到加完后的日期是哪天

    image-20200928101523567

    怕了吗,加十天国庆假期直接结束。

    还有像什么firstDayOfYear(一年当中第一天是几号)等等不再赘述,另外几个类中也有相似的很多方法。

    格式化输出

    说道日期的格式化输出,大家第一个想到的肯定是

    SimpleDateFormat

    他的用法不尽其数,但是只要知道yyyy-dd-mm–hh-mm-ss之间的关系,想怎么输出就怎么输出。

    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /**
     * <h3>firstIdeaProject</h3>
     * <p></p>
     *
     * @author : Nicer_feng
     * @date : 2020-09-28 10:21
     **/
    public class SimpleDateFormatDemo {
        public static void main(String[] args) {
            SimpleDateFormat myFmt=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
            SimpleDateFormat myFmt1=new SimpleDateFormat("yy/MM/dd HH:mm");
            SimpleDateFormat myFmt2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //等价于now.toLocaleString()
            SimpleDateFormat myFmt3=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E ");
            SimpleDateFormat myFmt4=new SimpleDateFormat("一年中的第 D 天 一年中第w个星期 一月中第W个星期 在一天中k时 z时区");
            SimpleDateFormat myFmt5=new SimpleDateFormat("今年是yyyy,这个月是MM月了,今天是dd号啊");
            Date now=new Date();
            System.out.println(myFmt.format(now));
            System.out.println(myFmt1.format(now));
            System.out.println(myFmt2.format(now));
            System.out.println(myFmt3.format(now));
            System.out.println(myFmt4.format(now));
            System.out.println(myFmt5.format(now));
            System.out.println(now.toString());
            System.out.println(now.toGMTString());
            System.out.println(now.toLocaleString());
        }
    }
    
    

    注意这里的最后两个方法都已经过时了,输出结果如下

    image-20200928103336713

    下面总结在SimpleDateFormat中各个字母的意思

    SimpleDateFormat函数变量/模式字母

    G 年代标志符
    y 年
    M 月
    d 日
    h 时 在上午或下午 (1~12)
    H 时 在一天中 (0~23)
    m 分
    s 秒
    S 毫秒
    E 星期
    D 一年中的第几天
    F 一月中第几个星期几
    w 一年中第几个星期
    W 一月中第几个星期
    a 上午 / 下午 标记符
    k 时 在一天中 (1~24)
    K 时 在上午或下午 (0~11)
    z 时区

    更全的可以见JDK8API中的SimpleDateFormat类

    https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html

    image-20200928110224532

    讲了这么多SimpleDateFormat,但其实在JDK8中,是不推荐使用的,为什么,因为SimpleDateFormat是线程不安全的。所以我们在JDK8应用中推荐用Instant代替Date,LocalDateTime带Calendar,DateTimeFormatter代替SimpleDateFormat,官方解释是simple beautiful strong immutable thread-safe。

    DateTimeFormatter(重要)

    跟上面的SimpleDateFormat函数变量基本无异,写一个简单的demo

    LocalDate localDate = LocalDate.now();
            String format1 = localDate.format(DateTimeFormatter.BASIC_ISO_DATE);
            //yyyyMMdd
            String format2 = localDate.format(DateTimeFormatter.ISO_DATE);
            //yyyy-MM-dd
            //2.LocalTime  --> String
            LocalTime localTime = LocalTime.now();
            String format3 = localTime.format(DateTimeFormatter.ISO_TIME);
            //20:19:22.42
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("hh:mm:ss");
            String format4 = localTime.format(formatter);
            //3.LocalDateTime  --> String
            LocalDateTime localDateTime = LocalDateTime.now();
            DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
            String format5 = localDateTime.format(formatter2);
    
            System.out.println(format1);
            System.out.println(format2);
            System.out.println(format3);
            System.out.println(format4);
            System.out.println(format5);
    

    输出

    image-20200928105612447

    这个DateTimeFormatter甚至能按照当地习惯来输出

    LocalDateTime localDateTime = LocalDateTime.now();
    DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy MMM dd EE HH:mm", Locale.CHINA);
            String format5 = localDateTime.format(formatter2);
    

    输出

    image-20200928110004377

    但是官方给我们弄得总是不符合我们心里预期,所以这里推荐自己封装DateTimeUtils类来调用

    DateTimeUtils封装

    DateTimeUtils.java

    package TimeUtilssss;
    
    import java.time.*;
    import java.time.format.DateTimeFormatter;
    import java.time.temporal.ChronoUnit;
    
    /**
     * <h3>firstIdeaProject</h3>
     * <p></p>
     *
     * @author : Nicer_feng
     * @date : 2020-09-28 10:48
     **/
    public class DateTimeUtils {
        public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HHmmss");
        public static final DateTimeFormatter YEAR_MONTH_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM");
        public static final DateTimeFormatter SHORT_DATE_FORMATTER = DateTimeFormatter.ofPattern("yyMMdd");
        public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        public static final DateTimeFormatter SHORT_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyMMddHHmmss");
        public static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        public static final DateTimeFormatter LONG_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss SSS");
    
        /**
         * 返回当前的日期
         */
        public static LocalDate getCurrentLocalDate() {
            return LocalDate.now();
        }
    
        /**
         * 返回当前时间
         */
        public static LocalTime getCurrentLocalTime() {
            return LocalTime.now();
        }
    
        /**
         * 返回当前日期时间
         */
        public static LocalDateTime getCurrentLocalDateTime() {
            return LocalDateTime.now();
        }
    
        /**
         * yyyy-MM-dd
         */
        public static String getCurrentDateStr() {
            return LocalDate.now().format(DATE_FORMATTER);
        }
    
        /**
         * yyMMdd
         */
        public static String getCurrentShortDateStr() {
            return LocalDate.now().format(SHORT_DATE_FORMATTER);
        }
    
        public static String getCurrentMonthStr() {
            return LocalDate.now().format(YEAR_MONTH_FORMATTER);
        }
    
        /**
         * yyyy-MM-dd HH:mm:ss
         */
        public static String getCurrentDateTimeStr() {
            return LocalDateTime.now().format(DATETIME_FORMATTER);
        }
    
    
        public static String getCurrentLongDateTimeStr(){
            return LocalDateTime.now().format(LONG_DATETIME_FORMATTER);
        }
    
        /**
         * yyMMddHHmmss
         */
        public static String getCurrentShortDateTimeStr() {
            return LocalDateTime.now().format(SHORT_DATETIME_FORMATTER);
        }
    
        /**
         * HHmmss
         */
        public static String getCurrentTimeStr() {
            return LocalTime.now().format(TIME_FORMATTER);
        }
    
        public static String getCurrentDateStr(String pattern) {
            return LocalDate.now().format(DateTimeFormatter.ofPattern(pattern));
        }
    
        public static String getCurrentDateTimeStr(String pattern) {
            return LocalDateTime.now().format(DateTimeFormatter.ofPattern(pattern));
        }
    
        public static String getCurrentTimeStr(String pattern) {
            return LocalTime.now().format(DateTimeFormatter.ofPattern(pattern));
        }
    
        public static LocalDate parseLocalDate(String dateStr, String pattern) {
            return LocalDate.parse(dateStr, DateTimeFormatter.ofPattern(pattern));
        }
    
        public static LocalDateTime parseLocalDateTime(String dateTimeStr, String pattern) {
            return LocalDateTime.parse(dateTimeStr, DateTimeFormatter.ofPattern(pattern));
        }
    
        public static LocalTime parseLocalTime(String timeStr, String pattern) {
            return LocalTime.parse(timeStr, DateTimeFormatter.ofPattern(pattern));
        }
    
        public static String formatLocalDate(LocalDate date, String pattern) {
            return date.format(DateTimeFormatter.ofPattern(pattern));
        }
    
        public static String formatLocalDateTime(LocalDateTime datetime, String pattern) {
            return datetime.format(DateTimeFormatter.ofPattern(pattern));
        }
    
        public static String formatLocalTime(LocalTime time, String pattern) {
            return time.format(DateTimeFormatter.ofPattern(pattern));
        }
    
        public static LocalDate parseLocalDate(String dateStr) {
            return LocalDate.parse(dateStr, DATE_FORMATTER);
        }
    
        public static LocalDateTime parseLocalDateTime(String dateTimeStr) {
            return LocalDateTime.parse(dateTimeStr, DATETIME_FORMATTER);
        }
    
        public static LocalDateTime parseLongLocalDateTime(String longDateTimeStr){
            return LocalDateTime.parse(longDateTimeStr, LONG_DATETIME_FORMATTER);
        }
    
        public static LocalTime parseLocalTime(String timeStr) {
            return LocalTime.parse(timeStr, TIME_FORMATTER);
        }
    
        public static String formatLocalDate(LocalDate date) {
            return date.format(DATE_FORMATTER);
        }
    
        public static String formatLocalDateTime(LocalDateTime datetime) {
            return datetime.format(DATETIME_FORMATTER);
        }
    
        public static String formatLocalTime(LocalTime time) {
            return time.format(TIME_FORMATTER);
        }
    
        /**
         * 日期相隔秒
         */
        public static long periodHours(LocalDateTime startDateTime,LocalDateTime endDateTime){
            return Duration.between(startDateTime, endDateTime).get(ChronoUnit.SECONDS);
        }
    
        /**
         * 日期相隔天数
         */
        public static long periodDays(LocalDate startDate, LocalDate endDate) {
            return startDate.until(endDate, ChronoUnit.DAYS);
        }
    
        /**
         * 日期相隔周数
         */
        public static long periodWeeks(LocalDate startDate, LocalDate endDate) {
            return startDate.until(endDate, ChronoUnit.WEEKS);
        }
    
        /**
         * 日期相隔月数
         */
        public static long periodMonths(LocalDate startDate, LocalDate endDate) {
            return startDate.until(endDate, ChronoUnit.MONTHS);
        }
    
        /**
         * 日期相隔年数
         */
        public static long periodYears(LocalDate startDate, LocalDate endDate) {
            return startDate.until(endDate, ChronoUnit.YEARS);
        }
    
        /**
         * 是否当天
         */
        public static boolean isToday(LocalDate date) {
            return getCurrentLocalDate().equals(date);
        }
        /**
         * 获取当前毫秒数
         */
        public static Long toEpochMilli(LocalDateTime dateTime) {
            return dateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
        }
    
        /**
         * 判断是否为闰年
         */
        public static boolean isLeapYear(LocalDate localDate){
            return localDate.isLeapYear();
        }
    }
    
    

    实例化LocalDate类后直接format调用即可

    时间戳格式化

    拿到Java中13位时间戳以后,我们可以做啥?

    long l = System.currentTimeMillis();
    System.out.println(l);
    //输出	1601260690773
    

    刚才说正常的时间戳是10位,Java中多的3位是毫秒级别,如果不要毫秒直接输出咋办?当然是丢掉后面3位啦,你可以直接除1000,或者把时间戳转为字符串,只拿前十位

    long l = System.currentTimeMillis();
    System.out.println(l);
    System.out.println(l/1000);
    String l1 = (l + "").substring(0, 10);
    System.out.println(l1);
    

    image-20200928104100794

    咱时间戳也是可以直接用SimpleDateFormat 来格式化的,这里做个示范,其他具体操作可以看上面的

    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String s = format.format(l);
    System.out.println(s);
    

    image-20200928104225707

    参考资料:

    阿里巴巴Java开发手册泰山版

    DateTimeUtil工具类来自

    https://blog.csdn.net/tanhongwei1994/article/details/86680845

    展开全文
  • 主要介绍了Java获得当前时间前指定几个小时具体时间的方法,涉及java使用Calendar针对日期时间的相关运算与转换操作技巧,需要的朋友可以参考下
  • 主要为大家详细介绍了java获取指定开始时间与结束时间之间的所有日期,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了Java获取当地的日出日落时间代码分享,国外猿友写的一个类,需要的朋友可以参考下
  • Calendar c = new GregorianCalendar(); c.setFirstDayOfWeek(Calendar.MONDAY); c.setTime(new Date()); c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday System.out.println(c.getTime());...
  • 针对java获取Date时间的各种方式汇总,有常用的时间获取方式,还有一些其他特殊时间获取方式,感兴趣的小伙伴们可以参考一下
  • java获取今天、昨天、近一周、近两周、近三周、近一月、近两月、近三月、近半年、本周、上周、本月、上月时间
  • java获取时间整点工具代码

    千次阅读 2019-07-15 10:55:27
    以下是获取向前,向后 或者当前时间的整点时间 /** * 获取当前时间小时整点时间 * * @param * @return */ public static Date getCurrentHourTime() { return getHourTime(new Date(), 0, "="); } ...

     以下是获取向前,向后 或者当前时间的整点时间

        /**
         * 获取当前时间小时整点时间
         *
         * @param 
         * @return
         */
        public static Date getCurrentHourTime() {
            return getHourTime(new Date(), 0, "=");
        }
    
        /**
         * 获取指定时间上n个小时整点时间
         *
         * @param date
         * @return
         */
        public static Date getLastHourTime(Date date, int n) {
            return getHourTime(date, n, "-");
        }
    
        /**
         * 获取指定时间下n个小时整点时间
         *
         * @param date
         * @return
         */
        public static Date getNextHourTime(Date date, int n) {
            return getHourTime(date, n, "+");
        }
    
        /**
         * 获取指定时间n个小时整点时间
         *
         * @param date
         * @return
         */
        public static Date getHourTime(Date date, int n, String direction) {
            Calendar ca = Calendar.getInstance();
            ca.setTime(date);
            ca.set(Calendar.MINUTE, 0);
            ca.set(Calendar.SECOND, 0);
            switch (direction) {
                case "+":
                    ca.set(Calendar.HOUR_OF_DAY, ca.get(Calendar.HOUR_OF_DAY) + n);
                    break;
                case "-":
                    ca.set(Calendar.HOUR_OF_DAY, ca.get(Calendar.HOUR_OF_DAY) - n);
                    break;
                case "=":
                    ca.set(Calendar.HOUR_OF_DAY, ca.get(Calendar.HOUR_OF_DAY));
                    break;
                default:
                    ca.set(Calendar.HOUR_OF_DAY, ca.get(Calendar.HOUR_OF_DAY));
            }
    
            date = ca.getTime();
            return date;
        }

     

    展开全文
  • 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 获取时间日期

    千次阅读 2021-03-17 13:01:16
    java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。第一个构造函数使用当前日期和时间来初始化对象。Date( )第二个构造函数接收一个参数,该参数是从1970年1月1日起...
  • java获取年月日时分秒的方法
  • java获取当前时间和前一天日期的实现代码。需要的朋友可以过来参考下,希望对大家有所帮助
  • Java获取本周一、上周一、下周一时间Java获取本周一、上周一、下周一时间Java获取本周一、上周一、下周一时间Java获取本周一、上周一、下周一时间
  • Java中描述日期时间调用Date类型,该类型存储有时间的年月日、时分秒信息。 其中: 需要获取时间单位 格式 年 YYYY or yyyy 月 MM(大写) 日 dd(小写) 时 HH or hh 分 mm(小写) 秒 ss...
  • JAVA获取当前时间并转换成string格式
  • * @Description: 获取时间字符串的工具类 * @Date: 2020/8/18 16:01 * @LastModify: 2020/8/19 17:00 */ public class DatetimeUtil { /** * 获取当前时间的8位字符串 * @return 返回时间字符串yyyy-MM
  • java 获取当前时间的三种方法

    千次阅读 2022-03-21 14:45:09
    1.通过Util包中的Date获取 Date date = new Date(); SimpleDateFormat dateFormat= new SimpleDateFormat("yyyy-MM-dd :hh:mm:ss"); System.out.println(dateFormat.format(date)); 2.通过Util包的Calendar 获取 ...
  • 主要介绍了在java获取List集合中最大的日期时间操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • JAVA获取当前时间的三种方法

    万次阅读 2021-12-20 23:03:46
    Java中显示当前时间的三种方式,各有优缺点。
  • java代码-以当前时间获取上周、本周、下周、下下周的结束时间
  • Java:如何获取当前时间

    千次阅读 2021-12-17 20:08:58
    本文介绍如何从新的 Java 8 java.time.* 中获取当前日期时间,如 Localdate、LocalTime、LocalDateTime、ZonedDateTime、Instant 以及旧的日期时间 API,如 Date 和 Calendar。 新旧API: 对于新的 Java 8 的java....
  • java8中获取两个时间时间

    万次阅读 2019-02-20 14:16:14
    工作中我们经常会想查看一个方法执行的性能,就会通过在方法入口和出口处记算一下时间差值,像下面代码这样: long start = System.currentTimeMillis(); //business code Thread.sleep(1000); long over = ...
  • JAVA获得当前系统时间

    千次阅读 2021-03-03 12:22:07
    获取当前系统时间和日期并格式化输出:import java.util.Date;import java.text.SimpleDateFormat;public class NowString {public static void main(String[] args) {SimpleDateFormat df = new SimpleDateFormat(...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,474,787
精华内容 589,914
关键字:

java获取时间

java 订阅
友情链接: vrml-sofare.zip