1 package timeTools;
  2 
  3 import java.text.ParseException;
  4 import java.text.SimpleDateFormat;
  5 import java.util.Date;
  6 
  7 /**
  8  * 日期时间工具类
  9  * 
 10  * @author 温度
 11  *
 12  */
 13 
 14 public class DataUtils {
 15 
 16     /**
 17      * 获取当前时间，以"yyyy-MM-dd HH:mm:ss"格式返回字符串类型值
 18      * 
 19      * @return
 20      */
 21     public static String getCurrentTime() {
 22 
 23         // Date dt= new Date();
 24         // SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 25         // String s=sdf.format(dt);
 26         // return s;
 27 
 28         return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
 29 
 30     }
 31 
 32     /**
 33      * 以指定的时间格式获取当前时间的字符串类型
 34      * 
 35      * @param s
 36      *            格式为 "yyyy*MM*dd HH*mm*ss"，其中*可用其他字符匹配
 37      * @return
 38      */
 39     public static String getCurrentTime(String s) {
 40 
 41         return new SimpleDateFormat(s).format(new Date());
 42 
 43     }
 44 
 45     /**
 46      * 获取当前时间的毫秒值
 47      * 
 48      * @return
 49      */
 50     public static long getMilliSecond() {
 51         return new Date().getTime();
 52     }
 53 
 54     /**
 55      * 获取给定时间的毫秒值
 56      * 
 57      * @param s
 58      *            格式为"yyyy-MM-dd HH:mm:ss"
 59      * @return
 60      */
 61     public static long getMilliSecond(String s) {
 62         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 63         Date d;
 64         long l = 0;
 65         try {
 66             d = sdf.parse(s);
 67             l = d.getTime();
 68         } catch (ParseException e) {
 69             // TODO Auto-generated catch block
 70             e.printStackTrace();
 71             System.out.println("时间格式不对！");
 72         }
 73         return l;
 74     }
 75 
 76     /**
 77      * 获取给定的两个时间之间的差值，单位为毫秒。时间格式为"yyyy-MM-dd HH:mm:ss"
 78      * 
 79      * @param s1
 80      *            第一个时间参数
 81      * @param s2
 82      *            第二个时间参数
 83      * @return 返回值为负，说明第一个参数时间小于第二个参数时间。返回值为正，说明第一个参数时间大于第二个参数时间。
 84      */
 85     public static long getMilliSecond(String s1, String s2) {
 86         return getMilliSecond(s1) - getMilliSecond(s2);
 87     }
 88 
 89     /**
 90      * 获取当前时间的秒值
 91      * 
 92      * @return
 93      */
 94     public static long getSecond() {
 95         return (new Date().getTime()) / 1000;
 96     }
 97 
 98     /**
 99      * 获取给定时间的秒值
100      * 
101      * @param s
102      *            格式为"yyyy-MM-dd HH:mm:ss"
103      * @return
104      */
105     public static long getSecond(String s) {
106         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
107         Date d;
108         long l = 0;
109         try {
110             d = sdf.parse(s);
111             l = d.getTime();
112         } catch (ParseException e) {
113             // TODO Auto-generated catch block
114             e.printStackTrace();
115             System.out.println("时间格式不对！");
116         }
117         return l / 1000;
118     }
119 
120     /**
121      * 获取给定的两个时间之间的差值，单位为秒。时间格式为"yyyy-MM-dd HH:mm:ss"
122      * 
123      * @param s1
124      *            第一个时间参数
125      * @param s2
126      *            第二个时间参数
127      * @return 返回值为负，说明第一个参数时间小于第二个参数时间。返回值为正，说明第一个参数时间大于第二个参数时间。
128      * 
129      */
130     public static long getSecond(String s1, String s2) {
131         return (getMilliSecond(s1) - getMilliSecond(s2)) / 1000;
132     }
133 
134     /**
135      * 根据毫秒时间获取时长，返回值格式"h小时m分s秒"
136      * 
137      * @param s
138      * @return
139      */
140     public static String getDurationByMilliSecond(long ms) {
141         long s = ms / 1000;
142         long tmp = 0;
143         StringBuffer sb = new StringBuffer();
144         sb.insert(0, "秒");
145         if (s >= 60) {
146             tmp = s % 60;
147             sb.insert(0, tmp);
148             tmp = s / 60;
149             if (tmp >= 60) {
150                 s = tmp % 60;
151                 sb.insert(0, "分");
152                 sb.insert(0, s);
153                 s = tmp / 60;
154                 if (s >= 24) {
155                     tmp = s % 24;
156                     sb.insert(0, "小时");
157                     sb.insert(0, tmp);
158                     tmp = s / 24;
159                     sb.insert(0, "天");
160                     sb.insert(0, tmp);
161                 } else {
162                     sb.insert(0, "小时");
163                     sb.insert(0, s);
164                 }
165 
166             } else {
167                 sb.insert(0, "分");
168                 sb.insert(0, tmp);
169             }
170         } else {
171             sb.insert(0, s);
172         }
173         String dt = sb.toString();
174         return dt;
175     }
176 
177     /**
178      * 根据秒时间获取时长，返回值格式"h小时m分s秒"
179      * 
180      * @param s
181      * @return
182      */
183     public static String getDurationBySecond(long s) {
184         long tmp = 0;
185         StringBuffer sb = new StringBuffer();
186         sb.insert(0, "秒");
187         if (s >= 60) {
188             tmp = s % 60;
189             sb.insert(0, tmp);
190             tmp = s / 60;
191             if (tmp >= 60) {
192                 s = tmp % 60;
193                 sb.insert(0, "分");
194                 sb.insert(0, s);
195                 s = tmp / 60;
196                 if (s >= 24) {
197                     tmp = s % 24;
198                     sb.insert(0, "小时");
199                     sb.insert(0, tmp);
200                     tmp = s / 24;
201                     sb.insert(0, "天");
202                     sb.insert(0, tmp);
203                 } else {
204                     sb.insert(0, "小时");
205                     sb.insert(0, s);
206                 }
207 
208             } else {
209                 sb.insert(0, "分");
210                 sb.insert(0, tmp);
211             }
212         } else {
213             sb.insert(0, s);
214         }
215         String dt = sb.toString();
216         return dt;
217     }
218 
219 }