精华内容
下载资源
问答
  • JAVA时间类及java8新时间类

    千次阅读 2019-06-28 17:27:20
    java.util.Date 时区 GMT(Greenwich Mean Time)代表格林尼治标准时间,这个大家都知道。 而CST却同时可以代表如下 4 个不同的时区: Central Standard Time (USA) UT-6:00 Central Standard Time (Australia) UT+...

    java.util.Date

    时间类框架

    时区

    GMT(Greenwich Mean Time)代表格林尼治标准时间,这个大家都知道。

    而CST却同时可以代表如下 4 个不同的时区:

    • Central Standard Time (USA) UT-6:00
    • Central Standard Time (Australia) UT+9:30
    • China Standard Time UT+8:00
    • Cuba Standard Time UT-4:00

    java.util.Date基本使用

    初始化

    Date date = new Date();
    Date date1 = new Date(1000L);
    // 默认创建一个本地时间, long类型
    // Date date = new Date(System.currentTimeMillis());
    // 从1970-1-1 0:0:0开始
    

    输出时间

    System.out.println(date1);
    // 打印出北京时间 Thu Jan 01 08:00:01 CST 1970
    System.out.println(date1.toGMTString());
    // 打印出格林标准时间 1 Jan 1970 00:00:01 GMT
    

    输出时差

    // 返回与格林时间的时差, 以分钟计时, 正好是8个小时, 此函数输出-480   则北京时间-480分钟等于格林时间
    date1.getTimezoneOffset();
    

    打印毫秒数

    long m = date1.getTime();
    // 打印出date到1970年1月1日的毫秒数
    System.out.println("m = " + m);
    

    比较时间

    // 比较时间
    // 返回boolean类型
    date.after(date1);
    date.before(date1);
    // 返回-1 1 0
    date.compareTo(date1);
    

    java.util.Date的子类

    java.sql.Date的使用

    // sql包的date类, 接收一个毫秒值
    java.sql.Date sqldate = new java.sql.Date(1000L);
    // 输出一个这样的字符串 1970-01-01
    System.out.println(sqldate);
    // 转换成格林时间和util中date输出一样
    System.out.println(sqldate.toGMTString());
    

    java.sql.Timestamp使用

    java.sql.Timestamp timestamp = new Timestamp(2000L);
    // 返回的均为本地时间
    //1970-01-01 08:00:02.0
    //1970-01-01T08:00:02
    System.out.println(timestamp);
    System.out.println(timestamp.toLocalDateTime());
    
    // 返回一个格林瞬时时间
    // 1970-01-01T00:00:02Z
    System.out.println(timestamp.toInstant());
    

    java.sql.Time使用

    java.sql.Time time = new Time(3000L);
    // 返回一个不带日期的本地时间  08:00:03
    System.out.println(time);
    

    SimpleDateFormat使用

    Date date = new Date();
    // 指定格式输出时间
    // yyyy 年   MM 月   dd日   h 12小时制   H  24小时制0-23   ss秒     SSS毫秒
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss.SSS");
    System.out.println(dateFormat.format(date));
    
    // 将指定格式的字符串转化成Date
    // "2018-05-26 09:03:22.658"
    DateFormat dateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    try {
       date = dateFormat1.parse("2018-05-26 09:03:22.658");
       // 输出 date = Sat May 26 09:03:22 CST 2018
       System.out.println("date = " + date);
    } catch (ParseException e) {
       e.printStackTrace();
    }
    

    Calender 使用

    GregorianCalendar类中存放了各国的标准日历

    Calendar calendar = new GregorianCalendar();
    
    // 设置日历时间
    calendar.set(Calendar.YEAR, 2019);
    calendar.set(Calendar.MONTH, 5);
    calendar.set(Calendar.DAY_OF_MONTH, 26);
    
    //使用Date类设置calendar时间
    calendar.setTime(new Date());
    
    //取得日历时间 calendar.getTime();  返回一个Date对象
    // 输出Wed Jun 26 12:58:42 CST 2019
    System.out.println(calendar.getTime().toString());
    
    //使用日历取得时间偏移
    // 输出Tue Jun 26 12:58:42 CST 2029
    calendar.add(Calendar.YEAR, 10);
    System.out.println(calendar.getTime().toString());
    

    java8 新特性—java.time包 时间处理类

    LocalDate类

    // 本地日期
    LocalDate localDate = LocalDate.of(2019, 2, 14);
    System.out.println(localDate);
    int year = localDate.getYear(); //那一年
    System.out.println("year = " + year);
    Month month = localDate.getMonth(); // 第几个月
    System.out.println("month = " + month);
    int dayOfMonth = localDate.getDayOfMonth(); //一个月的第几天
    System.out.println("dayOfMonth = " + dayOfMonth);
    DayOfWeek dayOfWeek = localDate.getDayOfWeek(); //一周的第几天
    System.out.println("dayOfWeek = " + dayOfWeek);
    int lenth = localDate.lengthOfMonth(); // 一个月的天数
    System.out.println("lenth = " + lenth);
    boolean leapYear = localDate.isLeapYear(); // 是否是闰年
    System.out.println("leapYear = " + leapYear);
    
    //获取当前日期
    System.out.println("LocalDate.now() = " + LocalDate.now());
    

    LocalTime 类

    // LocalTime 包含具体时间
    LocalTime localTime = LocalTime.of(22, 10, 59);
    System.out.println("localTime = " + localTime);
    

    LocalDateTime 类

    // LocalDateTime包括LocalDate和LocalTime
    LocalDateTime localDateTime = LocalDateTime.of(localDate, localTime);
    System.out.println("localDateTime = " + localDateTime);
    
    //LocalDateTime 和 LocalDate, LocalTime 相互转换
    LocalDate localDate1 = localDateTime.toLocalDate();
    LocalTime localTime1 = localDateTime.toLocalTime();
    

    Instant类

    // 一个时间戳
    Instant instant = Instant.now();
    System.out.println("instant = " + instant);
    

    Duration类

    // 一个时间段
    Duration duration = Duration.between(localDateTime, localTime1);
    long toDays = duration.toDays(); // 这个时间段中有几天
    long toHours = duration.toHours(); // 这个时间段中有几个小时
    
    // 通过of创建时间段
    Duration duration1 = Duration.of(5, ChronoUnit.DAYS);
    

    Period类

    // 以年月日来表示时间段
    Period period = Period.between(localDate, localDate1);
    

    时间加减操作

    // 时间加减操作
    LocalDate date = LocalDate.now();
    LocalDate localDate2 = date.minusDays(5);
    LocalDate localDate3 = date.plusYears(10);
    date.plus(5, ChronoUnit.DAYS);
    System.out.println("localDate3 = " + localDate3);
    System.out.println("localDate2 = " + localDate2);
    
    展开全文
  • Java时间类浅析

    千次阅读 2016-03-13 18:55:22
    Java关于时间有Date, Calendar, TimeZone和DateFormat,Date表示时间的格式;Calendar实现了对时间的处理;TimeZone是时区,表示各个地区不同的时间规定(夏令时等);DateFormat用于格式化时间的显示。

    Java关于时间的类有Date, Calendar, TimeZone和DateFormat,Date类表示时间的格式;Calendar类实现了对时间的处理;TimeZone是时区类,表示各个地区不同的时间规定(夏令时等);DateFormat类用于格式化时间的显示。

    夏令时和冬令时

    在一些实施了夏令时的国家,夏天从4月份开始至9月份,时间将快一个小时,而冬季则将时间拨回。也就是说夏令时区间,第一天比标准时间少1个小时,到夏令时结束时,第一天比标准时间多1个小时。我国以前有一段时间实行过夏令时,但由于人民难以掌握夏令时的计算方法,出现了不少问题,后面就没有实施了。夏令时在西方国家比较常见,在东亚地区则基本上没有。
    关于夏令时和冬令时,网上有一个程序[http://josh-persistence.iteye.com/blog/2230341],以美国洛杉矶的时区为例,显示自1970年至2021年的“特殊时间”。以下是代码:

    public class WhatTime {
        public static void testDayTime(TimeZone timeZone) {
            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Calendar start = Calendar.getInstance(timeZone);
            start.setTime(new Date(0));
            System.out.println("start=" + fmt.format(start.getTime()));
            long now = Calendar.getInstance(timeZone).getTimeInMillis();
            long year = 1000l * 3600 * 24 * 365;
            long end = now + year * 5;
            System.out.println(fmt.format(new Date(end)));
            boolean find = false;
            for(long i = start.getTimeInMillis();i<end;i=start.getTimeInMillis()){
                start.add(Calendar.DATE, 1);
                if((start.getTimeInMillis()-i)%(24*3600*1000L)!=0) {
                    find = true;
                    System.out.println("from" + fmt.format(new Date(i))+" to "+fmt.format(start.getTime())
                    +" has "+(start.getTimeInMillis() - i) + "ms " + "[" + (start.getTimeInMillis() - i) / (3600*1000L) + "hours]"
                    );
                }
            }
            if(!find){
                System.out.println("Every Day is OK.");
            }
        }
    
        public static void main(String args[]) {
            testDayTime(TimeZone.getTimeZone("America/Los_Angeles"));
        }
    }

    其计算结果为:

    start=1970-01-01 08:00:00
    2021-12-12 19:36:36
    from1970-04-26 08:00:00 to 1970-04-27 07:00:00 has 82800000ms [23hours]
    from1970-10-25 07:00:00 to 1970-10-26 08:00:00 has 90000000ms [25hours]
    ......

    Date类

    目前时间都是从1970年1月1日0时0分0秒开始的,因此,new Date(0)指的就是这个时间。直接new Date()表示本机的时间。new Date(long l)表示基于millsecond来创建时间,这个millsecond是与1970-01-01 0:0:0的偏移量。

    Calendar类

    Calendar类处理日期的增加、提取、设置等操作。它自动地处理复杂的夏令时和冬令时。Calendar.getInstance()方法默认返回本地操作系统所设置的时区。Calendar.setTime(Date date)则可以将一个时间设置到Calendar对象里,默认是当前时间。Calendar.getTimeInMillis()将返回Calendar时间对象的millsecond偏移量。通过对millsecond偏移量进行加减(加 +/-)操作时间,再通过Calendar.getTime就可以返回操作后的时间。

    TimeZone类

    TimeZone类已经设定了当前全球各个时区地区的参数,调用时仅需要输入TimeZone的ID,就可以获得TimeZone对象。你可以使用以下代码将TimeZone的详细信息输出。

    String id[] = TimeZone.getAvailableIDs();
    for(String idx : id) {
        System.out.println(TimeZone.getTimeZone(idx));
    }

    输出结果如下,以Paris为例:

    sun.util.calendar.ZoneInfo[**id="Europe/Paris"**,offset=3600000,dstSavings=3600000,useDaylight=true,transitions=184,lastRule=java.util.SimpleTimeZone[id=Europe/Paris,offset=3600000,dstSavings=3600000,useDaylight=true,startYear=0,startMode=2,startMonth=2,startDay=-1,startDayOfWeek=1,startTime=3600000,startTimeMode=2,endMode=2,endMonth=9,endDay=-1,endDayOfWeek=1,endTime=3600000,endTimeMode=2]] 

    里面的id就是创建TimeZone所需的参数。


    时间的统一处理

    对于客户端,一个人在国内递交了一个表单,服务器生成了提交的时间,另一个国外的用户查询该表单的提交时间。如何让不同时区的用户看到的时间与它本地所在的时区一致呢?综合网上搜索和自己思考,我认为,可以在后台数据库在存储时间时,将时间转为GMT(格林尼治时间)进行存储。在客户端显示时,依据客户端所处的时区(地区),再调用相应的函数输出显示。
    以下是转换时间的测试类:

    public class DateSave {
        public static Date convertToGMT(Date date) {
            //Local Time Zone Calendar Instance
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            //calendar.setTimeZone(TimeZone.getTimeZone("UTC"));       
            //return calendar.getTime();
            int zoneOffset = calendar.get(Calendar.ZONE_OFFSET);
            int dstOffset = calendar.get(Calendar.DST_OFFSET);
            calendar.add(Calendar.MILLISECOND, -(dstOffset+zoneOffset));
            return calendar.getTime();
        }
    
        public static Date convertGMTToLocal(Date gmtDate, String id) {
            Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
            calendar.setTime(gmtDate);
            calendar.setTimeZone(TimeZone.getTimeZone(id));
            int zoneOffset = calendar.get(Calendar.ZONE_OFFSET);
            int dstOffset = calendar.get(Calendar.DST_OFFSET);
            calendar.add(Calendar.MILLISECOND, dstOffset+zoneOffset);
            return calendar.getTime();
        }
    
        public static Date stringToDate(String sDate , String pattern) throws ParseException {
            DateFormat df = new SimpleDateFormat(pattern);
            return df.parse(sDate);
        }
    
        public static String dateToString(Date date , String pattern) {
            DateFormat df = new SimpleDateFormat(pattern);
            return df.format(date);
        } 
    
        public static void main(String args[]) {
            String sdate = "1988-11-30 16:03:00";
            String pattern = "yyyy-MM-dd HH:mm:ss";
            try {
                Date date = stringToDate(sdate,pattern);
                date = convertToGMT(date);
                System.out.println("GMT is "+dateToString(date,pattern));
                date = convertGMTToLocal(date,"America/Los_Angeles");
                System.out.println("Local is "+dateToString(date,pattern));
            } catch (ParseException ex) {
                Logger.getLogger(DateSave.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    展开全文
  • Java时间类总结

    千次阅读 2018-02-03 16:43:35
    java.util.Date 包含有年月日时分秒,精确到毫秒级别。 官方解释: // The class Date represents a specific instant in time, with millisecond precision. // 语句 Date date = new Date(); System.out....

    java.util.Date

    包含有年月日时分秒,精确到毫秒级别。
    官方解释:

    // The class Date represents a specific instant in time, with millisecond precision.
    // 语句
    Date date = new Date();
    System.out.println(date);
    
    //输出结果
    Sat Feb 03 14:48:47 CST 2018

    java.sql.Date

    包含年月日,时分秒都被设置为0,之所以这样设计是为了适应SQL中的DATE类型。
    官方解释:

    // A thin wrapper around a millisecond value that allows JDBC to identify this as an SQL DATE value. A milliseconds value represents the number of milliseconds that have passed since January 1, 1970 00:00:00.000 GMT.
    // To conform with the definition of SQL DATE, the millisecond values wrapped by a java.sql.Date instance must be 'normalized' by setting the hours, minutes, seconds, and milliseconds to zero in the particular time zone with which the instance is associated.

    注意,虽然说这个类是使用年月日的,但是初始化的时候,需要一个long类型的参数,这个参数代表着January 1, 1970, 00:00:00 GMT到某个时间的毫秒数。如果是当前时间的话,可以用System.currentTimeMillis()或者new Date().getTime()获取。

    // 语句
    java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis());
    System.out.println(sqlDate);
    
    // 输出结果
    2018-02-03

    java.sql.Time

    包含时分秒,这个也是为了SQL中的TIME类型而出现的。

    // 语句
    Time time = new Time(System.currentTimeMillis());
    System.out.println(time);
    
    // 输出结果
    15:07:35

    java.sql.Timestamp

    时间戳,适配于SQL中的TIMESTAMP类型而出现的,精确到纳秒级别。

    格式化输出:java.text.SimpleDateFormat

    这个类提供时间的各种格式化输出和将字符串转换为时间类,简单来说,它拥有date → text 以及text → date的能力。
    例如:将Date格式化输出

        // 格式化输出
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日  HH:mm:ss");
        String dateStr = sdf.format(new Date());
        System.out.println(dateStr);
    
        // 结果
        2018020315:20:58

    例如:将时间字符串转化为Date

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日  HH:mm:ss");
        Date date = sdf.parse("2018年02月03日  15:20:58");

    注意,SimpleDateFormat.parse(String source)中的source格式一定得是SimpleDateFormat当前使用的格式。如这个例子中使用了yyyy年MM月dd日 HH:mm:ss,所以传入了2018年02月03日 15:20:58时间字符串。
    PS:有些同学对yyyy或者MM这些字母代表的含义不懂的话,建议使用这个类的时候,看一下源码,源码类上都有对这些字母的解释。

    java.util.Calendar

    日历类,这个类大多被用于获取时间的特殊属性,比如说获取某个时间对象的年份、月份、星期等

        Calendar calendar = Calendar.getInstance();
        // 设置时间,不设置的话,默认是当前时间
        calendar.setTime(new Date());
        // 获取时间中的年份
        int year = calendar.get(Calendar.YEAR);

    从JDK1.8开始,Calendar增加新的构造方式

        // since jdk 1.8
        Calendar calendar = new Calendar.Builder().setDate(2018, 3, 25).build();
        int year = calendar.get(Calendar.YEAR);
        System.out.println(year);

    阶段小结

    以上大概就是jdk1.8之前的操作时间方式了。然后,从jdk1.8开始,有了新的操作时间的类。

    java.time.LocalDate

    LocalDate提供年月日而不提供时分秒信息,它是不可变类且线程安全的。它经常被用于展示year-month-day,day-of-year,day-of-week,week-of-year等格式的信息。

            LocalDate localDate = LocalDate.now();
            // 获取当天是几号
            int dayOfMonth = localDate.getDayOfMonth();
            // 获取当天是星期几
            DayOfWeek dayOfWeek = localDate.getDayOfWeek();
    
            // 获取本月的第一天
            LocalDate firstDayOfMonth = localDate.with(TemporalAdjusters.firstDayOfMonth());
            // 取本月最后一天
            LocalDate lastDayOfThisMonth = localDate.with(TemporalAdjusters.lastDayOfMonth());

    是不是很赞~

    java.time.Time

    提供时分秒不提供年月日,也是线程安全并且不可变类。它经常被用于展示hour-minute-second格式的信息。可以对时间进行加减等操作。

            // 样例
            LocalTime localTime = LocalTime.now();
            // 获取当前的小时
            int hour = localTime.getHour();
            System.out.println(hour);
            // 小时数加1
            LocalTime addTwoHours = localTime.plusHours(2L);
            System.out.println(addTwoHours.getHour());
    
            // 结果
            16
            18
    

    java.time.LocalDateTime

    包含年月日时分秒,精确到纳秒级别,同样是线程安全并且不可变类。它可以操作时间中的年月日时分秒并且可以获取其中的属性。

            LocalDateTime localDateTime = LocalDateTime.now();
            // 获取年
            int year = localDateTime.getYear();
            // 获取小时
            int hour = localDateTime.getHour();
            // 增加一年
            LocalDateTime addOneYear = localDateTime.plusYears(1);

    结语

    今天就先这样啦,希望看到这篇博文的人能有所收获,同样,错误之处还请帮忙指正。

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,771
精华内容 18,708
关键字:

java时间类

java 订阅