`
zljpp
  • 浏览: 260043 次
社区版块
存档分类
最新评论

Java Date 和 Calendar 实例

    博客分类：
  • java
javaDate 
阅读更多 

Java 之 Date 和 Calendar 实例
[java] view plaincopyprint?
package com.homer.learn;  
  
import java.text.DateFormat;  
import java.text.ParsePosition;  
import java.text.SimpleDateFormat;  
import java.util.Calendar;  
import java.util.Date;  
import java.util.GregorianCalendar;  
  
  
public class TimeTest {  
    public static void main(String[] args) {  
        TimeTest tt = new TimeTest();  
  
        System.out.println("\n当前日期： ");  
        System.out.println(tt.getNowTime());                    // 获取当前时间  
        System.out.println(tt.getNowTime2());                   // 获取当前时间  
        System.out.println(tt.getNowTime3());                   // 获取当前时间  
          
        System.out.println("\n计算周： ");  
        System.out.println(tt.getDaysOfNow2SundayInWeek());     // 获取当前日期与本周日的相差天数  
        System.out.println(tt.getDateOfMondayInWeek());         // 获取本周一的日期  
        System.out.println(tt.getDateOfSaturdayInWeek());       // 获取本周六的日期  
        System.out.println(tt.getDateOfSaturdayInNextWeek());   // 获取下周一的日期  
        System.out.println(tt.getDateOfSaturdayInLastWeek());   // 获取上周一的日期  
  
  
        System.out.println("\n计算月： ");  
        System.out.println(tt.getFirstDayOfMonth());            // 获取当月的第一天  
        System.out.println(tt.getLastDayOfMonth());             // 获取当月最后一天  
        System.out.println(tt.getFirstDayOfPreviousMonth());    // 获取上月第一天        
        System.out.println(tt.getLastDayOfPreviousMonth());     // 获取上月最后一天           
        System.out.println(tt.getFirstDayOfNextMonth());        // 获取下月第一天    
        System.out.println(tt.getLastDayOfNextMonth());         // 获取下月最后一天  
          
  
        System.out.println("\n计算年： ");  
        System.out.println(tt.getFirstDayOfYear());             // 获取本年的第一天  
        System.out.println(tt.getLastDayOfYear());              // 获取本年最后一天  
        System.out.println(tt.getFirstDayOfPreviousYear());     // 获取上年的第一天  
        System.out.println(tt.getLastDayOfPreviousYear());      // 获取上年最后一天  
        System.out.println(tt.getFirstDayOfNextYear());         // 获取下年的第一天  
        System.out.println(tt.getLastDayOfNextYear());          // 获取下年最后一天  
        System.out.println(tt.getDaysOfYear());                 // 获取本年的天数  
          
  
        System.out.println("\n计算季度： ");  
        System.out.println(tt.getSeasonOfMonth());              // 获取当前月的季度  
        System.out.println(tt.getLastDayOfNow());               // 获取当前天所在月份的天数  
        System.out.println(tt.isLeapYear(2012));                // 判断是否是润年  
          
  
        System.out.println("\n日期格式转换与计算： ");  
        System.out.println(tt.getDateFromStr("2012-06-20"));    // 将字符串时间格式 yyyy-MM-dd，转换成Date类型  
        System.out.println(tt.getWeek("2012-06-20"));           // 根据一个日期，返回是星期几的字符串  
        System.out.print("2012-06-02 -> 2012-06-12间隔天数:");   // 计算两个日期间的间隔天数  
        System.out.println(tt.getDaysFromTwoDate("2012-06-02", "2012-06-12"));            
    }  
  
      
      
    // 获取当前时间  
    public String getNowTime() {  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Date now = new Date();  
        return sDateFormat.format(now);  
    }  
  
    public String getNowTime2() {  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
          
        Date now = new Date(System.currentTimeMillis());  
        return sDateFormat.format(now);  
    }  
  
    public String getNowTime3() {  
        StringBuilder strBuildNow = new StringBuilder();  
          
        Calendar calendar = Calendar.getInstance();  
        int year = calendar.get(Calendar.YEAR);  
        int month = calendar.get(Calendar.MONTH) + 1;  
        int day = calendar.get(Calendar.DAY_OF_MONTH);  
        int hour = calendar.get(Calendar.HOUR_OF_DAY);  
        int minute = calendar.get(Calendar.MINUTE);  
        int second = calendar.get(Calendar.SECOND);  
        int millissecond = calendar.get(Calendar.MILLISECOND);  
          
        strBuildNow.append(year + "-");  
        strBuildNow.append(month + "-");  
        strBuildNow.append(day + " ");  
        strBuildNow.append(hour + ":");  
        strBuildNow.append(minute + ":");  
        strBuildNow.append(second + ".");  
        strBuildNow.append(millissecond);  
          
        return strBuildNow.toString();  
    }  
      
      
      
      
    // 获取当前日期与本周日的相差天数  
    public int getDaysOfNow2SundayInWeek() {  
        Calendar calendar = Calendar.getInstance();  
          
        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;     // 减一天，周一为1，符合中国人习惯。Sunday - 1; Monday - 2; Saturday - 7  
        if(dayOfWeek == 0) {        // 周日  
            return 0;  
        } else {  
            return 0 - dayOfWeek;  
        }  
    }  
      
    // 获取本周一的日期  
    public String getDateOfMondayInWeek(){  
        int day = this.getDaysOfNow2SundayInWeek() + 1; // 加1，即周一离本周日的间隔天数  
        GregorianCalendar gCalendar = new GregorianCalendar();  
          
        gCalendar.add(GregorianCalendar.DATE, day);     // 计算与本周一相差的时间间隔  
        Date curDay = gCalendar.getTime();  
          
        DateFormat dateFormat = DateFormat.getInstance();  
        String dateOfMonday = dateFormat.format(curDay);  
          
        return dateOfMonday;  
    }  
  
    // 获取本周六的日期  
    public String getDateOfSaturdayInWeek(){  
        int day = this.getDaysOfNow2SundayInWeek() + 6; // 加6，即周六离本周日的间隔天数  
        GregorianCalendar gCalendar = new GregorianCalendar();  
          
        gCalendar.add(GregorianCalendar.DATE, day);     // 计算与本周六相差的时间间隔  
        Date curDay = gCalendar.getTime();  
          
        DateFormat dateFormat = DateFormat.getInstance();  
        String dateOfMonday = dateFormat.format(curDay);  
          
        return dateOfMonday;  
    }  
  
    // 获取上周一的日期  
    public String getDateOfSaturdayInLastWeek(){  
        int day = this.getDaysOfNow2SundayInWeek() - 1; // 减1，即上周一离本周日的间隔天数  
        GregorianCalendar gCalendar = new GregorianCalendar();  
          
        gCalendar.add(GregorianCalendar.DATE, day);     // 计算与上周一相差的时间间隔  
        Date curDay = gCalendar.getTime();  
          
        DateFormat dateFormat = DateFormat.getInstance();  
        String dateOfMonday = dateFormat.format(curDay);  
          
        return dateOfMonday;  
    }  
      
    // 获取下周一的日期  
    public String getDateOfSaturdayInNextWeek(){  
        int day = this.getDaysOfNow2SundayInWeek() + 8; // 加8，即下周一离本周日的间隔天数  
        GregorianCalendar gCalendar = new GregorianCalendar();  
          
        gCalendar.add(GregorianCalendar.DATE, day);     // 计算与下周一相差的时间间隔  
        Date curDay = gCalendar.getTime();  
          
        DateFormat dateFormat = DateFormat.getInstance();  
        String dateOfMonday = dateFormat.format(curDay);  
          
        return dateOfMonday;  
    }  
      
      
      
  
    // 获取当月第一天  
    public String getFirstDayOfMonth() {  
        String strFirstDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.set(Calendar.DATE, 1);     // 设置当前月的1号  
          
        strFirstDay = sDateFormat.format(calendar.getTime());  
        return strFirstDay;  
    }  
  
    // 获取当月最后一天  
    public String getLastDayOfMonth() {  
        String strLastDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.set(Calendar.DATE, 1);     // 设置当前月的1号  
        calendar.add(Calendar.MONDAY, 1);   // 加一个月，变为下月的1号  
        calendar.add(Calendar.DATE, -1);    // 减去一天，变为当前月的最后一天  
          
        strLastDay = sDateFormat.format(calendar.getTime());  
        return strLastDay;  
    }  
  
    // 获取上月第一天  
    public String getFirstDayOfPreviousMonth() {  
        String strFirstDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.set(Calendar.DATE, 1);     // 设置当前月的1号  
        calendar.add(Calendar.MONDAY, -1);  // 减一个月，变为上月的1号  
          
        strFirstDay = sDateFormat.format(calendar.getTime());  
        return strFirstDay;  
    }  
  
    // 获取上月最后一天  
    public String getLastDayOfPreviousMonth() {  
        String strLastDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.set(Calendar.DATE, 1);     // 设置当前月的1号  
        calendar.add(Calendar.DATE, -1);    // 减一天，变为上月的1号  
          
        strLastDay = sDateFormat.format(calendar.getTime());  
        return strLastDay;  
    }  
  
    public String getLastDayOfPreviousMonth2() {  
        String strLastDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.add(Calendar.MONDAY, -1);  // 减一个月  
        calendar.set(Calendar.DATE, 1);     // 设置当前月的1号  
        calendar.roll(Calendar.DATE, -1);   // 把日期回滚一天，也就是本月最后一天  
          
        strLastDay = sDateFormat.format(calendar.getTime());  
        return strLastDay;  
    }  
      
    // 获取下月第一天  
    public String getFirstDayOfNextMonth() {  
        String strFirstDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.add(Calendar.MONTH, 1);    // 加一个月  
        calendar.set(Calendar.DATE, 1);     // 设置当前月第一天  
          
        strFirstDay = sDateFormat.format(calendar.getTime());  
        return strFirstDay;  
    }  
  
    // 获取下月最后一天  
    public String getLastDayOfNextMonth() {  
        String strLastDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.set(Calendar.DATE, 1);     // 设置当前月的1号  
        calendar.add(Calendar.MONDAY, 2);   // 加两个月，变为下下月的1号  
        calendar.add(Calendar.DATE, -1);    // 减一天，变为下月的最后一天  
          
        strLastDay = sDateFormat.format(calendar.getTime());  
        return strLastDay;  
    }  
  
    public String getLastDayOfNextMonth2(){  
        String strLastDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.add(Calendar.MONTH, 1);    // 加1个月  
        calendar.set(Calendar.DATE, 1);     // 把日期设置为当月第1天  
        calendar.roll(Calendar.DATE, -1);   // 日期回滚1天，也就是本月最后1天  
          
        strLastDay = sDateFormat.format(calendar.getTime());  
        return strLastDay;  
    }  
      
      
      
      
    // 获取本年的第一天  
    public String getFirstDayOfYear(){  
        String strFirstDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.set(Calendar.DAY_OF_YEAR, 1);      // 设置当年第一天  
          
        strFirstDay = sDateFormat.format(calendar.getTime());  
        return strFirstDay;  
    }  
  
    // 获取本年的最后一天  
    public String getLastDayOfYear(){  
        String strLastDay = "";  
          
        Calendar calendar = Calendar.getInstance();  
        strLastDay = calendar.get(Calendar.YEAR) + "-12-31";  
          
        return strLastDay;  
    }  
      
    // 获取上年的第一天  
    public String getFirstDayOfPreviousYear(){  
        String strFirstDay = "";  
          
        Calendar calendar = Calendar.getInstance();  
        strFirstDay = (calendar.get(Calendar.YEAR) - 1) + "-01-01";  
          
        return strFirstDay;  
    }  
  
    // 获取上年的最后一天  
    public String getLastDayOfPreviousYear(){  
        String strLastDay = "";  
          
        Calendar calendar = Calendar.getInstance();  
        strLastDay = (calendar.get(Calendar.YEAR) - 1) + "-12-31";  
          
        return strLastDay;  
    }  
      
    // 获取下年的第一天  
    public String getFirstDayOfNextYear(){  
        String strFirstDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.add(Calendar.YEAR, 1);             // 加一年  
        calendar.set(Calendar.DAY_OF_YEAR, 1);      // 设置当年第一天  
          
        strFirstDay = sDateFormat.format(calendar.getTime());  
        return strFirstDay;  
    }  
  
    // 获取下年的最后一天  
    public String getLastDayOfNextYear(){  
        String strLastDay = "";  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.add(Calendar.YEAR, 1);             // 加一年  
        calendar.set(Calendar.DAY_OF_YEAR, 1);      // 设置当年第一天  
        calendar.roll(Calendar.DAY_OF_YEAR, -1);    // 回滚到当年最后一天  
          
        strLastDay = sDateFormat.format(calendar.getTime());  
        return strLastDay;  
    }  
      
    // 获取本年的天数  
    public String getDaysOfYear(){  
        int year = 0;  
        int days = 0;  
          
        Calendar calendar = Calendar.getInstance();  
        calendar.set(Calendar.DAY_OF_YEAR, 1);      // 设置日期为当年第一天  
        calendar.roll(Calendar.DAY_OF_YEAR, -1);    // 把日期回滚一天  
          
        year = calendar.get(Calendar.YEAR);  
        days = calendar.get(Calendar.DAY_OF_YEAR);  
          
        return (days + " in " + year);  
    }  
      
      
      
      
    // 获取当前月的季度  
    public String getSeasonOfMonth(){  
        String strSeason = "";  
        int year, month, day;  
        int season = 1;  
        int array[][] = new int[][]{ {1,2,3}, {4,5,6}, {7,8,9}, {10,11,12} };  
          
        Calendar calendar = Calendar.getInstance();  
        year = calendar.get(Calendar.YEAR);  
        month = calendar.get(Calendar.MONDAY) + 1;  
        day = calendar.get(Calendar.DAY_OF_MONTH);  
        switch (month) {  
        case 1:  
        case 2:  
        case 3:  
            season = 1;  
            break;  
        case 4:  
        case 5:  
        case 6:  
            season = 2;  
            break;  
        case 7:  
        case 8:  
        case 9:  
            season = 3;  
            break;  
        case 10:  
        case 11:  
        case 12:  
            season = 4;  
            break;  
        default:  
            season = 1;  
            break;  
        }  
          
          
        int start_month = array[season-1][0];  
        int end_month = array[season-1][2];  
        strSeason = year + "-" + month + "-" +day;  
        strSeason += " in [ " + year + "-" + start_month + " : " + year + "-" + end_month + " ]";  
          
        return strSeason;  
    }  
      
      
    // 获取当前天所在月份的天数  
    public String getLastDayOfNow(){  
        String strLastDay = "";  
        int year, month, day;  
        int days = 0;  
          
        Calendar calendar = Calendar.getInstance();  
        year = calendar.get(Calendar.YEAR);  
        month = calendar.get(Calendar.MONTH) + 1;  
        day = calendar.get(Calendar.DAY_OF_MONTH);  
          
        switch (month) {  
        case 1:  
        case 3:  
        case 5:  
        case 7:  
        case 8:  
        case 10:  
        case 12:  
            days = 31;  
            break;  
        case 4:  
        case 6:  
        case 9:  
        case 11:  
            days = 30;  
            break;  
        case 2:  
            if (isLeapYear(year)) {  
                days = 29;  
            } else {  
                days = 28;  
            }  
            break;  
        default:  
            days = 0;  
            break;  
        }  
          
        strLastDay = days + " in [ " + year + "-" + month + "-" + day + " ]";  
        return strLastDay;  
    }  
      
    // 判断是否是润年  
    public boolean isLeapYear(int year){  
        return (year%4 == 0 && year%100 != 0) || (year%400 == 0);  
    }  
      
      
      
      
  
    // 将字符串时间格式 yyyy-MM-dd，转换成Date类型  
    public Date getDateFromStr(String txtDate) {  
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
        ParsePosition pos = new ParsePosition(0);  
        Date date = sDateFormat.parse(txtDate, pos);  
          
        return date;  
    }  
  
    // 根据一个日期，返回是星期几的字符串  
    public String getWeek(String txtDate) {  
        Date date = getDateFromStr(txtDate);  
        Calendar calendar = Calendar.getInstance();  
          
        calendar.setTime(date);  
        String week = new SimpleDateFormat("EEEE").format(date);  
          
        return week;  
    }  
  
    // 计算两个日期间的间隔天数  
    public long getDaysFromTwoDate(String txtDate1, String txtDate2) {  
        if(txtDate1 == null || txtDate1.equals("")) {  
            return 0;  
        }  
        if(txtDate2 == null || txtDate2.equals("")) {  
            return 0;  
        }  
          
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");  
        long days = 0;  
        try {  
            Date date1 = sDateFormat.parse(txtDate1);  
            Date date2 = sDateFormat.parse(txtDate2);  
            days = (date2.getTime() - date1.getTime())/(24*60*60*1000);     // 通过getTime()方法，把时间Date转换成毫秒格式Long类型，进行计算  
        } catch (Exception e) {  
            System.out.println(e.getMessage());  
        }  
          
        return days;  
    }  
      
}  
运行结果：
当前日期： 
2012-03-07
2012-03-07 12:30:11
2012-3-7 12:30:11.101

计算周： 
-3
3/5/12 12:30 PM
3/10/12 12:30 PM
3/12/12 12:30 PM
3/3/12 12:30 PM

计算月： 
2012-03-01
2012-03-31
2012-02-01
2012-02-29
2012-04-01
2012-04-30

计算年： 
2012-01-01
2012-12-31
2011-01-01
2011-12-31
2013-01-01
2013-12-31
366 in 2012

计算季度： 
2012-3-7 in [ 2012-1 : 2012-3 ]
31 in [ 2012-3-7 ]
true

日期格式转换与计算： 
Wed Jun 20 00:00:00 CST 2012
Wednesday
2012-06-02 -> 2012-06-12间隔天数:10
 
分享到：
| s5pc110 uboot
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java 之 Date 和 Calendar 实例

    在Java编程语言中，`Date`和`Calendar`类是处理日期和时间的核心组件。这两个类在不同的Java版本中有着不同的使用方式和功能，对于理解Java时间处理机制至关重要。本篇将深入探讨`Date`和`Calendar`类的实例应用。 ...

    java中时间类Date和Calendar的使用

    Java中的时间类`Date`和`Calendar`是处理日期和时间的核心组件，它们在Java编程中扮演着重要的角色。在Java中，`Date`类主要用来表示特定的瞬间，精确到毫秒。而`Calendar`类则是一个抽象类，提供了比`Date`更灵活的...

    Java基础之Date和Calendar类的使用方法

    Java中的Date和Calendar类是处理日期和时间的核心组件。Date类主要用于表示特定的瞬间，精确到毫秒。在早期版本的Java中，Date类的设计受到批评，因为它的API不直观且容易导致错误。为了解决这些问题，大部分日期和...

    JAVA Calendar,Date类详解

    在Java编程语言中，`Calendar`和`Date`类是处理日期和时间的核心组件。这两个类在处理日期、时间计算以及格式化等任务时扮演着关键角色。理解并熟练运用它们，对于提升Java开发能力至关重要。 `Date`类是Java早期...

    Calendar和Date的转化

    在Java编程语言中，`Calendar`和`Date`是处理日期和时间的重要类。为了更好地理解和使用这两个类之间的转换方法，本文将详细介绍如何将`Calendar`对象转换为`Date`对象，以及如何将`Date`对象转换为`Calendar`对象。...

    Java中Date和Calendar常用方法

    `java.util.Date`和`java.util.Calendar`是两个核心的类，用于表示和操作日期。尽管`Date`类提供了许多功能，但它的某些方法如`getYear()`、`getMonth()`等在后续版本中被废弃，取而代之的是使用`Calendar`类来进行...

    JAVA new Date()或Calendar.getInstance().getTime()得到的时间不对

    在Java编程中，`new Date()` 和 `Calendar.getInstance().getTime()` 都是获取当前系统时间的方法，但有时可能会出现获取到的时间与预期不符的情况。这种问题通常与时区设置、系统时间、Java运行环境以及代码逻辑...

    Date与Calendar详解

    `java.util.Calendar`是Java中用于操作日期和时间的抽象类，提供了比`Date`类更全面的日期和时间操作能力，包括时区支持、日历字段的访问以及日期的加减运算等。 ##### 使用Calendar `Calendar`类是抽象的，不能...

    java Date应用实例

    Java中的`Date`类是处理日期和时间的基础类，它在Java编程中扮演着重要的角色。在本实例中，我们将深入探讨如何使用`Date`类进行时间相关的操作，包括时间的获取、格式化以及日期之间的比较。让我们逐一展开这些知识...

    JavaDate应用实例.pdf

    在Java编程中，`java.util.Date`类是处理日期的核心类，而`Calendar`类则提供了更为复杂的日期和时间操作。在给定的代码片段中，我们看到了如何使用这两个类来获取指定月份的第一天和最后一天。以下是这些方法的详细...

    Java_Date应用实例

    上述代码展示了如何使用Java的Date和Calendar类获取指定月份的第一天和最后一天，以及进行日期格式化的实用方法。 首先，`getMonthBegin`方法用于获取给定日期所在月份的第一天。它接受一个字符串`strdate`作为参数...

    Date、String、Calendar之间的转换_java编程_

    在Java编程中，Date、String和Calendar是三个重要的日期时间处理类，它们之间相互转换的技巧是开发者必备的知识。理解并熟练掌握这三者之间的转换，对于处理日常的日期时间问题至关重要。 首先，我们来看`Date`类。...

    JAVA System、Math、Date、DateFormat、Calendar

    `Calendar.getInstance()`可以获取当前的Calendar实例，`calendar.get(field)`和`calendar.set(field, value)`用于获取或设置特定的日期字段。 在实际编程中，这些类通常结合使用，例如，通过`Date`获取当前时间，...

    Java Date的使用

    然而，在实际开发中，`java.util.Date`往往与`java.text.SimpleDateFormat`一起使用来格式化和解析日期。 ### SimpleDateFormat 类的使用 `SimpleDateFormat`是`DateFormat`的一个子类，用于格式化或解析日期。它...

    常用java date方法集合

    本文将深入探讨“常用Java date方法集合”，这是一份关于`java.util.Date`和`java.util.Calendar`类中常用操作的总结。通过本文，我们将详细了解如何计算特定月份的最大天数、实现`Calendar`与`Date`之间的转换、...

    java的calendar具体用法

    在Java中处理日期和时间非常常见，而`java.util.Calendar`类则是进行此类操作的核心工具之一。`Calendar`类提供了一系列的功能来帮助开发者处理复杂的日期计算问题，比如日期的加减、获取特定日期组件等。 #### 二...

    JavaCalendar_JAVA源码_

    首先，`Calendar`类是抽象的，不能直接实例化，通常我们通过`Calendar.getInstance()`来获取一个`Calendar`对象，它会根据系统默认时区和语言环境返回一个具体的实现。在Java 8之后，`java.time`包提供了更现代、...

    java操作date对象

    在 Java 中，处理日期和时间主要依赖于 `java.util.Date` 和 `java.text.DateFormat` 这两个核心类。在本文中，我们将深入探讨如何使用这些类来获取、格式化和操作日期。 1. **获取当前时间** 获取当前时间最常用...

    java SimpleDateFormat &Calendar

    // 创建一个Calendar实例 Calendar calendar = Calendar.getInstance(); // 设置当前时间为2022年1月1日 calendar.set(2022, Calendar.JANUARY, 1); // 将Calendar对象转换为Date对象 Date date = calendar....

    Java Date类常用示例_动力节点Java学院整理

    在JDK1.0中，Date类是唯一的一个代表时间的类，但是由于Date类不便于实现国际化，所以从JDK1.1版本开始，推荐使用Calendar类进行时间和日期处理。这里简单介绍一下Date类的使用。

Magicbox
Global site tag (gtag.js) - Google Analytics