Java常用类系列（二）——时间类（Date、DateFormat、SimpleDateFormat、Calendar、GregorianCalendar）

一、 Date类

1. 创建一个当前时间的Date对象

   //创建一个代表系统当前日期的Date对象
   Date d = new Date();
   

2. 创建一个我们指定的时间的Date对象

   使用带参数的构造方法Date(int year, int month, int day) ，可以构造指定日期的Date类对象，Date类中年份的参数应该是实际需要代表的年份减去1900，实际需要代表的月份减去1以后的值。

   //创建一个代表2020年02月17号的 Date对象
   Date d1 = new Date(2020-1900, 2-1, 17); （注意参数的设置）
   

3. 正确获得一个date对象所包含的信息，如：

   Date d2 =  new Date(2020-1900, 2-1, 17);
   
   //获得年份（注意年份要加上1900，这样才是日期对象d2所代表的年份）
   int year = d2.getYear() + 1900;
   
   //获得月份（注意月份要加1，这样才是日期对象d2所代表的月份）
   int month = d2.getMonth() + 1;
   
   //获得日期
   int date = d2.getDate();
   
   //获得小时
   int hour = d2.getHours();//不设置默认为0
   
   //获得分钟
   int minute = d2.getMinutes();
   
   //获得秒
   int second = d2.getSeconds();
   
   //获得星期 （注意：0代表星期日、1代表星期1、2代表星期2，其他的一次类推了）
   int day = d2.getDay();
   
   /**
   *	Date对象和相对时间之间的互转
   */
   Date d3 = new Date(2020-1900,2-1,18);
   long time = 1290876532190L;
   //将Date类的对象转换为相对时间
   long t = d3.getTime();
   //将相对时间转换为Date类的对象
   Date d4 = new Date(time);
   

二、DateFormat类和SimpleDateFormat类

1. DateFormat类
   此类是一个日期的格式化类，用来格式化日期。具体日期可以通过java.util.Date类来获取。DateFormat类的定义：此类是定义在java.test包中的。

   /**
   * 美式日期格式化
   */
   DateFormat df1 = null ;     // 声明一个DateFormat
   DateFormat df2 = null ;     // 声明一个DateFormat
   df1 = DateFormat.getDateInstance() ;    // 得到日期的DateFormat对象
   df2 = DateFormat.getDateTimeInstance() ;    // 得到日期时间的DateFormat对象
   System.out.println("DATE：" + df1.format(new Date())) ; // 按照日期格式化
   System.out.println("DATETIME：" + df2.format(new Date())) ;   // 按照日期时间格式化
   /**
   * 中式日期格式（通过Locale对象指定要显示的区域，指定的区域是中国）
   */
   DateFormat df1 = null ;     // 声明一个DateFormat  
   DateFormat df2 = null ;     // 声明一个DateFormat  
   df1 = DateFormat.getDateInstance(DateFormat.YEAR_FIELD,new Locale("zh","CN")) ; // 得到日期的DateFormat对象  
   df2 = DateFormat.getDateTimeInstance(DateFormat.YEAR_FIELD,DateFormat.ERA_FIELD,new Locale("zh","CN")) ;    // 得到日期时间的DateFormat对象  
   System.out.println("DATE：" + df1.format(new Date())) ; // 按照日期格式化  
   System.out.println("DATETIME：" + df2.format(new Date())) ;   // 按照日期时间格式化
   
   

2. SimpleDateFormat类
   SimpleDateFormat类为DateFormat类的子类。

   /**
   * Date转化成指定的日期格式
   */
   Date now = new Date();
   
   SimpleDateFormat myFmt = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
   System.out.println(myFmt.format(now));//结果：2020年02月18日 17时24分27秒
   
   SimpleDateFormat myFmt1 = new SimpleDateFormat("yy/MM/dd HH:mm"); 
   System.out.println(myFmt1.format(now));//结果：20/02/18 17:24
   
   SimpleDateFormat myFmt2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//等价于now.toLocaleString()
   System.out.println(myFmt2.format(now));//结果：2020-02-18 17:24:27 
   
   SimpleDateFormat myFmt3 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E ");
   System.out.println(myFmt3.format(now));//结果：2020年02月18日 17时24分27秒 星期二
   
   SimpleDateFormat myFmt4 = new SimpleDateFormat("一年中的第 D 天 一年中第 w 个星期 一月中第 W 个星期 在一天中 k 时 z 时区");
   System.out.println(myFmt4.format(now));//结果：一年中的第 49 天 一年中第7个星期 一月中第3个星期 在一天中17时 CST时区
   
   System.out.println(now.toGMTString());//结果：18 Feb 2020 09:24:27 GMT
   System.out.println(now.toLocaleString());//结果：2020-02-18 17:24:27
   System.out.println(now.toString());//结果：Thu Feb 18 17:24:27 CST 2020
   
   /**
   * 把给定的字符串中的日期提取为Date
   * 通常是一个日期字符串，但不是想要的格式，可以先转化为Date，再转化为其它格式
   */
   String strDate = "2020-02-18 10:11:30.345" ;  
   // 从字符串中提取出日期数字  
   String pat1 = "yyyy-MM-dd HH:mm:ss.SSS" ;  
   // 将提取后的日期数字变为指定的格式  
   String pat2 = "yyyy年MM月dd日 HH时mm分ss秒SSS毫秒" ;  
   SimpleDateFormat sdf1 = new SimpleDateFormat(pat1) ;   // 实例化模板对象  
   SimpleDateFormat sdf2 = new SimpleDateFormat(pat2) ;   // 实例化模板对象  
   Date d = null ;  
   try{  
   	d = sdf1.parse(strDate) ;   // 将给定的字符串中的日期提取出来  
   }catch(Exception e){            // 如果提供的字符串格式有错误，则进行异常处理  
       e.printStackTrace() ;       // 打印异常信息  
   }  
   System.out.println(sdf2.format(d)) ;    // 将日期变为新的格式 
   
   

三、Calendar类

1. Calendar类对象的创建

   Calendar类是一个抽象类，由于Calendar类是抽象类，且Calendar类的构造方法是protected的，所以无法使用Calendar类的构造方法来创建对象，API中提供了getInstance方法用来创建对象。

2. 创建一个代表系统当前日期的Calendar对象

   Calendar c = Calendar.getInstance();//默认是当前日期
   

3. 创建一个指定日期的Calendar对象

   使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。

   //创建一个代表2020年2月18日的Calendar对象
   Calendar c1 = Calendar.getInstance();
   c1.set(2020, 2 - 1, 18)；//调用：public final void set(int year,int month,int date)
   

4. Calendar类对象信息的设置与获得

   1）Calendar类对象信息的设置

   /**
   *A、Set设置
   *如：
   *Calendar c1 = Calendar.getInstance();
   *调用：public final void set(int year,int month,int date)
   */
   c1.set(2014, 6- 1, 9);//把Calendar对象c1的年月日分别设这为：2014、6、9
   
   
   /**
   *B、利用字段类型设置
   *   如果只设定某个字段，例如日期的值，则可以使用public void set(int field,int value)
   */
   //把 c1对象代表的日期设置为10号，其它所有的数值会被重新计算
   c1.set(Calendar.DATE,10);
   
   //把c1对象代表的年份设置为2014年，其他的所有数值会被重新计算
   c1.set(Calendar.YEAR,2015);
   

   其他字段属性set的意义以此类推
   Calendar类中用一下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想
   Calendar.YEAR——年份
   Calendar.MONTH——月份
   Calendar.DATE——日期
   Calendar.DAY_OF_MONTH——日期，和上面的字段意义相同
   Calendar.HOUR——12小时制的小时
   Calendar.HOUR_OF_DAY——24小时制的小时
   Calendar.MINUTE——分钟
   Calendar.SECOND——秒
   Calendar.DAY_OF_WEEK——星期几
   

   /**
   *C、Add设置(可用与计算时间)
   */
   Calendar c1 = Calendar.getInstance();
   //把c1对象的日期加上10，也就是c1所表的日期的10天后的日期，其它所有的数值会被重新计算
   c1.add(Calendar.DATE, 10);
   
   //把c1对象的日期加上-10，也就是c1所表的日期的10天前的日期，其它所有的数值会被重新计算
   c1.add(Calendar.DATE, -10);
   

   2）、基本用法，获取年月日时分秒星期

   Calendar c1 = Calendar.getInstance();
   
   // 获得年份
   int year = c1.get(Calendar.YEAR);
   
   // 获取月，这里需要需要月份的范围为0~11，因此获取月份的时候需要+1才是当前月份值
   int month = c1.get(Calendar.MONTH) + 1;（MONTH+1）
   
   // 获得日期
   int date = c1.get(Calendar.DATE);
   
   // 获得小时
   int hour = c1.get(Calendar.HOUR_OF_DAY);
   
   // 获得分钟
   int minute = c1.get(Calendar.MINUTE);
   
   // 获得秒
   int second = c1.get(Calendar.SECOND);
   
   // 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
   int day = c1.get(Calendar.DAY_OF_WEEK);
   

四、 GregorianCalendar类

GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家使用的标准日历系统。

1. GregorianCalendar类对象的创建

   GregorianCalendar(int year, int month, int dayOfMonth) 
   GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute) 。
   GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute, int second)
   

2. 创建一个代表当前日期的GregorianCalendar对象

   GregorianCalendar gc = new GregorianCalendar();
   //创建一个代表2020年2月18日的GregorianCalendar对象(注意参数设置，与其父类是一样，月份要减去1)
   GregorianCalendar gc = new GregorianCalendar(2020,2-1,18);
   

3. 另外：GregorianCalendar有一个方法：boolean isLeapYear(int year)
   判断给定的年份是否为闰年

五、日期类对象之间的互转

1. Date类对象与long型时间的互转

   //1.将Date类的对象转换为long型时间
   Date d= new Date();
   //使用对象的getTime（）方法完成
   long dLong = d.getTime();
   
   //2.将long型时间转换为Date类的对象
   long time = 1290876532190L;
   //使用Date的构造方法完成
   Date d2 = new Date(time);
   

2. Calendar对象和long型时间之间的互转

   // 将Calendar对象转换为相对时间
   Calendar c = Calendar.getInstance();
   long t1 = c.getTimeInMillis(); 
   
   // 将long转换为Calendar对象
   Calendar c1 = Calendar.getInstance();
   long t = 1252785271098L;
   c1.setTimeInMillis(t1);
   

3. Calendar对象和Date对象之间的互转

   //1 .将Calendar对象转换为Date(c.getTime())
   Calendar c = Calendar.getInstance();
   Date d = c.getTime();
   
   // 2.将Date转换为Calendar对象(s.setTime(date))
   Calendar c1 = Calendar.getInstance();
   Date d1 = new Date();
   
   //通过setTime（）方法后，日历c1所表示的日期就d1的日期
   c1.setTime(d1);
   

4. String Calendar之间的转换：

   //1.Date 转化String
   SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");
   String dateStr=sdf.format(new Date());
   
   //2.String 转化Date
   String str="2010-5-27";
   SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");
   Date birthday = sdf.parse(str);
   

5. Date个Calendar对象之间的转换

   //1.Date 转化为Calendar
   Calendar calendar = Calendar.getInstance();
   calendar.setTime(new Date());
   
   //2.Calenda转换为Date
   Calendar calendar = Calendar.getInstance();
   Date date =calendar.getTime();
   

6. Date和String对象之间的转换

   //1.Calendar 转化 String
   Calendar calendat = Calendar.getInstance();
   SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd")0;
   String dateStr = sdf.format(calendar.getTime());
   
   //2.String 转化Calendar
   String str="2010-5-27";
   SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");
   Date date =sdf.parse(str);
   Calendar calendar = Calendar.getInstance();
   calendar.setTime(date);
   

六、时间类常用方法：

1. 判断是否是闰年

   /**
    * 给定一个年份判断该年份是否为闰年
    */
   public static boolean isLeapYear(int year) {
      GregorianCalendar calendar = new GregorianCalendar();
      return calendar.isLeapYear(year);
   }
   

2. 获取当前日期的字符串表示形式

   /**
   * 利用SimpleDateFormat获取当前日期的字符串表示形式 格式：2009-5-05
   */
   public static String getCurrentDate() {
   	SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd")
    	return dateFormat.format(System.currentTimeMillis());
   }
   

3. 给出任意一个年月日得到该天是星期几

   /**
    * 给出任意一个年月日得到该天是星期几
    */
   public static int getWeek(String date) {
      // 注意参数的大小写格式
      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
      Calendar c = Calendar.getInstance();
      try {
   	   Date d = dateFormat.parse(date);
          c.setTime(d);
      } catch (ParseException e) {
      
      }
      return c.get(Calendar.DAY_OF_WEEK)-1;
   }
   

4. 获得今天n天以后或者n天以前是那一天

       /**
        * 获得距离今天n天的那一天的日期
        */
       public static String getDistanceDay(int day) {
          Calendar calen = Calendar.getInstance();
          calen.add(Calendar.DAY_OF_MONTH, day);
          Date date = calen.getTime();
          // 这里也个用SimpleDateFormat的format（）进行格式化，然后以字符串形式返回格式化后的date
          SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
          return dateFormat.format(date);
   }
   

5. 获得距离指定日期n天的那一天的日期

   /**
    * 获得距离指定日期n天的那一天的日期
    */
   public static String getDistanceDay(String date, int day) {
      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
      Date d;
      Calendar c =Calendar.getInstance();
      try {
          d = dateFormat.parse(date);
          c.setTime(d);
          c.add(Calendar.DATE, day);
      } catch (ParseException e) {
          e.printStackTrace();
      }
      return dateFormat.format(c.getTime());
   }
   

6. 获得给定两个日期相差的天数

   /**
    * 获得给定两个日期相差的天数
    */
   public static long getGapDays(String date1, String date2) {
      String[] d1 = date1.split("-");
      String[] d2 = date2.split("-");
      Calendar c = Calendar.getInstance();
      c.set(Integer.parseInt(d1[0]), Integer.parseInt(d1[1]), Integer.parseInt(d1[2]), 0, 0, 0);
      long l1 = c.getTimeInMillis();
      c.set(Integer.parseInt(d2[0]), Integer.parseInt(d2[1]), Integer.parseInt(d2[2]), 0, 0, 0);
      long l2 = c.getTimeInMillis();
      return (Math.abs(l1 - l2) / (24 * 60 * 60 * 1000));
   }
   

七、Java常用类系列（一）： 包装类（Byte、Boolean、Short、Character、Integer、Long、Float、Double）

八、Java常用类系列（三）： 文件类（File）