java中的时间操作

java中的时间操作不外乎这四种情况：

1、获取当前时间

2、获取某个时间的某种格式

3、设置时间

4、时间的运算

好，下面就针对这三种情况，一个一个搞定。



一、获取当前时间



有两种方式可以获得，第一种，使用Date类。

j2SE的包里有两个Date类，一个是java.sql.Date,一个是java.util.Date

这里，要使用java.util.Date。获取当前时间的代码如下

Date date = new Date();

date.getTime();

还有一种方式，使用System.currentTimeMillis();



这两种方式获得的结果是一样的，都是得到一个当前的时间的long型的时间的毫秒值，这个值实际上是当前时间值与1970年一月一号零时零分零秒相差的毫秒数。

当前的时间得到了，但实际的应用中最后往往不是要用这个long型的东西，用户希望得到的往往是一个时间的字符串，比如“2006年6月18号”，或“2006-06-18”，老外可能希望得到的是“06-18-2006”，诸如此类等等。这就是下一个要解决的问题



二、获取某个时间的某种格式



获取时间的格式，需要用到一个专门用于时间格式的类java.text.SimpleDateFormat。

首先，定义一个SimpleDateFormat变量

SimpleDateFormat sdf = new SimpleDateFormat("",Locale.SIMPLIFIED_CHINESE);

这个构造函数的定义如下：

SimpleDateFormat(String pattern, Locale locale)

第一个参数pattern，我们后面再解释，这里我们使用一个"",第二个参数，是用来设置时区的，这里用到了java.util.Locale 这个类，这个类了面定义了很多静态变量，直接拿过来用就OK，我们把时区设置为Locale.SIMPLIFIED_CHINESE，只看名字，这个静态变量的意义已经很清楚了。



接下来我们使用这个SimpleDateFormat把当前时间格式化为一个如下格式的时间字符串“XXXX年XX月XX日_XX时XX分XX秒”，代码：

sdf.applyPattern("yyyy年MM月dd日_HH时mm分ss秒");

String timeStr = sdf.format(new Date());



获取时间格式的函数是format，这个函数的参数是java.util.Date对象，这个没有什么花头。

要说明一下的是这个pattern，所谓的模式。这里，yyyy,MM,dd等，这就是模式。

我们可以在SimpleDateFormat的构造函数中指定模式，比如

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd",Locale.SIMPLIFIED_CHINESE);

也可以获取时间格式的时候使用applyPattern函数临时指定，上面的例子就是这样。

什么字符代表什么，这是j2se约定好的，设置模式的时候，我们可以使用约定好的字符加上任何我们想要的字符串。

j2se对字符所代表的模式的约定列表如下：





Letter Date or Time Component Presentation
G Era designator Text
y Year Year
M Month in year Month
w Week in year Number
W Week in month Number
D Day in year Number
d Day in month Number
F Day of week in month Number
E Day in week Text
a Am/pm marker Text
H Hour in day (0-23) Number
k Hour in day (1-24) Number
K Hour in am/pm (0-11) Number
h Hour in am/pm (1-12) Number
m Minute in hour Number
s Second in minute Number
S Millisecond Number
z Time zone General time zone
Z Time zone RFC 822 time zone


三、设置时间



现实中的时间是由不得我们这些凡夫俗子的，如来老头来了也许还有点可能，但在程序里我们可以变得神通广大。设置时间最典型的应用就是定时任务，我们设置一个时间，到时执行某项任务。

但这里我们主要不是为了解决这个定时任务的问题，我们是为了搞清楚怎么设置时间。关于定时任务，在后面再讨论怎么做。

所谓的设置时间，其实就是我们把一个我们能看懂的时间的显性的值（数字、字符串等），转化成程序能看得懂的（Date类，long型的毫秒值等）告诉它。

最直接的思路是，new一个Date类，使用它的某个方法，传进我们指定的数字或字符串类型的值，设置它的时间。

那就先来看一下Date这个类，这个类里面有好多方法，什么setYear，setMonth的，看起来真是太好了，传个int值进去就搞定了。

可惜，这些看起来非常good的方法从JDK1.1以后就不用了，只有一个

setTime(long time)方法还勉强可以用，但是看看这个方法的参数吧，TNND，是个long，2006年7月1号的long值是什么？鬼才知道。

所以这个方法不可取，刚才也提到Date类里有很多方法从JDK1.1以后就不用了，其中就有什么setYear,setMonth这样的方法。这些方法不是JDK里面没有了，而是被Calendar类里面的方法给取代了。（为什么取代？这个问题去问开发JDK的那帮人好了）



其实，还是用上面说到的SimpleDateFormat就可以搞定，代码,三行：

SimpleDateFormat sdf = new SimpleDateFormat("",Locale.SIMPLIFIED_CHINESE);

sdf.applyPattern("yyyy年MM月dd日_HH时mm分ss秒");

Date date = sdf.parse("2006年07月01日_14时00分00秒");



一看就懂了吧，第一行是声明对象的，如果前面已经声明了，这一行也省了，第二行是设置模式（pattern）的，关于这个模式，前面已经解释的很详细了，没有什么好说的。第三行，就是要设置的时间跟模式对应的字符串。第三行就返回了我们要得到的Date类型。（啰嗦了这么半天，才啰嗦出这么三行代码:)）



Ok，这个问题搞定，继续下一个。



四、时间的运算



现在我们要开始用Calendar了，简单介绍一下先，JDK的文档里说，Calendar主要是用来对Date对象和Integer对象做转换的（这样看起来上面那个问题我们也可以使用Calendar）。事实上，实际的开发应用中，Calendar往往用来对时间进行操作，比如说设置个时间啊，对时间进行个对比运算什么滴。

举个例子，已知两个Date型时间对象，date1、date2，我们需要计算出这两个时间之间相差几个小时，怎么做。

一种思路：得到这两个时间对象的long值，然后相减，这就得到了他们相差的毫秒值，然后再根据这个毫秒值算出对应的小时。代码如下：

int distance = (int)((date2.getTime() - date1.getTime())/1000/60/60);

简单解释一下:

date2.getTime() - date1.getTime()得到相应的long型时间值并相减，得到相差的毫秒值，再除1000，得到秒，再除60，得到分，再除60，得到小时。呵呵，我真是够啰嗦！从毫秒转化成秒的时候，我在google上搜索了半天才确定一秒等于1000毫秒，真是白痴:)。



按上面的方式，似乎问题已经解决了。但是，结果得到的小时值很大可能是个小数，而且，有可能是个小数位很长的小数，这样就要考虑精确位的问题，上面那行代码就不够用了；还有一个比较关键的问题是，根据我们的习惯，往往可能是希望知道他们相差几小时几分几秒，而不是几点几个小时，也可能我们只想知道他们差几个小时，至于小时之外还差几分几秒，我们不感兴趣，这样，上面那行代码也不够用了。

如果要解决这种方式带来的后续的这两个问题，还要写更多的代码，麻烦死了，我是个懒人，不想费那脑子，我需要找一种更直接，更简单的方式来解决。



终于轮到Calendar出场了，对上面的问题，解决的代码如下：

Calendar ca1 = Calendar.getInstance();

Calendar ca2 = Calendar.getInstance();

ca1.setTime(date1);

ca2.setTime(date2);

int distanceHour = ca2.get(Calendar.HOUR_OF_DAY) - ca1.get(Calendar.HOUR_OF_DAY);



虽然有五行代码，但这五行代码根本都不用费我的脑子考虑，不像前面的，还要考虑转化什么的，而且这五行代码完全可以像前面一样用一行代码搞定。

这样就得到了这两个时间相差的小时的值，我可以保证绝对是个整数，因为这个distanceHour只是这两个时间对象的小时数之差，而不考虑它们的分秒的差，如果想得它们差几分，代码如下

int distanceMin = ca2.get(Calendar.MINUTE) - ca1.get(Calendar.MINUTE);



解释一下上面的代码:

Calendar ca1 = Calendar.getInstance();

得到一个Calendar对象，Calendar不提供公用的构造函数，不能new。这行代码得到的新对象的时间设置为当前时间。

ca1.setTime(date1);

把Calendar对象的时间设置为date1的时间。

ca1.get(Calendar.HOUR_OF_DAY)

获取Calendar对象的小时值，这里得到的是24小时制的。这个get方法参数是int型的，用来指定想要获取的域（field），就是什么年啊月啊周啊小时的东西。参数需要用Calendar类定义的常量，每个常量对应一个域（field），这些常量的含义都很明显（都可以顾名思义出来），用的时候在IDE环境里直接打点选择就可以。

这个get方法用起来很灵活，比如得到一天的int值，我们可以得到这一天一个月里的第几天，也可以得到一周里的第几天，也可以得到一年里的第几天，只要传进对应的参数就OK了。

有一点需要注意的是，按照我们的习惯，周一是一周的第一天，而老外的习惯是周日才是第一天，他们是先做完礼拜才开始这一周的。所以如果今天是周一，我们使用ca1.get(Calendar.DAY_OF_WEEK)时得到的值是2。





前面提到，Canlendar也可以用来设置时间，代码如下

Calendar ca = Calendar.getInstance();

ca.set(Calendar.YEAR, 2006);

ca.set(Calendar.MONTH, 7);

ca.set(Calendar.DAY_OF_MONTH, 1);

ca.set(Calendar.HOUR_OF_DAY, 14);

ca.set(Calendar.MINUTE,0);

ca.set(Calendar.SECOND, 0);

Date date = ca.getTime();

这跟前面第三个问题中的那三行代码的结果基本上是一样的，为什么说基本上？因为毫秒值不一样，ca的毫秒值是当前时间的毫秒值，而我们没有进行设置，所以仍然是当前的毫秒值。用那三行代码，还是用这几行，任君选择。

java.util.*;
import java.text.*;
import java.util.Calendar;
public class VeDate {
/**
* 获取现在时间
*
* @return 返回时间类型 yyyy-MM-dd HH:mm:ss
*/
public static Date getNowDate() {
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateString = formatter.format(currentTime);
ParsePosition pos = new ParsePosition(8);
Date currentTime_2 = formatter.parse(dateString, pos);
return currentTime_2;
}
/**
* 获取现在时间
*
* @return返回短时间格式 yyyy-MM-dd
*/
public static Date getNowDateShort() {
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
String dateString = formatter.format(currentTime);
ParsePosition pos = new ParsePosition(8);
Date currentTime_2 = formatter.parse(dateString, pos);
return currentTime_2;
}
/**
* 获取现在时间
*
* @return返回字符串格式 yyyy-MM-dd HH:mm:ss
*/
public static String getStringDate() {
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateString = formatter.format(currentTime);
return dateString;
}
/**
* 获取现在时间
*
* @return 返回短时间字符串格式yyyy-MM-dd
*/
public static String getStringDateShort() {
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
String dateString = formatter.format(currentTime);
return dateString;
}
/**
* 获取时间 小时:分;秒 HH:mm:ss
*
* @return
*/
public static String getTimeShort() {
SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
Date currentTime = new Date();
String dateString = formatter.format(currentTime);
return dateString;
}
/**
* 将长时间格式字符串转换为时间 yyyy-MM-dd HH:mm:ss
*
* @param strDate
* @return
*/
public static Date strToDateLong(String strDate) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
ParsePosition pos = new ParsePosition(0);
Date strtodate = formatter.parse(strDate, pos);
return strtodate;
}
/**
* 将长时间格式时间转换为字符串 yyyy-MM-dd HH:mm:ss
*
* @param dateDate
* @return
*/
public static String dateToStrLong(java.util.Date dateDate) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateString = formatter.format(dateDate);
return dateString;
}
/**
* 将短时间格式时间转换为字符串 yyyy-MM-dd
*
* @param dateDate
* @param k
* @return
*/
public static String dateToStr(java.util.Date dateDate) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
String dateString = formatter.format(dateDate);
return dateString;
}
/**
* 将短时间格式字符串转换为时间 yyyy-MM-dd
*
* @param strDate
* @return
*/
public static Date strToDate(String strDate) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
ParsePosition pos = new ParsePosition(0);
Date strtodate = formatter.parse(strDate, pos);
return strtodate;
}
/**
* 得到现在时间
*
* @return
*/
public static Date getNow() {
Date currentTime = new Date();
return currentTime;
}
/**
* 提取一个月中的最后一天
*
* @param day
* @return
*/
public static Date getLastDate(long day) {
Date date = new Date();
long date_3_hm = date.getTime() - 3600000 * 34 * day;
Date date_3_hm_date = new Date(date_3_hm);
return date_3_hm_date;
}

/**
* 得到现在时间
*
* @return 字符串 yyyyMMdd HHmmss
*/
public static String getStringToday() {
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd HHmmss");
String dateString = formatter.format(currentTime);
return dateString;
}
// 计算当月最后一天,返回字符串
public String getDefaultDay(){
String str = "";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

Calendar lastDate = Calendar.getInstance();
lastDate.set(Calendar.DATE,1);//设为当前月的1号
lastDate.add(Calendar.MONTH,1);//加一个月，变为下月的1号
lastDate.add(Calendar.DATE,-1);//减去一天，变为当月最后一天

str=sdf.format(lastDate.getTime());
return str;
}
/**
* 得到现在小时
*/
public static String getHour() {
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateString = formatter.format(currentTime);
String hour;
hour = dateString.substring(11, 13);
return hour;
}
/**
* 得到现在分钟
*
* @return
*/
public static String getTime() {
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateString = formatter.format(currentTime);
String min;
min = dateString.substring(14, 16);
return min;
}
/**
* 根据用户传入的时间表示格式，返回当前时间的格式 如果是yyyyMMdd，注意字母y不能大写。
*
* @param sformat
* yyyyMMddhhmmss
* @return
*/
public static String getUserDate(String sformat) {
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat(sformat);
String dateString = formatter.format(currentTime);
return dateString;
}
/**
* 二个小时时间间的差值,必须保证二个时间都是"HH:MM"的格式，返回字符型的分钟
*/
public static String getTwoHour(String st1, String st2) {
String[] kk = null;
String[] jj = null;
kk = st1.split(":");
jj = st2.split(":");
if (Integer.parseInt(kk[0]) < Integer.parseInt(jj[0]))
return "0";
else {
double y = Double.parseDouble(kk[0]) + Double.parseDouble(kk[1]) / 60;
double u = Double.parseDouble(jj[0]) + Double.parseDouble(jj[1]) / 60;
if ((y - u) > 0)
return y - u + "";
else
return "0";
}
}
/**
* 得到二个日期间的间隔天数
*/
public static String getTwoDay(String sj1, String sj2) {
SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
long day = 0;
try {
java.util.Date date = myFormatter.parse(sj1);
java.util.Date mydate = myFormatter.parse(sj2);
day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
} catch (Exception e) {
return "";
}
return day + "";
}
/**
* 时间前推或后推分钟,其中JJ表示分钟.
*/
public static String getPreTime(String sj1, String jj) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String mydate1 = "";
try {
Date date1 = format.parse(sj1);
long Time = (date1.getTime() / 1000) + Integer.parseInt(jj) * 60;
date1.setTime(Time * 1000);
mydate1 = format.format(date1);
} catch (Exception e) {
}
return mydate1;
}
/**
* 得到一个时间延后或前移几天的时间,nowdate为时间,delay为前移或后延的天数
*/
public static String getNextDay(String nowdate, String delay) {
try{
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
String mdate = "";
Date d = strToDate(nowdate);
long myTime = (d.getTime() / 1000) + Integer.parseInt(delay) * 24 * 60 * 60;
d.setTime(myTime * 1000);
mdate = format.format(d);
return mdate;
}catch(Exception e){
return "";
}
}
/**
* 判断是否润年
*
* @param ddate
* @return
*/
public static boolean isLeapYear(String ddate) {
/**
* 详细设计： 1.被400整除是闰年，否则： 2.不能被4整除则不是闰年 3.能被4整除同时不能被100整除则是闰年
* 3.能被4整除同时能被100整除则不是闰年
*/
Date d = strToDate(ddate);
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(d);
int year = gc.get(Calendar.YEAR);
if ((year % 400) == 0)
return true;
else if ((year % 4) == 0) {
if ((year % 100) == 0)
return false;
else
return true;
} else
return false;
}
/**
* 返回美国时间格式 26 Apr 2006
*
* @param str
* @return
*/
public static String getEDate(String str) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
ParsePosition pos = new ParsePosition(0);
Date strtodate = formatter.parse(str, pos);
String j = strtodate.toString();
String[] k = j.split(" ");
return k[2] + k[1].toUpperCase() + k[5].substring(2, 4);
}
/**
* 获取一个月的最后一天
*
* @param dat
* @return
*/
public static String getEndDateOfMonth(String dat) {// yyyy-MM-dd
String str = dat.substring(0, 8);
String month = dat.substring(5, 7);
int mon = Integer.parseInt(month);
if (mon == 1 || mon == 3 || mon == 5 || mon == 7 || mon == 8 || mon == 10 || mon == 12) {
str += "31";
} else if (mon == 4 || mon == 6 || mon == 9 || mon == 11) {
str += "30";
} else {
if (isLeapYear(dat)) {
str += "29";
} else {
str += "28";
}
}
return str;
}
/**
* 判断二个时间是否在同一个周
*
* @param date1
* @param date2
* @return
*/
public static boolean isSameWeekDates(Date date1, Date date2) {
Calendar cal1 = Calendar.getInstance();
Calendar cal2 = Calendar.getInstance();
cal1.setTime(date1);
cal2.setTime(date2);
int subYear = cal1.get(Calendar.YEAR) - cal2.get(Calendar.YEAR);
if (0 == subYear) {
if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
return true;
} else if (1 == subYear && 11 == cal2.get(Calendar.MONTH)) {
// 如果12月的最后一周横跨来年第一周的话则最后一周即算做来年的第一周
if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
return true;
} else if (-1 == subYear && 11 == cal1.get(Calendar.MONTH)) {
if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
return true;
}
return false;
}
/**
* 产生周序列,即得到当前时间所在的年度是第几周
*
* @return
*/
public static String getSeqWeek() {
Calendar c = Calendar.getInstance(Locale.CHINA);
String week = Integer.toString(c.get(Calendar.WEEK_OF_YEAR));
if (week.length() == 1)
week = "0" + week;
String year = Integer.toString(c.get(Calendar.YEAR));
return year + week;
}
=======================================================
# import java.text.DateFormat;
# import java.text.SimpleDateFormat;
# import java.text.ParseException;
# import java.util.Calendar;
# import java.util.Date;
#
#
# DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
# Date date = null;
# String str = null;
#
# // String转Date
# str = "2007-1-18";
# try {
# date = format.parse(str); // Thu Jan 18 00:00:00 CST 2007
# } catch (ParseException e) {
# e.printStackTrace();
# }
#
# date = java.sql.Date.valueOf(str); // 只保留日期部分，返回的是java.sql.Date 2007-01-18
#
# // Date转String
# date = new Date(); // Thu Jan 18 21:35:01 CST 2007
# /*Calendar cal = Calendar.getInstance();
# date = new Date(cal.getTimeInMillis());*/
# str = format.format(date); // 2007-01-18
#
# format = DateFormat.getDateInstance(DateFormat.SHORT);
# str = format.format(date); // 07-1-18
#
# format = DateFormat.getDateInstance(DateFormat.MEDIUM);
# str = format.format(date); // 2007-1-18
#
# format = DateFormat.getDateInstance(DateFormat.FULL);
# str = format.format(date); // 2007年1月18日 星期四