㈠ java Calendar类获取时间问题.
WEEK_OF_MONTH 某月第几周，来严格以星期源的起止算。比如这个月3号才是周一，那3号才算第1周，2号不算。以星期为标准
DAY_OF_WEEK_IN_MONTH，某月中第几周，按这个月1号算，1号起就是第1周，8号起就是第2周。以月份天数为标准
int am = calendar.get(Calendar.AM);
int pm = calendar.get(Calendar.PM); //这2行是误用，AM和PM是作为值的常量
=============
正确用法
int r = calendar.get(Calendar.AM_PM);//询上午还是下午
if(r==Calendar.AM)//如果上午
if(r==Calendar.PM)//如果下午
㈡ java时间类的问题
void
set(int year,
int month, int date, int hourOfDay, int minute)
设置日历字段
YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY
和 MINUTE 的值。
Calendar 类是一个抽象类，它为特定瞬间与一组诸如
YEAR、MONTH、DAY_OF_MONTH、HOUR
等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。该类还为实现包范围外的具体日历系统提供了其他字段和方法。这些字段和方法被定义为 protected。与其他语言环境敏感类一样，Calendar 提供了一个类方法
getInstance，以获得此类型的一个通用的对象。Calendar 的
getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化：
Calendar rightNow = Calendar.getInstance();Calendar
对象能够生成为特定语言和日历风格实现日期-时间格式化所需的所有日历字段值，例如，日语-格里高里历，日语-传统日历。Calendar
定义了某些日历字段返回值的范围，以及这些值的含义。例如，对于所有日历，日历系统第一个月的值是 MONTH ==
JANUARY。其他值是由具体子类（例如 ERA）定义的。有关此内容的细节，请参阅每个字段的文档和子类文档。获得并设置日历字段值
可以通过调用 set 方法来设置日历字段值。在需要计算时间值（距历元所经过的毫秒）或日历字段值之前，不会解释
Calendar 中的所有字段值设置。调用
get、getTimeInMillis、getTime、add
和 roll 涉及此类计算。宽松性
Calendar 有两种解释日历字段的模式，即 lenient 和
non-lenient。当 Calendar 处于 lenient
模式时，它可接受比它所生成的日历字段范围更大范围内的值。当 Calendar 重新计算日历字段值，以便由
get() 返回这些值时，所有日历字段都被标准化。例如，lenient 模式下的
GregorianCalendar 将 MONTH ==
JANUARY、DAY_OF_MONTH == 32 解释为 February 1。当 Calendar 处于 non-lenient
模式时，如果其日历字段中存在任何不一致性，它都会抛出一个异常。例如，GregorianCalendar 总是在 1
与月份的长度之间生成 DAY_OF_MONTH 值。如果已经设置了任何超出范围的字段值，那么在计算时间或日历字段值时，处于
non-lenient 模式下的 GregorianCalendar 会抛出一个异常。第一个星期
Calendar 使用两个参数定义了特定于语言环境的 7
天制星期：星期的第一天和第一个星期中的最小一天（从 1 到 7）。这些数字取自构造 Calendar
时的语言环境资源数据。还可以通过为其设置值的方法来显式地指定它们。
在设置或获得 WEEK_OF_MONTH 或 WEEK_OF_YEAR
字段时，Calendar 必须确定一个月或一年的第一个星期，以此作为参考点。一个月或一年的第一个星期被确定为开始于
getFirstDayOfWeek() 的最早七天，它最少包含那一个月或一年的
getMinimalDaysInFirstWeek() 天数。第一个星期之前的各星期编号为 ...、-1、0；之后的星期编号为
2、3、...。注意，get() 返回的标准化编号方式可能有所不同。例如，特定 Calendar
子类可能将某一年第 1 个星期之前的那个星期指定为前一年的第 n 个星期。日历字段解析
在计算日历字段中的日期和时间时，可能没有足够的信息用于计算（例如只有年和月，但没有日），或者可能有不一致的信息( 例如
"Tuesday, July 15, 1996"（格林威治时间）——实际上，1996 年 7 月 15 日是星期一
)。Calendar 将解析日历字段值，以便用以下方式确定日期和时间。
如果日历字段值中存在任何冲突，则 Calendar
将为最近设置的日历字段提供优先权。以下是日历字段的默认组合。将使用由最近设置的单个字段所确定的最近组合。对于日期字段：
YEAR + MONTH + DAY_OF_MONTH
YEAR + MONTH + WEEK_OF_MONTH + DAY_OF_WEEK
YEAR + MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK
YEAR + DAY_OF_YEAR
YEAR + DAY_OF_WEEK + WEEK_OF_YEAR
对于时间字段：
HOUR_OF_DAY
AM_PM + HOUR如果在选定的字段组合中，还有尚未设置值的任一日历字段，那么 Calendar
将使用其默认值。每个字段的默认值可能依据具体的日历系统而有所不同。例如，在 GregorianCalendar
中，字段的默认值与历元起始部分的字段值相同：即 YEAR = 1970、MONTH =
JANUARY、DAY_OF_MONTH = 1，等等。注： 对于某些特别时间的解释可能会有某些歧义，可以用下列方式解决：
23:59 是一天中的最后一分钟，而 00:00 是下一天的第一分钟。因此，1999 年 12 月 31 日的 23:59 < 2000 年 1
月 1 日的 00:00。
尽管从历史上看不够精确，但午夜也属于 "am",，中午属于 "pm"，所以在同一天，12:00 am ( 午夜 ) < 12:01
am，12:00 pm ( 中午 ) < 12:01 pm。
日期或时间格式字符串不是日历定义的一部分，因为在运行时，用户必须能够修改或重写它们。可以使用 DateFormat 格式化日期。字段操作
可以使用三种方法更改日历字段：set()、add() 和
roll()。
set(f, value) 将日历字段 f 更改为
value。此外，它设置了一个内部成员变量，以指示日历字段 f 已经被更改。尽管日历字段
f 是立即更改的，但是直到下次调用
get()、getTime()、getTimeInMillis()、add()
或 roll() 时才会重新计算日历的时间值（以毫秒为单位）。因此，多次调用 set()
不会触发多次不必要的计算。使用 set()
更改日历字段的结果是，其他日历字段也可能发生更改，这取决于日历字段、日历字段值和日历系统。此外，在重新计算日历字段之后，get(f)
没必要通过调用 set 方法返回 value 集合。具体细节是通过具体的日历类确定的。
示例：假定 GregorianCalendar 最初被设置为 1999 年 8 月 31 日。调用
set(Calendar.MONTH, Calendar.SEPTEMBER) 将该日期设置为 1999 年 9 月 31
日。如果随后调用 getTime()，那么这是解析 1999 年 10 月 1 日的一个暂时内部表示。但是，在调用
getTime() 之前调用 set(Calendar.DAY_OF_MONTH, 30) 会将该日期设置为
1999 年 9 月 30 日，因为在调用 set() 之后没有发生重新计算。
add(f, delta) 将 delta 添加到
f 字段中。这等同于调用 set(f, get(f) + delta)，但要带以下两个调整：
Add 规则 1。调用后 f 字段的值减去调用前 f 字段的值等于
delta，以字段 f
中发生的任何溢出为模。溢出发生在字段值超出其范围时，结果，下一个更大的字段会递增或递减，并将字段值调整回其范围内。
Add 规则 2。如果期望某一个更小的字段是不变的，但让它等于以前的值是不可能的，因为在字段
f
发生更改之后，或者在出现其他约束之后，比如时区偏移量发生更改，它的最大值和最小值也在发生更改，然后它的值被调整为尽量接近于所期望的值。更小的字段表示一个更小的时间单元。HOUR
是一个比 DAY_OF_MONTH
小的字段。对于不期望是不变字段的更小字段，无需进行任何调整。日历系统会确定期望不变的那些字段。
此外，与 set() 不同，add() 强迫日历系统立即重新计算日历的毫秒数和所有字段。
示例：假定 GregorianCalendar 最初被设置为 1999 年 8 月 31 日。调用
add(Calendar.MONTH, 13) 将日历设置为 2000 年 9 月 30 日。Add 规则
1 将 MONTH 字段设置为 September，因为向 August 添加 13 个月得出的就是下一年的
September。因为在 GregorianCalendar 中，DAY_OF_MONTH 不可能是 9
月 31 日，所以 add 规则 2 将 DAY_OF_MONTH 设置为
30，即最可能的值。尽管它是一个更小的字段，但不能根据规则 2 调整 DAY_OF_WEEK，因为在
GregorianCalendar 中的月份发生变化时，该值也需要发生变化。
roll(f, delta) 将 delta 添加到
f 字段中，但不更改更大的字段。这等同于调用 add(f, delta)，但要带以下调整：
Roll
规则。在完成调用后，更大的字段无变化。更大的字段表示一个更大的时间单元。DAY_OF_MONTH 是一个比
HOUR 大的字段。
示例：请参阅 GregorianCalendar.roll(int,
int)。使用模型。为了帮助理解 add() 和 roll()
的行为，假定有一个用户界面组件，它带有用于月、日、年和底层 GregorianCalendar
的递增或递减按钮。如果从界面上读取的日期为 1999 年 1 月 31 日，并且用户按下月份的递增按钮，那么应该得到什么？如果底层实现使用
set()，那么可以将该日期读为 1999 年 3 月 3 日。更好的结果是 1999 年 2 月 28
日。此外，如果用户再次按下月份的递增按钮，那么该日期应该读为 1999 年 3 月 31 日，而不是 1999 年 3 月 28 日。通过保存原始日期并使用
add() 或 roll()，根据是否会影响更大的字段，用户界面可以像大多数用户所期望的那样运行。
至于如何使用，可以参考JAVA API
㈢ java calendar Calendar.DATE Calendar.DAY_OF_MONTH Calendar.DAY_OF_YEAR 区别
cal.get(Calendar.HOUR_OF_DAY) 取的就是24时钟数
cal.get(Calendar.HOUR) 取的就是12时钟数
看一下它们的注释就清楚了。
/**
* Field number for <code>get</code> and <code>set</code> indicating the
* hour of the morning or afternoon. <code>HOUR</code> is used for the
* 12-hour clock (0 - 11). Noon and midnight are represented by 0, not by 12.
* E.g., at 10:04:15.250 PM the <code>HOUR</code> is 10.
*
* @see #AM_PM
* @see #HOUR_OF_DAY
*/
public final static int HOUR = 10;
/**
* Field number for <code>get</code> and <code>set</code> indicating the
* hour of the day. <code>HOUR_OF_DAY</code> is used for the 24-hour clock.
* E.g., at 10:04:15.250 PM the <code>HOUR_OF_DAY</code> is 22.
*
* @see #HOUR
*/
public final static int HOUR_OF_DAY = 11;
如果使用的是cal.get(Calendar.HOUR),可能通过cal.get(Calendar.AM_PM)的返回值来判断是上午还是下午，如果返回0，则是上午，如果返回1，则是下午。判断的时候，最好用类定义的常量来比较。
if(Calendar.AM==cal.get(Calendar.AM_PM)){
//上午
}else /*if(Calendar.PM==cal.get(Calendar.AM_PM))*/{
//下午
}
㈣ java如何判断时间的早中晚
很简单，你先通过System.current获取到当前的系统时间，这是一个long类型，new一个Date ，
Date有一个getHours的方法，然后通过小时来判断现在是早中晚，因为你说的早中晚没有确切的定义，而且SimpleDateFormat只提供AM/PM两个时间段，所以你只能得到现在是几点，然后在直接判断
㈤ 求java中Calendar类的用法例子（并附每条注释）
建议自己查api这样有助于你的理解。/**
* 获得当月第一天的日期时间 yyyy-MM-dd HH:mm:ss
* @param date
* @return
*/
public static String getMonthFirstDate(Date date) { if (date == null) {
date = new Date();
}
Calendar c = Calendar.getInstance();
c.setTime(date); /*
* 设定日期
*/
Integer minDateNum = c.getActualMinimum(Calendar.DAY_OF_MONTH);
c.set(Calendar.DAY_OF_MONTH, minDateNum); /*
* 设定小时、分钟、秒
*/
c.set(Calendar.HOUR, c.getActualMinimum(Calendar.HOUR));
c.set(Calendar.AM_PM, Calendar.AM);
c.set(Calendar.MINUTE, c.getActualMinimum(Calendar.MINUTE));
c.set(Calendar.SECOND, c.getActualMinimum(Calendar.SECOND)); return FORMATTOSEC24.format(c.getTime());
} /**
* 获得当月最有一天的日期时间 yyyy-MM-dd HH:mm:ss
* @param date
* @return
*/
public static String getMonthLastDate(Date date) { if (date == null) {
date = new Date();
}
Calendar c = Calendar.getInstance();
c.setTime(date); /*
* 设定日期
*/
Integer maxDateNum = c.getActualMaximum(Calendar.DAY_OF_MONTH);
c.set(Calendar.DAY_OF_MONTH, maxDateNum); /*
* 设定小时、分钟、秒
*/
c.set(Calendar.HOUR, c.getActualMaximum(Calendar.HOUR));
c.set(Calendar.AM_PM, Calendar.PM);
c.set(Calendar.MINUTE, c.getActualMaximum(Calendar.MINUTE));
c.set(Calendar.SECOND, c.getActualMaximum(Calendar.SECOND));
return FORMATTOSEC24.format(c.getTime());
}
/**
* 获得当月的第一天的日期
*
* @return
* @throws ParseException
*/
@SuppressWarnings("deprecation")
public static String getFristDayofMonth() throws Exception { Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.DATE, calendar
.getActualMinimum(Calendar.DAY_OF_MONTH));
return FORMATTODAY.format(calendar.getTime());
} /**
* 获得当月的最后一天的日期
*
* @return
* @throws ParseException
*/
public static String getLastDayOfMonth() throws Exception { Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.DATE, calendar
.getActualMaximum(Calendar.DAY_OF_MONTH));
return FORMATTODAY.format(calendar.getTime());
}
/**
* 返回两个日期之间的所有天数的日期
* @param begin
* @param end
* @return
*/
@SuppressWarnings("deprecation")
public static List<Date> getDate(Date begin , Date end){
List<Date> result = new ArrayList<Date>();
while(begin.before(end)){
result.add(new Date(begin.getYear(),begin.getMonth(),begin.getDate()));
begin.setDate(begin.getDate()+1);
}
result.add(end);
return result;
}
/**
* 根据两个日期获得之间所有的工作日期返回一个日期数组
* (工作日不包括星期六和星期日)
*
* @param begin 开始日期
* @param end 结束日期
* @return List<Date> 存放日期的数组
*/
public static List<Date> getDateWeek(Date begin,Date end){
if(null == begin){
begin = new Date();
}
if(null == end){
end = new Date();
}
List<Date> list = DateUtils.getDate(begin, end);
List<Date> result = new ArrayList<Date>();
Calendar calendar = Calendar.getInstance();
for(int i=0;i<list.size();i++){
calendar.setTime(list.get(i));
if (calendar.get(Calendar.DAY_OF_WEEK) == 1
|| calendar.get(Calendar.DAY_OF_WEEK) == 7) {
continue;
}else{
result.add(list.get(i));
}
}
return result;
} /**
* 根据日期类型的数组获得数组里所有日期的星期
* @param list 日期类型的数组
* @return 返回字符串数组
*/
public static List<String> getDateWeeks(List<Date> list){
List<String> result = new ArrayList<String>();
Calendar cal = Calendar.getInstance();
for (int i = 0; i < list.size(); i++) {
cal.setTime(list.get(i));
switch (cal.get(Calendar.DAY_OF_WEEK)) {
case 1:
result.add("星期天");
break;
case 2:
result.add("星期一");
break;
case 3:
result.add("星期二");
break;
case 4:
result.add("星期三");
break;
case 5:
result.add("星期四");
break;
case 6:
result.add("星期五");
break;
case 7:
result.add("星期六");
break;
default:
break;
} }
return result;
}
㈥ 求java的计时器代码，应该比较简单的，来看看吧。
packagetest;
importjava.util.*;
importjava.awt.*;
importjava.awt.event.*;
importjava.applet.*;
publicclassTest5extendsApplet{
privatefinalPanelpan=newPanel();
privatefinalLabeltime=newLabel();
privatefinalButtonbtnGo=newButton("开始");
privatefinalButtonbtnPouse=newButton("暂停");
privatefinalButtonbtnReset=newButton("复位");
=newStopwatchThread();
{
publicvoidactionPerformed(ActionEvente){
.go();
btnGo.setEnabled(false);
}
}
{
publicvoidactionPerformed(ActionEvente){
if(btnGo.isEnabled()){
return;
}
if(btnPouse.getLabel().equals("继续")){
swThread.go();
btnPouse.setLabel("暂停");
}elseif(btnPouse.getLabel().equals("暂停")){
swThread.noGo();
btnPouse.setLabel("继续");
}
}
}
{
publicvoidactionPerformed(ActionEvente){
swThread.reset();
btnGo.setEnabled(true);
btnGo.setLabel("开始");
btnPouse.setLabel("暂停");
}
}
{
privatebooleangoing=false;
privatelongprevElapsed=0;
privateDatestartDate=newDate();
privatelongelapsedTime(){
returnprevElapsed+
(going?newDate().getTime()-startDate.getTime():0);
}
privateStringmsToString(longtime){
System.out.println(time+""+((0*60+2)*1000+999));
if(((99*60+59)*1000+983)<=time&&((99*60+59)*1000+999)>=time){//((0*60+2)*1000+983)<=time&&((0*60+2)*1000+999)>=time
if(time%1000<990)
time+=2;
swThread.noGo();
}
Stringms,sec,min;
if(time%10>=5)
time+=5;
ms=Long.toString(time%1000);
while(ms.length()<3)
ms="0"+ms;
ms=ms.substring(0,ms.length()-1);
time/=1000;
sec=Long.toString(time%60);
if(sec.length()==1)sec="0"+sec;
time/=60;
min=Long.toString(time);
returnmin+":"+sec+"."+ms;
}
publicvoidgo(){
startDate=newDate();
going=true;
}
publicvoidnoGo(){
prevElapsed=elapsedTime();
going=false;
}
publicvoidreset(){
going=false;
prevElapsed=0;
}
publicvoidrun(){
while(true){
time.setText(msToString(elapsedTime()));
yield();
}
}
}
publicvoidinit(){
setLayout(newGridLayout(2,2));
setBackground(Color.lightGray);
setForeground(Color.black);
pan.setLayout(newGridLayout(3,2));
pan.add(newLabel("计时:"));
time.setForeground(Color.blue);
pan.add(time);
pan.add(btnGo);
pan.add(btnPouse);
pan.add(btnReset);
pan.add(newLabel());
add(pan);
btnGo.addActionListener(newbtnGoListener());
btnReset.addActionListener(newbtnResetListener());
btnPouse.addActionListener(newbtnPouseListener());
swThread.setDaemon(true);
swThread.start();
}
publicstaticvoidmain(String[]args){
Test5applet=newTest5();
FrameaFrame=newFrame("计时器");
aFrame.addWindowListener(newWindowAdapter(){
publicvoidwindowClosing(WindowEvente){
System.exit(0);
}
});
aFrame.add(applet,BorderLayout.CENTER);
aFrame.setSize(400,200);
applet.init();
applet.start();
aFrame.setVisible(true);
}
}
可以改变有注释的那个if语句里面的值来判断什么时候停止
㈦ java calendar 时间
1、计算某一月份的最大天数
Calendartime=Calendar.getInstance();
time.clear();
time.set(Calendar.YEAR,year);
time.set(Calendar.MONTH,i-1);//注意,Calendar对象默认一月为0
intday=time.getActualMaximum(Calendar.DAY_OF_MONTH);//本月份的天数
注：在使用set方法之前，必须先clear一下，否则很多信息会继承自系统当前时间。
2、Calendar和Date的转化
(1) Calendar转化为Date
Calendarcal=Calendar.getInstance();
Datedate=cal.getTime();
(2) Date转化为Calendar
Datedate=newDate();
Calendarcal=Calendar.getInstance();
cal.setTime(date);
3、格式化输出日期时间
Datedate=newDate();
SimpleDateFormatdf=newSimpleDateFormat("yyyy-MM-ddhh:mm:ss");
System.out.println(df.format(date));
4、计算一年中的第几星期
(1)计算某一天是一年中的第几星期
Calendarcal=Calendar.getInstance();
cal.set(Calendar.YEAR,2006);
cal.set(Calendar.MONTH,8);
cal.set(Calendar.DAY_OF_MONTH,3);
intweekno=cal.get(Calendar.WEEK_OF_YEAR);
(2)计算一年中的第几星期是几号
SimpleDateFormatdf=newSimpleDateFormat("yyyy-MM-dd");
Calendarcal=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()));
㈧ java中的Calendar如何使用
package pack.java.calendar.demo;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
public class CalendarDemo {
private static SimpleDateFormat date_format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
public static void main(String[] args) {
//获取calendar实例;
Calendar calendar = Calendar.getInstance();
//判断calendar是不是GregorianCalendar类的实例;
if(calendar instanceof GregorianCalendar){
System.out.println("属于GregorianCalendar类的实例!");
}
//从calendar对象中获得date对象，当前时间;
Date dates = calendar.getTime();
//格式化时间;
String date_str= date_format.format(dates);
System.out.println(date_str);
//设置月份05；代表日历的月份6月，因为月份从0开始。
calendar.set(Calendar.MONTH, 05);
int months = calendar.get(Calendar.MONTH);
System.out.println(months); //输出05;
//设置日期为2011-07-24 09：59:50
calendar.set(2011, 06, 24, 9, 59, 50);
String getDate = date_format.format(calendar.getTime());
System.out.println(getDate); //输出2011-07-24 09:59:50;
//比较日前大小;
if(new Date().getTime() > calendar.getTimeInMillis()){
System.out.println("当前日期在后!");
}else{
System.out.println("当前日期在前!");
}
//设置当前时间为:2011-07-24 11:06:00
calendar.setTime(new Date());
int year = calendar.get(Calendar.YEAR); //获取年;
int month = calendar.get(Calendar.MONTH); //获取月;
int date = calendar.get(Calendar.DATE); //获取天;
int hour = calendar.get(Calendar.HOUR); //获取小时;
int minute = calendar.get(Calendar.MINUTE); //获取分钟;
int second = calendar.get(Calendar.SECOND); //获取秒钟;
int hour_of_day = calendar.get(Calendar.HOUR_OF_DAY); //第几个小时，
int day_of_month = calendar.get(Calendar.DAY_OF_MONTH); //这天，在一个月内是第几天.
int day_of_week = calendar.get(Calendar.DAY_OF_WEEK); //这天，在一周内，是第几天.
int day_of_year = calendar.get(Calendar.DAY_OF_YEAR); //这天，在一年内，是第几天。
int week_of_year = calendar.get(Calendar.WEEK_OF_YEAR); //这周，在一年内是第几周;
int week_of_month = calendar.get(Calendar.WEEK_OF_MONTH);//这周，在这个月是第几周;以以星为标准；
int zone_offset = calendar.get(Calendar.ZONE_OFFSET); //获取时区;
int day_of_week_in_month = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH); //某月中第几周，按这个月1号算，1号起就是第1周，8号起就是第2周。以月份天数为标准
int r = calendar.get(Calendar.AM_PM);
if(r==calendar.AM){
System.out.println("现在是上午");
}
if(r==calendar.PM){
System.out.println("现在是下午");
}
System.out.println("==================================================");
System.out.println(year);
System.out.println(month);
System.out.println(date);
System.out.println(hour);
System.out.println(minute);
System.out.println(second);
System.out.println(hour_of_day);
System.out.println(day_of_month);
System.out.println(day_of_week);
System.out.println(day_of_year);
System.out.println(week_of_year);
System.out.println(week_of_month);
System.out.println(zone_offset);
System.out.println(day_of_week_in_month);
}
}
㈨ java calendar.month有什么用
package pack.java.calendar.demo;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
public class CalendarDemo {
private static SimpleDateFormat date_format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
public static void main(String[] args) {
//获取calendar实例;
Calendar calendar = Calendar.getInstance();
//判断calendar是不是GregorianCalendar类的实例;
if(calendar instanceof GregorianCalendar){
System.out.println("属于GregorianCalendar类的实例!");
}
//从calendar对象中获得date对象，当前时间;
Date dates = calendar.getTime();
//格式化时间;
String date_str= date_format.format(dates);
System.out.println(date_str);
//设置月份05；代表日历的月份6月，因为月份从0开始。
calendar.set(Calendar.MONTH, 05);
int months = calendar.get(Calendar.MONTH);
System.out.println(months); //输出05;
//设置日期为2011-07-24 09：59:50
calendar.set(2011, 06, 24, 9, 59, 50);
String getDate = date_format.format(calendar.getTime());
System.out.println(getDate); //输出2011-07-24 09:59:50;
//比较日前大小;
if(new Date().getTime() > calendar.getTimeInMillis()){
System.out.println("当前日期在后!");
}else{
System.out.println("当前日期在前!");
}
//设置当前时间为:2011-07-24 11:06:00
calendar.setTime(new Date());
int year = calendar.get(Calendar.YEAR); //获取年;
int month = calendar.get(Calendar.MONTH); //获取月;
int date = calendar.get(Calendar.DATE); //获取天;
int hour = calendar.get(Calendar.HOUR); //获取小时;
int minute = calendar.get(Calendar.MINUTE); //获取分钟;
int second = calendar.get(Calendar.SECOND); //获取秒钟;
int hour_of_day = calendar.get(Calendar.HOUR_OF_DAY); //第几个小时，
int day_of_month = calendar.get(Calendar.DAY_OF_MONTH); //这天，在一个月内是第几天.
int day_of_week = calendar.get(Calendar.DAY_OF_WEEK); //这天，在一周内，是第几天.
int day_of_year = calendar.get(Calendar.DAY_OF_YEAR); //这天，在一年内，是第几天。
int week_of_year = calendar.get(Calendar.WEEK_OF_YEAR); //这周，在一年内是第几周;
int week_of_month = calendar.get(Calendar.WEEK_OF_MONTH);//这周，在这个月是第几周;以以星为标准；
int zone_offset = calendar.get(Calendar.ZONE_OFFSET); //获取时区;
int day_of_week_in_month = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH); //某月中第几周，按这个月1号算，1号起就是第1周，8号起就是第2周。以月份天数为标准
int r = calendar.get(Calendar.AM_PM);
if(r==calendar.AM){
System.out.println("现在是上午");
}
if(r==calendar.PM){
System.out.println("现在是下午");
}
System.out.println("==================================================");
System.out.println(year);
System.out.println(month);
System.out.println(date);
System.out.println(hour);
System.out.println(minute);
System.out.println(second);
System.out.println(hour_of_day);
System.out.println(day_of_month);
System.out.println(day_of_week);
System.out.println(day_of_year);
System.out.println(week_of_year);
System.out.println(week_of_month);
System.out.println(zone_offset);
System.out.println(day_of_week_in_month);
}
}
㈩ Java用Calendar如何每秒取一次系统时间
用线程可以啊
import java.util.*;
public class test implements Runnable{
Thread th0 ;
//public void run(){}
public test(Thread th)
{
th0 = th;
th0= new Thread(this);
th0.start();
}
public void run()
{
try{
while(true)
{
if(Thread.currentThread()==th0){
Calendar cal = Calendar.getInstance();
int wd = cal.get(Calendar.DAY_OF_WEEK);
String x = "";
switch(wd){
case 1:x="星期日";break;
case 2:x="星期一";break;
case 3:x="星期二";break;
case 4:x="星期三";break;
case 5:x="星期四";break;
case 6:x="星期五";break;
case 7:x="星期六";break;
}
int y = cal.get(Calendar.YEAR);
int mon = cal.get(Calendar.MONTH)+1;
int d = cal.get(Calendar.DATE);
int h = cal.get(Calendar.HOUR);
int min = cal.get(Calendar.MINUTE);
int s = cal.get(Calendar.SECOND);
int ap = cal.get(Calendar.AM_PM);
if(ap==1)
h = h+12;
StringBuffer sb = new StringBuffer("日期："+y+"-"+((mon<=9)?"0"+mon:mon)+"-"+((d<=9)?"0"+d:d)+" 时间："+h+":"+((min<=9)?"0"+min:min)+":"+((s<=9)?"0"+s:s)+" "+x);
System.out.println(sb);
Thread.sleep(1000);
}
}
}catch(Exception ee){
ee.getStackTrace();
}
}
public static void main(String[] args) {
Thread th = new Thread();
test t = new test(th);
t.run();
}
}