java calendar 使用_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();

}

}

}