Calendar的用方法

package com.koal.test.calendar;


import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;


public class TestCalendar {


public static void main(String[] args) {

testCalendarGet();
testCalendarSet();


}



/**获取时间*/
public static void testCalendarGet(){

Calendar calendar = Calendar.getInstance();

System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.MONTH)+1);
System.out.println(calendar.get(Calendar.MONDAY)+1);
System.out.println(calendar.get(Calendar.DATE));
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
System.out.println(calendar.get(Calendar.HOUR));
System.out.println(calendar.get(Calendar.HOUR_OF_DAY));
System.out.println(calendar.get(Calendar.MINUTE));
System.out.println(calendar.get(Calendar.SECOND));
System.out.println(calendar.get(Calendar.DAY_OF_WEEK));//一星期的第几天，5代表周四
System.out.println(calendar.getActualMaximum(Calendar.DAY_OF_MONTH));//一月的天数
;
}

/**设置时间*/
public static void testCalendarSet(){
Calendar calendar = Calendar.getInstance();
calendar.set(2015, 10, 20);
System.out.println(calendar.get(Calendar.MONDAY));
System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
calendar.set(Calendar.DAY_OF_MONTH, 5);
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
System.out.println(calendar.get(Calendar.MONTH));

//add（）   c.add(Calendar.DATE, X);
//去指定天数的时期，取过去天的日期用负数，取未来天数日期用正数，在"X"处天下
//如 c.add(Calendar.DATE, -1)去当前日期前一天的日期 
calendar.add(Calendar.YEAR, -10);
System.out.println(calendar.get(Calendar.YEAR));
}


//java中关于时间日期操作的常用函数 
//1.计算某一月份的最大天数 
public static void method11(){

Calendar time=Calendar.getInstance(); 
time.clear(); 
time.set(Calendar.YEAR,11); 
time.set(Calendar.MONTH,-1);//注意,Calendar对象默认一月为0 
int day=time.getActualMaximum(Calendar.DAY_OF_MONTH);//本月份的天数 
}
//注：在使用set方法之前，必须先clear一下，否则很多信息会继承自系统当前时间 
//2.Calendar和Date的转化 
//(1) Calendar转化为Date 
//Calendar cal=Calendar.getInstance(); 
//Date date=cal.getTime(); 
//(2) Date转化为Calendar 
//Date date=new Date(); 
// Calendar cal=Calendar.getInstance(); 
// cal.setTime(date); 
// 3.格式化输出日期时间 
// Date date=new Date(); 
// SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); 
// System.out.println(df.format(date)); 
// 4.计算一年中的第几星期 
// (1)计算某一天是一年中的第几星期 
// Calendar cal=Calendar.getInstance(); 
// cal.set(Calendar.YEAR, 2006); 
// cal.set(Calendar.MONTH,; 
// cal.set(Calendar.DAY_OF_MONTH, 3); 
// int weekno=cal.get(Calendar.WEEK_OF_YEAR); 
// (2)计算一年中的第几星期是几号 
// SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd"); 
// Calendar cal=Calendar.getInstance(); 
// cal.set(Calendar.YEAR, 2006); 
// cal.set(Calendar.WEEK_OF_YEAR, 1); 
// cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY); 
// System.out.println(df.format(cal.getTime())); 
// 输出: 
// 2006-01-02 
// 5.add()和roll()的用法 
// (1)add()方法 
// SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd"); 
// Calendar cal=Calendar.getInstance(); 
// cal.set(Calendar.YEAR, 2006); 
// cal.set(Calendar.MONTH,; 
// cal.set(Calendar.DAY_OF_MONTH, 3); 
// cal.add(Calendar.DATE, -4); 
// Date date=cal.getTime(); 
// System.out.println(df.format(date)); 
// cal.add(Calendar.DATE, 4); 
// date=cal.getTime(); 
// System.out.println(df.format(date)); 
// 输出： 
// 2006-08-30 
// 2006-09-03 
// (2)roll方法 
// cal.set(Calendar.YEAR, 2006); 
// cal.set(Calendar.MONTH,; 
// cal.set(Calendar.DAY_OF_MONTH, 3); 
// cal.roll(Calendar.DATE, -4); 
// date=cal.getTime(); 
// System.out.println(df.format(date)); 
// cal.roll(Calendar.DATE, 4); 
// date=cal.getTime(); 
// System.out.println(df.format(date)); 
// 输出： 
// 2006-09-29 
// 2006-09-03 
// 可见，roll()方法在本月内循环，一般使用add()方法； 
// 6.计算两个任意时间中间的间隔天数 
// (1)传进Calendar对象 


/** *//**计算两个时间之间相隔天数 
* @param startday 开始时间 
* @param endday 结束时间 
* @return 
*/ 
public int getIntervalDays(Calendar startday,Calendar endday){ 
//确保startday在endday之前 
if(startday.after(endday)){ 
Calendar cal=startday; 
startday=endday; 
endday=cal; 
} 
//分别得到两个时间的毫秒数 
long sl=startday.getTimeInMillis(); 
long el=endday.getTimeInMillis(); 


long ei=el-sl; 
//根据毫秒数计算间隔天数 
return (int)(ei/(1000*60*60*24)); 
} 


//(2)传进Date对象 
/** *//**计算两个时间之间相隔天数 
* @param startday 开始时间 
* @param endday 结束时间 
* @return 
*/ 
public int getIntervalDays(Date startday,Date endday){ 
//确保startday在endday之前 
if(startday.after(endday)){ 
Date cal=startday; 
startday=endday; 
endday=cal; 
} 
//分别得到两个时间的毫秒数 
long sl=startday.getTime(); 
long el=endday.getTime(); 


long ei=el-sl; 
//根据毫秒数计算间隔天数 
return (int)(ei/(1000*60*60*24)); }
// }同理，可以用相同的方法计算出任意两个时间相隔的小时数，分钟数，秒钟数等 
// 注：以上方法是完全按时间计算，有时并不能令人满意，如： 
// startday="2006-10-11 20:00:00" 
// endday="2006-10-12 8:00:00" 
// 计算结果为0，但是我们也许相让计算结果变为1，此时可以用如下方法实现： 
// 在传参之前，先设定endday的时间，如： 
// endday.set(Calendar.HOUR_OF_DAY, 23); 
// endday.set(Calendar.MINUTE, 59); 
// endday.set(Calendar.SECOND, 59); 
// endday.set(Calendar.MILLISECOND, 59); 
// 这样再传进去startday,endday，则结果就如我们所愿了。不过，如果嫌以上方法麻烦，可以参考以下方法： 
// (3)改进精确计算相隔天数的方法 
// public int getDaysBetween (Calendar d1, Calendar d2) ...{ 
// if (d1.after(d2)) ...{ // swap dates so that d1 is start and d2 is end 
// java.util.Calendar swap = d1; 
// d1 = d2; 
// d2 = swap; 
// } 
// int days = d2.get(Calendar.DAY_OF_YEAR) - d1.get(Calendar.DAY_OF_YEAR); 
// int y2 = d2.get(Calendar.YEAR); 
// if (d1.get(Calendar.YEAR) != y2) ...{ 
// d1 = (Calendar) d1.clone(); 
// do ...{ 
// days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);//得到当年的实际天数 
// d1.add(Calendar.YEAR, 1); 
// } while (d1.get(Calendar.YEAR) != y2); 
// } 
// return days; 
// } 
// 2007-04-24 14:34 作者: JAVA-HE   
// re: JAVA 一句话技巧（不断补充中） 
// JAVA中日期格式化 分类:java 基础时间格式化 
// 一、JAVA中日期的获取、设置和格式化 
// 1）JAVA提供了3个日期类：Date、Calendar和DateFormat。 
// Date()方法主要用于创建日期对象并获取日期； 
// Calendar()方法主要用于获取和设置日期； 
// DateFormat()方法主要用于创建日期格式化器，然后再由格式化器将日期转换为各种日期格式串输出。 
// 2）JAVA语言规定的基准日期为格林尼治标准时间1970.1.1.00:00:00，当前日期是由基准日期开始所经历的毫秒数转换出来的。 
// 3）DateFomat类在java.text包中，Date和Calendar类在java.util包中。 
// 4）实例如下： 


public void method1(){
Date today; 
Calendar now; 
DateFormat f1,f2; 
String s1,s2; 


System.out.println("\n显示Date类的相关用法"); 


today = new Date(); 
System.out.println("new Date()= \t"+ today); 


System.out.println("\n用DateFormat类显示各种日期格式"); 


//显示各种日期格式 
f1 = DateFormat.getDateInstance(); 
s1 = f1.format(today); 
System.out.println("DateFormat.getDateInstance()= \t"+s1); 


f1 = DateFormat.getDateInstance(DateFormat.LONG,Locale.CHINA); 
s1 = f1.format(today); 
System.out.println("DateFormat.getDateInstance(DateFormat.LONG,Locale.CHINA)= \t"+ s1); 


f1 = DateFormat.getDateInstance(DateFormat.MEDIUM,Locale.CHINA); 
s1 = f1.format(today); 
System.out.println("DateFormat.getDateInstance(DateFormat.MEDIUM,Locale.CHINA)= \t"+ s1); 


f1 = DateFormat.getDateInstance(DateFormat.SHORT,Locale.CHINA); 
s1 = f1.format(today); 
System.out.println("DateFormat.getDateInstance(DateFormat.SHORT,Locale.CHINA)= \t" + s1); 


System.out.println("\n用DateFormat类显示各种时间格式"); 


//显示各种时间格式 
f1 = DateFormat.getTimeInstance(); 
s1 = f1.format(today); 
System.out.println("DateFormat.getTimeInstance()= \t"+s1); 


f1 = DateFormat.getTimeInstance(DateFormat.LONG,Locale.CHINA); 
s1 = f1.format(today); 
System.out.println("DateFormat.getTimeInstance(DateFormat.LONG,Locale.CHINA)= \t"+s1); 


f1 = DateFormat.getTimeInstance(DateFormat.MEDIUM,Locale.CHINA); 
s1 = f1.format(today); 
System.out.println("DateFormat.getTimeInstance(DateFormat.MEDIUM,Locale.CHINA)= \t"+s1); 


f1 = DateFormat.getTimeInstance(DateFormat.SHORT,Locale.CHINA); 
s1 = f1.format(today); 
System.out.println("DateFormat.getTimeInstance(DateFormat.SHORT,Locale.CHINA)= \t"+s1); 


System.out.println("\n显示Calendar的相关时间用法"); 


now = Calendar.getInstance(); 
today = now.getTime(); 
System.out.println("Calendar.getInstance().getTime()= \t"+ today.toString()); }


 



// 程序运行结果显示如下： 
//
// 显示Date类的相关用法 
// new Date()= Fri May 02 13:29:32 CST 2003 
//
// 用DateFormat类显示各种日期格式 
// DateFormat.getDateInstance()= 2003-5-2 
// DateFormat.getDateInstance(DateFormat.LONG,Locale.CHINA)= 2003年5月2日 
// DateFormat.getDateInstance(DateFormat.MEDIUM,Locale.CHINA)= 2003-5-2 
// DateFormat.getDateInstance(DateFormat.SHORT,Locale.CHINA)= 03-5-2 
//
// 用DateFormat类显示各种时间格式 
// DateFormat.getTimeInstance()= 13:29:32 
// DateFormat.getTimeInstance(DateFormat.LONG,Locale.CHINA)= 下午01时29分32秒 
// DateFormat.getTimeInstance(DateFormat.MEDIUM,Locale.CHINA)= 13:29:32 
// DateFormat.getTimeInstance(DateFormat.SHORT,Locale.CHINA)= 下午1:29 
//
// 显示Calendar的相关时间用法 
// Calendar.getInstance().getTime()= Fri May 02 13:29:33 CST 2003 
//
// *********************************************************************************转帖 
// Java 语言的Calendar(日历),Date(日期), 和DateFormat(日期格式)组成了Java标准的一个基本但是非常重要的部分. 日期是商业逻辑计算一个关键的部分. 所有的开发者都应该能够计算未来的日期, 定制日期的显示格式, 并将文本数据解析成日期对象. 我们写了两篇文章, 这是第一篇, 我们将大概的学习日期, 日期格式, 日期的解析和日期的计算. 
//
//
// 我们将讨论下面的类: 
//
// 1、具体类(和抽象类相对)java.util.Date 
// 2、抽象类java.text.DateFormat 和它的一个具体子类,java.text.SimpleDateFormat 
// 3、抽象类java.util.Calendar 和它的一个具体子类,java.util.GregorianCalendar 
//
// 具体类可以被实例化, 但是抽象类却不能. 你首先必须实现抽象类的一个具体子类. 
//
// Date 类从Java 开发包(JDK) 1.0 就开始进化, 当时它只包含了几个取得或者设置一个日期数据的各个部分的方法, 比如说月, 日, 和年. 这些方法现在遭到了批评并且已经被转移到了Calendar类里去了, 我们将在本文中进一步讨论它. 这种改进旨在更好的处理日期数据的国际化格式. 就象在JDK 1.1中一样, Date 类实际上只是一个包裹类, 它包含的是一个长整型数据, 表示的是从GMT(格林尼治标准时间)1970年, 1 月 1日00:00:00这一刻之前或者是之后经历的毫秒数. 
//


// 一、创建一个日期对象 


// 让我们看一个使用系统的当前日期和时间创建一个日期对象并返回一个长整数的简单例子. 这个时间通常被称为Java 虚拟机(JVM)主机环境的系统时间. 
// import java.util.Date; 


//public class DateExample1 { 
// /public static void main(String[] args) { 
// // Get the system date/time 
// Date date = new Date(); 


// System.out.println(date.getTime()); 
// } 
// } 


// 在星期六, 2001年9月29日, 下午大约是6:50的样子, 上面的例子在系统输出设备上显示的结果是 1001803809710. 在这个例子中,值得注意的是我们使用了Date 构造函数创建一个日期对象, 这个构造函数没有接受任何参数. 而这个构造函数在内部使用了System.currentTimeMillis() 方法来从系统获取日期. 
//
// 那么, 现在我们已经知道了如何获取从1970年1月1日开始经历的毫秒数了. 我们如何才能以一种用户明白的格式来显示这个日期呢? 在这里类java.text.SimpleDateFormat 和它的抽象基类 java.text.DateFormat 就派得上用场了. 
//


// 二、日期数据的定制格式 
//
// 假如我们希望定制日期数据的格式, 比方星期六-9月-29日-2001年. 下面的例子展示了如何完成这个工作: 
//
// import java.text.SimpleDateFormat; 
// import java.util.Date; 
//
// public class DateExample2 { 
//
// public static void main(String[] args) { 
//
// SimpleDateFormat bartDateFormat = 
// new SimpleDateFormat("EEEE-MMMM-dd-yyyy"); 
//
// Date date = new Date(); 
//
// System.out.println(bartDateFormat.format(date)); 
// } 
// } 
//
// 只要通过向SimpleDateFormat 的构造函数传递格式字符串"EEE-MMMM-dd-yyyy", 我们就能够指明自己想要的格式. 你应该可以看见, 格式字符串中的ASCII 字符告诉格式化函数下面显示日期数据的哪一个部分. EEEE是星期, MMMM是月, dd是日, yyyy是年. 字符的个数决定了日期是如何格式化的.传递"EE-MM-dd-yy"会显示 Sat-09-29-01. 请察看Sun 公司的Web 站点获取日期格式化选项的完整的指示. 
//
//
// 三、将文本数据解析成日期对象 
//
// 假设我们有一个文本字符串包含了一个格式化了的日期对象, 而我们希望解析这个字符串并从文本日期数据创建一个日期对象. 我们将再次以格式化字符串"MM-dd-yyyy" 调用SimpleDateFormat类, 但是这一次, 我们使用格式化解析而不是生成一个文本日期数据. 我们的例子, 显示在下面, 将解析文本字符串"9-29-2001"并创建一个值为001736000000 的日期对象. 
//
// 例子程序: 
//




public static void main3(String[] args) { 
// Create a date formatter that can parse dates of 
// the form MM-dd-yyyy. 
SimpleDateFormat bartDateFormat = 
new SimpleDateFormat("MM-dd-yyyy"); 


// Create a string containing a text date to be parsed. 
String dateStringToParse = "9-29-2001"; 


try { 
// Parse the text version of the date. 
// We have to perform the parse method in a 
// try-catch construct in case dateStringToParse 
// does not contain a date in the format we are expecting. 
Date date = bartDateFormat.parse(dateStringToParse); 


// Now send the parsed date as a long value 
// to the system output. 
System.out.println(date.getTime()); 
} 
catch (Exception ex) { 
System.out.println(ex.getMessage()); 
} }}
//
//
//
//
// 五、使用标准的日期格式化过程 
//
// 既然我们已经可以生成和解析定制的日期格式了, 让我们来看一看如何使用内建的格式化过程. 方法 DateFormat.getDateTimeInstance() 让我们得以用几种不同的方法获得标准的日期格式化过程. 在下面的例子中, 我们获取了四个内建的日期格式化过程. 它们包括一个短的, 中等的, 长的, 和完整的日期格式. 
//
//
// public static void mccin22() { 
// Date date = new Date(); 
//
// DateFormat shortDateFormat = 
// DateFormat.getDateTimeInstance( 
// DateFormat.SHORT, 
// DateFormat.SHORT); 
//
// DateFormat mediumDateFormat = 
// DateFormat.getDateTimeInstance( 
// DateFormat.MEDIUM, 
// DateFormat.MEDIUM); 
//
// DateFormat longDateFormat = 
// DateFormat.getDateTimeInstance( 
// DateFormat.LONG, 
// DateFormat.LONG); 
//
// DateFormat fullDateFormat = 
// DateFormat.getDateTimeInstance( 
// DateFormat.FULL, 
// DateFormat.FULL); 
//
// System.out.println(shortDateFormat.format(date)); 
// System.out.println(mediumDateFormat.format(date)); 
// System.out.println(longDateFormat.format(date)); 
// System.out.println(fullDateFormat.format(date)); 
// } 

//
//
//
// 注意我们在对 getDateTimeInstance的每次调用中都传递了两个值. 第一个参数是日期风格, 而第二个参数是时间风格. 它们都是基本数据类型int(整型). 考虑到可读性, 我们使用了DateFormat 类提供的常量: SHORT, MEDIUM, LONG, 和 FULL. 要知道获取时间和日期格式化过程的更多的方法和选项, 请看Sun 公司Web 站点上的解释. 
//
// 运行我们的例子程序的时候, 它将向标准输出设备输出下面的内容: 
// 9/29/01 8:44 PM 
// Sep 29, 2001 8:44:45 PM 
// September 29, 2001 8:44:45 PM EDT 
// Saturday, September 29, 2001 8:44:45 PM EDT 
//
//
// 六、Calendar 类 
//
// 我们现在已经能够格式化并创建一个日期对象了, 但是我们如何才能设置和获取日期数据的特定部分呢, 比如说小时, 日, 或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类. 就如我们前面提到的那样, Calendar 类中的方法替代了Date 类中被人唾骂的方法. 
//
// 假设你想要设置, 获取, 和操纵一个日期对象的各个部分, 比方一个月的一天或者是一个星期的一天. 为了演示这个过程, 我们将使用具体的子类 java.util.GregorianCalendar. 考虑下面的例子, 它计算得到下面的第十个星期五是13号. 
//




// public  void main1(){ 
// DateFormat dateFormat = 
// DateFormat.getDateInstance(DateFormat.FULL); 
//
// // Create our Gregorian Calendar. 
// GregorianCalendar cal = new GregorianCalendar(); 
//
// // Set the date and time of our calendar 
// // to the system's date and time 
// cal.setTime(new Date()); 
//
// System.out.println("System Date: " + 
// dateFormat.format(cal.getTime())); 
//
// // Set the day of week to FRIDAY 
// cal.set(GregorianCalendar.DAY_OF_WEEK, 
// GregorianCalendar.FRIDAY); 
// System.out.println("After Setting Day of Week to Friday: " + 
// dateFormat.format(cal.getTime())); 
//
// int friday13Counter = 0; 
// while (friday13Counter <= 10) { 
//
// // Go to the next Friday by adding 7 days. 
// cal.add(GregorianCalendar.DAY_OF_MONTH, 7); 
//
// // If the day of month is 13 we have 
// // another Friday the 13th. 
// if (cal.get(GregorianCalendar.DAY_OF_MONTH) == 13) { 
// friday13Counter++; 
// System.out.println(dateFormat.format(cal.getTime())); 
// } 
// } 
// } 
// }
//
//
//
// 在这个例子中我们作了有趣的函数调用: 
// cal.set(GregorianCalendar.DAY_OF_WEEK, 
// GregorianCalendar.FRIDAY); 
//
// 和: 
// cal.add(GregorianCalendar.DAY_OF_MONTH, 7); 
//
// set 方法能够让我们通过简单的设置星期中的哪一天这个域来将我们的时间调整为星期五. 注意到这里我们使用了常量 DAY_OF_WEEK 和 FRIDAY来增强代码的可读性. add 方法让我们能够在日期上加上数值. 润年的所有复杂的计算都由这个方法自动处理. 
//
// 我们这个例子的输出结果是: 
// System Date: Saturday, September 29, 2001 
// 当我们将它设置成星期五以后就成了: Friday, September 28, 2001 
// Friday, September 13, 2002 
// Friday, December 13, 2002 
// Friday, June 13, 2003 
// Friday, February 13, 2004 
// Friday, August 13, 2004 
// Friday, May 13, 2005 
// Friday, January 13, 2006 
// Friday, October 13, 2006 
// Friday, April 13, 2007 
// Friday, July 13, 2007 
// Friday, June 13, 2008
//