【日期-时间】Java中Calendar的使用

主要介绍了Calendar类的使用
输出
  1. * 时间格式化
  2.  * 当前时间：2016-12-02 16:46:27.079
  3.  * 
  4.  * 转换：String-->Date-->Calendar
  5.  * 设置时间(方式1)：2014-08-01 09:18:34.123
  6.  * 设置时间(方式2)：2016-12-01 19:08:54.123
  7.  * 
  8.  * ----YEAR-MONTH----
  9.  * YEAR:2016
  10.  * MONTH:11
  11.  * ----Day-----
  12.  * 本月第几天:1
  13.  * 本周几:5
  14.  * 今年的第 N天 :336
  15.  * DAY_OF_WEEK_IN_MONTH:1
  16.  * ----Hour-----
  17.  * Hour:7
  18.  * HOUR_OF_DAY:19
  19.  * ----MINUTE-----
  20.  * MINUTE:8
  21.  * 
  22.  * 向后推迟一个月(方式1)：2017-01-01 19:08:54.123
  23.  * 向后推迟一个月(方式2)：2017-02-01 19:08:54.123
  24.  * 向后推迟一小时(方式1)：2017-02-01 20:08:54.123
  25.  * 向前推迟一小时(方式2)：2017-02-01 19:08:54.123
  26.  * 设置为30分钟：2017-02-01 19:30:00.123
  27.  * 
  28.  * 开始时间：2014-12-15 16:46:27.116,毫秒数：1418633187116
  29.  * 结束时间：2016-12-05 12:15:35.117,毫秒数：1480911335117
  30.  * 相差天数：721
  31.  * 
  32.  * 本月最大天数：31
程序
  1. package com.sssppp.DateTime;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Calendar;
  6. import java.util.Date;
  8. public class CalendarExample {
  9.    public static void main(String[] args) {
  10.       Calendar cal = Calendar.getInstance();
  11.       System.out.println("时间格式化");
  12.       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
  13.       System.out.println("当前时间：" + sdf.format(cal.getTime()));
  14.       System.out.println();
  15.       
  16.       try {
  17.          System.out.println("转换：String-->Date-->Calendar");
  18.          cal.setTime(sdf.parse("2014-8-1 9:18:34.123"));
  19.          System.out.println("设置时间(方式1)：" + sdf.format(cal.getTime()));
  20.       } catch (ParseException e) {
  21.          e.printStackTrace();
  22.       }
  23.       
  24.       //2016-12-01 19:08:54
  25.       cal.set(2016, Calendar.DECEMBER, 1, 19, 8, 54);
  26.       System.out.println("设置时间(方式2)：" +sdf.format(cal.getTime()));
  27.       System.out.println();
  28.       
  29.       System.out.println("----YEAR-MONTH----");
  30.       System.out.println("YEAR:" + cal.get(Calendar.YEAR));
  31.       System.out.println("MONTH:" + cal.get(Calendar.MONTH));
  32.       System.out.println("----Day-----");
  33.       System.out.println("本月第几天:" + cal.get(Calendar.DAY_OF_MONTH));
  34.       System.out.println("本周几:" + cal.get(Calendar.DAY_OF_WEEK));
  35.       System.out.println("今年的第 N天 :" + cal.get(Calendar.DAY_OF_YEAR));
  36.       System.out.println("DAY_OF_WEEK_IN_MONTH:"
  37.             + cal.get(Calendar.DAY_OF_WEEK_IN_MONTH));
  38.       System.out.println("----Hour-----");
  39.       System.out.println("Hour:" + cal.get(Calendar.HOUR));
  40.       System.out.println("HOUR_OF_DAY:" + cal.get(Calendar.HOUR_OF_DAY));
  41.       System.out.println("----MINUTE-----");
  42.       System.out.println("MINUTE:" + cal.get(Calendar.MINUTE));
  44.       System.out.println();
  45.       cal.set(Calendar.MONTH,cal.get(Calendar.MONTH)+1);
  46.       System.out.println("向后推迟一个月(方式1)：" + sdf.format(cal.getTime()));
  47.       cal.add(Calendar.MONDAY, 1);
  48.       System.out.println("向后推迟一个月(方式2)：" + sdf.format(cal.getTime()));
  49.       
  50.       cal.set(Calendar.HOUR,cal.get(Calendar.HOUR)+1);
  51.       System.out.println("向后推迟一小时(方式1)：" + sdf.format(cal.getTime()));
  52.       cal.add(Calendar.HOUR, -1);
  53.       System.out.println("向前推迟一小时(方式2)：" + sdf.format(cal.getTime()));
  54.       
  55.       cal.set(Calendar.MINUTE,30);
  56.       cal.set(Calendar.SECOND,00);
  57.       System.out.println("设置为30分钟：" + sdf.format(cal.getTime()));
  58.       cal.getTimeInMillis();
  59.       
  60.       System.out.println();
  61.       Calendar calStart = Calendar.getInstance();
  62.       calStart.set(2014, Calendar.DECEMBER, 15);
  63.       System.out.println("开始时间：" + sdf.format(calStart.getTimeInMillis())
  64.             + ",毫秒数：" + calStart.getTimeInMillis());
  65.       Calendar calEnd = Calendar.getInstance();
  66.       calEnd.set(2016, Calendar.DECEMBER, 5, 12, 15, 35);
  67.       System.out.println("结束时间：" + sdf.format(calEnd.getTimeInMillis())
  68.             + ",毫秒数：" + calEnd.getTimeInMillis());
  69.       int day =getDaysBetween(calEnd,calStart);
  70.       System.out.println("相差天数：" + day);
  71.       
  72.       //计算某一月份的最大天数    
  73.       System.out.println();
  74.       Calendar time=Calendar.getInstance();     
  75.       time.clear(); // 在使用set方法之前，必须先clear一下，否则很多信息会继承自系统当前时间
  76.       time.set(Calendar.YEAR, 2016);
  77.       int dayCount = time.getActualMaximum(Calendar.DAY_OF_MONTH);// 本月份的天数
  78.       System.out.println("本月最大天数：" + dayCount);
  79.       
  80.    }
  82.    /**
  83.     * 计算两个时间之间相隔天数（不够精确）
  84.     * 
  85.     * @param startday
  86.     *            开始时间
  87.     * @param endday
  88.     *            结束时间
  89.     * @return
  90.     */
  91.    public static int getIntervalDays(Calendar startday, Calendar endday) {
  92.       // 确保startday在endday之前
  93.       if (startday.after(endday)) {
  94.          Calendar cal = startday;
  95.          startday = endday;
  96.          endday = cal;
  97.       }
  98.       // 分别得到两个时间的毫秒数
  99.       long sl = startday.getTimeInMillis();
  100.       long el = endday.getTimeInMillis();
  102.       long ei = el - sl;
  103.       // 根据毫秒数计算间隔天数
  104.       return (int) (ei / (1000 * 60 * 60 * 24));
  105.    }
  106.    
  107.    /**
  108.     * 计算两个时间之间相隔天数（不够精确）
  109.     * 
  110.     * @param startday
  111.     *            开始时间
  112.     * @param endday
  113.     *            结束时间
  114.     * @return
  115.     */
  116.    public int getIntervalDays(Date startday, Date endday) {
  117.       // 确保startday在endday之前
  118.       if (startday.after(endday)) {
  119.          Date cal = startday;
  120.          startday = endday;
  121.          endday = cal;
  122.       }
  123.       // 分别得到两个时间的毫秒数
  124.       long sl = startday.getTime();
  125.       long el = endday.getTime();
  127.       long ei = el - sl;
  128.       // 根据毫秒数计算间隔天数
  129.       return (int) (ei / (1000 * 60 * 60 * 24));
  130.    } 
  131.        
  132.    /**
  133.     * 精确计算两个日期之间的天数
  134.     * 
  135.     * @param d1
  136.     * @param d2
  137.     * @return
  138.     */
  139.    public static int getDaysBetween(Calendar d1, Calendar d2) {
  140.       if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end
  141.          java.util.Calendar swap = d1;
  142.          d1 = d2;
  143.          d2 = swap;
  144.       }
  146.       int days = d2.get(Calendar.DAY_OF_YEAR) - d1.get(Calendar.DAY_OF_YEAR);
  147.       int y2 = d2.get(Calendar.YEAR);
  148.       if (d1.get(Calendar.YEAR) != y2) {
  149.          d1 = (Calendar) d1.clone();
  150.          do {
  151.             days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);// 得到当年的实际天数
  152.             d1.add(Calendar.YEAR, 1);
  153.          } while (d1.get(Calendar.YEAR) != y2);
  154.       }
  155.       return days;
  156.    } 
  157. }











【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/ssslinppp/p/6126398.html