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();
        }
    }

}

转载于:https://www.cnblogs.com/hexu105/p/8078574.html