Java Calendar使用

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import org.apache.commons.lang3.time.DateUtils;

public class calendarTest {
	// Calendar的作用：设置日期时间、对日历字段进行加减操作，获得日历字段的详细信息
	public static void main(String[] args) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

		Calendar cal = Calendar.getInstance();
		// TODO get方法 返回给定日历字段的值。
		// 获取当前年份
		int year = cal.get(Calendar.YEAR);

		// 获取当前月份 Calendar.MONTH从0开始
		int month = (cal.get(Calendar.MONTH)) + 1;

		// 获取当前天是当前月的第几天：即当前日期
		int day_of_month = cal.get(Calendar.DAY_OF_MONTH);
		// Calendar.DAY_OF_MONTH 和 Calendar.DATE 是等价的
		int date = cal.get(Calendar.DATE);

		// 获取当前小时数：HOUR_OF_DAY-24小时制
		int hour24 = cal.get(Calendar.HOUR_OF_DAY);
		// HOUR-12小时制
		int hour12 = cal.get(Calendar.HOUR);

		// 获取当前分钟数
		int minute = cal.get(Calendar.MINUTE);

		// 获取当期秒数
		int second = cal.get(Calendar.SECOND);

		// 获取当前天是当前自然周的第几天 Calendar.DAY_OF_WEEK用数字（1~7）表示（星期日~星期六）
		int day_of_week = cal.get(Calendar.DAY_OF_WEEK);

		// 0-上午；1-下午
		int ampm = cal.get(Calendar.AM_PM);

		// 获取当前日期所在的自然周是当前年的第几个自然周
		int week_of_year = cal.get(Calendar.WEEK_OF_YEAR);

		// 获取当前日期所在的自然周是当前月的第几个自然周
		int week_of_month = cal.get(Calendar.WEEK_OF_MONTH);

		// 获取当前日期所在的非自然周是当前月中的第几个非自然周 （1-7第一周）
		int day_of_week_in_month = cal.get(Calendar.DAY_OF_WEEK_IN_MONTH);

		// 获取当前日期是当前年的第几天
		int day_of_year = cal.get(Calendar.DAY_OF_YEAR);

		// 获取一个自然周的第一天是星期几；目前默认的一周的第一天是周天。
		int FirstDayOfWeek = cal.getFirstDayOfWeek();

		// 返回指定日历字段实际拥有的最大值。
		// month:11;day_of_month:28,29,30,31;day_of_year:365,366
		int ActualMaximum = cal.getActualMaximum(Calendar.DAY_OF_YEAR);

		// 返回指定日历字段拥有的最大值。
		// month:11;day_of_month:31;day_of_year:366
		int Maximum = cal.getMaximum(Calendar.DAY_OF_YEAR);

		// 返回指定日历字段实际拥有的最小值。
		// year:1;month:0;day_of_month:1;day_of_year:1;week_of_year:1
		int ActualMinimum = cal.getActualMinimum(Calendar.DAY_OF_YEAR);

		// 返回指定日历字段拥有的最小值。
		// year:1;month:0;day_of_month:1;day_of_year:1;week_of_year:1
		int Minimum = cal.getMinimum(Calendar.DAY_OF_YEAR);

		// Calendar转Date
		Date date1 = cal.getTime();

		// Date转Calendar
		cal.setTime(date1);
		cal.set(Calendar.YEAR, 2016);
		Calendar cal1 = Calendar.getInstance();
		System.out.println("1111111:" + cal);
		System.out.println(cal.getTime());
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(cal1.getTime());
		System.out.println("22222222:" + cal1);
		// TODO set方法
		// 将给定的日历字段设置为给定值(定位),在使用set方法之前,建议先clear()一下，否则很多信息会继承自系统当前时间
		// 注意事项：如果set()的日期不合法，就会往后找，自动转换为合法的日期
		// 如set 2017-09-31，9月没有31,就会往后找,找一天,实际日期应该为2017-10-1
		System.out.println(cal.getTime());
		cal.clear();
		System.out.println(cal.getTime());
		cal.set(2017, Calendar.SEPTEMBER, 30);
		System.out.println("合法日期2017-9-30    :" + sdf.format(cal.getTime()));
		cal.set(2017, Calendar.SEPTEMBER, 31);
		System.out.println("2017-9-31设置为合法日期:" + sdf.format(cal.getTime()));

		// 得到今年的实际最大的星期数
		int weeks = cal.getActualMaximum(Calendar.WEEK_OF_YEAR);
		System.out.println("今年的实际星期数:" + weeks);
		// 设置一个不合法的星期数
		cal.set(Calendar.WEEK_OF_YEAR, 60);
		System.out.println("往后找到" + cal.get(Calendar.YEAR) + "年的第" + cal.get(Calendar.WEEK_OF_YEAR) + "周");

		// TODO add方法 根据日历的规则，为给定的日历字段添加或减去指定的时间量。
		// add()有两条规则：
		// 1.当被修改的字段超过它可以的范围时，那么比它大的字段会自动修正。
		// 2.如果比它小的字段在修正后的日期内是合法的，则小字段不需要改变;否则小字段会修正到变化最小的合法值。
		// 例1 8
		cal.set(2017, Calendar.AUGUST, 31);
		// 规则1：没有超过范围，不用改变大的字段（年份不变）
		cal.add(Calendar.MONTH, 1);
		// 规则2：比其小的字段不合法（日期改变），修正到变化最小的值，为30即可
		System.out.println("add方法规则:" + sdf.format(cal.getTime()));// 结果是2017-09-30

		// 例2
		cal.set(2017, Calendar.AUGUST, 31);
		// 规则1：超过范围，改变大的字段（年份不变）(年份改为2018)
		// 规则2：比其小的字段不合法（日期改变），变化最小值，为30即可
		cal.add(Calendar.MONTH, 13);
		System.out.println("add方法规则:" + sdf.format(cal.getTime()));// 结果是2018-09-30

		// TODO roll方法 和add方法一样，区别就是 当被修改的字段超出它可以的范围时，那么比它大的字段不会被修正
		// 1.当被修改的字段超过它可以的范围时，那么比它大的字段不会自动修正。
		// 2.如果比它小的字段在修正后的日期内是合法的，则小字段不需要改变；否则小字段会修正到变化最小的合法值。
		// 例1
		cal.set(2017, Calendar.AUGUST, 31);
		cal.roll(Calendar.MONTH, 13);
		System.out.println("roll方法规则:" + sdf.format(cal.getTime()));// 结果是2017-09-30

		// 求某月的第一天和最后一天
		cal.set(Calendar.DAY_OF_MONTH, 1);
		System.out.println("月中的第一天：" + sdf.format(cal.getTime()));
		cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
		System.out.println("月中的最后一天：" + sdf.format(cal.getTime()));

		// 求上月的最后一天
		cal.add(Calendar.MONTH, -1);
		cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
		System.out.println("上月的最后一天：" + sdf.format(cal.getTime()));

		// 求两个日期间的时间差()
		Calendar c1 = Calendar.getInstance();
		c1.clear();
		c1.set(2017, Calendar.SEPTEMBER, 20, 15, 52, 35);
		Calendar c2 = Calendar.getInstance();
		c2.clear();
		c2.set(2017, Calendar.SEPTEMBER, 26, 14, 52, 35);

		long l1 = c1.getTimeInMillis();
		long l2 = c2.getTimeInMillis();
		long l3 = (l2 - l1) / 1000 / 60 / 60 / 24;// 天数
		long l4 = (l2 - l1) / 1000 / 60 / 60 % 24;// 小时
		long l5 = (l2 - l1) / 1000 / 60 % 60;// 分
		long l6 = (l2 - l1) / 1000 % 60;// 秒
		System.out.println("时间相差" + l3 + "天" + l4 + "小时" + l5 + "分" + l6 + "秒");

		// 求n天之后的日期
		c2 = Calendar.getInstance();
		c2.add(Calendar.DATE, 4);
		System.out.println("n天之后的日期：" + sdf.format(c2.getTime()));

		// 计算某一天是一年中的第几个星期
		String s = "2018-1-7";
		Date dd = DateUtils.parseDate(s, "yyyy-MM-dd");
		c2.setTime(dd);
		System.out.println("当年的第" + c2.get(Calendar.WEEK_OF_YEAR) + "周");

		// 计算一年中第几周的星期几是几号
		c2 = Calendar.getInstance();
		System.out.println(c2.get(Calendar.WEEK_OF_YEAR));
		cal.set(Calendar.YEAR, 2017);
		cal.set(Calendar.WEEK_OF_YEAR, c2.get(Calendar.WEEK_OF_YEAR));
		cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
		System.out.println("今天是" + cal.get(Calendar.DAY_OF_MONTH) + "号");

		// TODO 毫秒的3种获取方式
		System.currentTimeMillis();
		Calendar.getInstance().getTimeInMillis();
		new Date().getTime();

		// 性能比较
		long times = 10000000l;
		long t1 = System.currentTimeMillis();
		testSystem(times);
		long t2 = System.currentTimeMillis();
		System.out.println("system耗时：" + (t2 - t1));
		testCalendar(times);
		long t3 = System.currentTimeMillis();
		System.out.println("Calendar耗时:" + (t3 - t2));
		testDate(times);
		long t4 = System.currentTimeMillis();
		System.out.println("Date耗时：" + (t4 - t3));
		// 结果发现System.currentTimeMillis()和new
		// Date().getTime()获取的速度差不多；Calendar.getInstance().getTimeInMillis()
		// 这种方式速度最慢,看源码会发现，Canlendar因为要处理时区问题会耗费很多的时间。所以建议多使用第一种方式或第二种。

		// TODO 纳秒的作用
		// java中System.nanoTime()返回的是纳秒,但是不能用它来计算当前日期.
		// 此返回值表示从某一固定但任意的时间算起的纳秒数（或许从以后算起，所以该值可能为负）。
		// nanoTime主要的用途是衡量一个时间段，比如说一段代码执行所用的时间，获取数据库连接所用的时间，网络访问所用的时间等。

		// TODO java.util.Date和java.sql时间类的区别及应用
		// java.util.Date 是 java.sql.Date 的父类，前者是常用的表示时间的类，后者在读写数据库的时候用。
		// java.sql包下给出三个与数据库相关的日期时间类型，分别是：
		// Date：表示日期，只有年月日，没有时分秒。会丢失时间；
		// Time：表示时间，只有时分秒，没有年月日。会丢失日期；
		// Timestamp：表示时间戳，有年月日时分秒，以及毫秒。
		java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis());
		System.out.println(sqlDate);// 2017-09-26

		java.sql.Time sqlTime = new java.sql.Time(System.currentTimeMillis());
		System.out.println(sqlTime);// 16:10:43

		java.sql.Timestamp sqlTimestamp = new java.sql.Timestamp(System.currentTimeMillis());
		System.out.println(sqlTimestamp);// 2017-09-26 16:10:43.043

		// 相互转换
		// 把数据库的三种时间类型赋给java.util.Date，基本不用转换，因为这是把子类对象给父类的引用。
		java.util.Date d1 = sqlDate;
		java.util.Date d2 = sqlTime;
		java.util.Date d3 = sqlTimestamp;

		// 当需要把java.util.Date转换成数据库的三种时间类型时，这就不能直接赋值了，这需要使用数据库三种时间类型的构造器。
		// java.sql包下的Date、Time、TimeStamp三个类的构造器都需要一个long类型的参数，表示毫秒值（时间戳）。
		// 创建这三个类型的对象，只需要有毫秒值即可。我们知道java.util.Date有getTime()方法可以获取毫秒值，那么这个转换也就不是什么问题了。
		java.util.Date d = new java.util.Date();
		java.sql.Date d4 = new java.sql.Date(d.getTime());// 会丢失时分秒
		java.sql.Time d5 = new java.sql.Time(d.getTime());// 会丢失年月日
		java.sql.Timestamp d6 = new java.sql.Timestamp(d.getTime());

		// TODO 两个new Date()对象的hasCode()值一样的原因。
		// 是因为Date类重写了生成hashCode的方法。以对象当前的毫秒值为基础生成。因此，如果在同一时间做new
		// Date()操作，两次new的时间差小于1毫秒，所以两者的毫秒值是一样的，那么在这个运算下生成的hashCode就是相等。
		System.out.println("***********" + System.currentTimeMillis());
		Date d7 = new Date();
		// try {
		// new Thread();
		// Thread.sleep(1);
		// } catch (InterruptedException e) {
		// e.printStackTrace();
		// }
		Date d8 = new Date();
		System.out.println("***********" + System.currentTimeMillis());
		System.out.println("d7的hascode:" + d7.hashCode());
		System.out.println("d7的hascode:" + d8.hashCode());
	}

	public static void testSystem(long times) {
		for (int i = 0; i < times; i++) {
			System.currentTimeMillis();
		}
	}

	public static void testCalendar(long times) {
		for (int i = 0; i < times; i++) {
			Calendar.getInstance().getTimeInMillis();
		}
	}

	public static void testDate(long times) {
		for (int i = 0; i < times; i++) {
			new Date().getTime();
		}
	}

}