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,; 
       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日 星期四