1
import java.text.DecimalFormat;
2import java.util.Arrays;
3
4
/** *//**
5
* 时间计算工具类
6
*/
7public class Time 
{
8
9
/** *//**
10 * 时间字段常量，表示“秒”
11
*/
12 public final static int SECOND = 0;
13
14 /** *//**
15 * 时间字段常量，表示“分”
16 */
17 public final static int MINUTE = 1;
18
19 /** *//**
20 * 时间字段常量，表示“时”
21 */
22 public final static int HOUR = 2;
23
24 /** *//**
25 * 时间字段常量，表示“天”
26 */
27 public final static int DAY = 3;
28
29 /** *//**
30 * 各常量允许的最大值
31 */
32 private final int[] maxFields = { 59, 59, 23, Integer.MAX_VALUE - 1 };
33
34 /** *//**
35 * 各常量允许的最小值
36 */
37 private final int[] minFields = { 0, 0, 0, Integer.MIN_VALUE };
38
39 /** *//**
40 * 默认的字符串格式时间分隔符
41 */
42 private String timeSeparator = ":";
43
44 /** *//**
45 * 时间数据容器
46 */
47 private int[] fields = new int[4];
48
49 /** *//**
50 * 无参构造，将各字段置为 0
51 */
52 public Time() {
53 this(0, 0, 0, 0);
54 }
55
56 /** *//**
57 * 使用时、分构造一个时间
58 * @param hour 小时
59 * @param minute 分钟
60 */
61 public Time(int hour, int minute) {
62 this(0, hour, minute, 0);
63 }
64
65 /** *//**
66 * 使用时、分、秒构造一个时间
67 * @param hour 小时
68 * @param minute 分钟
69 * @param second 秒
70 */
71 public Time(int hour, int minute, int second) {
72 this(0, hour, minute, second);
73 }
74
75 /** *//**
76 * 使用一个字符串构造时间<br/>
77 * Time time = new Time("14:22:23");
78 * @param time 字符串格式的时间，默认采用“:”作为分隔符
79 */
80 public Time(String time) {
81 this(time, null);
82 }
83
84 /** *//**
85 * 使用天、时、分、秒构造时间，进行全字符的构造
86 * @param day 天
87 * @param hour 时
88 * @param minute 分
89 * @param second 秒
90 */
91 public Time(int day, int hour, int minute, int second) {
92 set(DAY, day);
93 set(HOUR, hour);
94 set(MINUTE, minute);
95 set(SECOND, second);
96 }
97
98 /** *//**
99 * 使用一个字符串构造时间，指定分隔符<br/>
100 * Time time = new Time("14-22-23", "-");
101 * @param time 字符串格式的时间
102 */
103 public Time(String time, String timeSeparator) {
104 if(timeSeparator != null) {
105 setTimeSeparator(timeSeparator);
106 }
107 String pattern = patternQuote(this.timeSeparator);
108 String matcher = new StringBuffer()
109 .append("\\d+?").append(pattern)
110 .append("\\d+?").append(pattern)
111 .append("\\d+?")
112 .toString();
113 if(!time.matches(matcher)) {
114 throw new IllegalArgumentException(time + ", time format error, HH"
115 + this.timeSeparator + "mm" + this.timeSeparator + "ss");
116 }
117 String[] times = time.split(pattern);
118 set(DAY, 0);
119 set(HOUR, Integer.parseInt(times[0]));
120 set(MINUTE, Integer.parseInt(times[1]));
121 set(SECOND, Integer.parseInt(times[2]));
122 }
123
124 /** *//**
125 * 设置时间字段的值
126 * @param field 时间字段常量
127 * @param value 时间字段的值
128 */
129 public void set(int field, int value) {
130 if(value < minFields[field]) {
131 throw new IllegalArgumentException(value +
132 ", time value must be positive.");
133 }
134 fields[field] = value % (maxFields[field] + 1);
135 // 进行进位计算
136 int carry = value / (maxFields[field] + 1);
137 if(carry > 0) {
138 int upFieldValue = get(field + 1);
139 set(field + 1, upFieldValue + carry);
140 }
141 }
142
143 /** *//**
144 * 获得时间字段的值
145 * @param field 时间字段常量
146 * @return 该时间字段的值
147 */
148 public int get(int field) {
149 if(field < 0 || field > fields.length - 1) {
150 throw new IllegalArgumentException(field + ", field value is error.");
151 }
152 return fields[field];
153 }
154
155 /** *//**
156 * 将时间进行“加”运算，即加上一个时间
157 * @param time 需要加的时间
158 * @return 运算后的时间
159 */
160 public Time addTime(Time time) {
161 Time result = new Time();
162 int up = 0; // 进位标志
163 for (int i = 0; i < fields.length; i++) {
164 int sum = fields[i] + time.fields[i] + up;
165 up = sum / (maxFields[i] + 1);
166 result.fields[i] = sum % (maxFields[i] + 1);
167 }
168 return result;
169 }
170
171 /** *//**
172 * 将时间进行“减”运算，即减去一个时间
173 * @param time 需要减的时间
174 * @return 运算后的时间
175 */
176 public Time subtractTime(Time time) {
177 Time result = new Time();
178 int down = 0; // 退位标志
179 for (int i = 0, k = fields.length - 1; i < k; i++) {
180 int difference = fields[i] + down;
181 if (difference >= time.fields[i]) {
182 difference -= time.fields[i];
183 down = 0;
184 } else {
185 difference += maxFields[i] + 1 - time.fields[i];
186 down = -1;
187 }
188 result.fields[i] = difference;
189 }
190 result.fields[DAY] = fields[DAY] - time.fields[DAY] + down;
191 return result;
192 }
193
194 /** *//**
195 * 获得时间字段的分隔符
196 * @return
197 */
198 public String getTimeSeparator() {
199 return timeSeparator;
200 }
201
202 /** *//**
203 * 设置时间字段的分隔符（用于字符串格式的时间）
204 * @param timeSeparator 分隔符字符串
205 */
206 public void setTimeSeparator(String timeSeparator) {
207 this.timeSeparator = timeSeparator;
208 }
209
210 /** *//**
211 * 正则表达式引用处理方法，源自 JDK @link java.util.regex.Pattern#quote(String)
212 */
213 private String patternQuote(String s) {
214 int slashEIndex = s.indexOf("\\E");
215 if (slashEIndex == -1)
216 return "\\Q" + s + "\\E";
217
218 StringBuilder sb = new StringBuilder(s.length() * 2);
219 sb.append("\\Q");
220 slashEIndex = 0;
221 int current = 0;
222 while ((slashEIndex = s.indexOf("\\E", current)) != -1) {
223 sb.append(s.substring(current, slashEIndex));
224 current = slashEIndex + 2;
225 sb.append("\\E\\\\E\\Q");
226 }
227 sb.append(s.substring(current, s.length()));
228 sb.append("\\E");
229 return sb.toString();
230 }
231
232 public String toString() {
233 DecimalFormat df = new DecimalFormat("00");
234 return new StringBuffer().append(fields[DAY]).append(", ")
235 .append(df.format(fields[HOUR])).append(timeSeparator)
236 .append(df.format(fields[MINUTE])).append(timeSeparator)
237 .append(df.format(fields[SECOND]))
238 .toString();
239 }
240
241 public int hashCode() {
242 final int PRIME = 31;
243 int result = 1;
244 result = PRIME * result + Arrays.hashCode(fields);
245 return result;
246 }
247
248 public boolean equals(Object obj) {
249 if (this == obj)
250 return true;
251 if (obj == null)
252 return false;
253 if (getClass() != obj.getClass())
254 return false;
255 final Time other = (Time) obj;
256 if (!Arrays.equals(fields, other.fields)) {
257 return false;
258 }
259 return true;
260 }
261}
262
posted on 2008-07-24 08:28
scea2009 阅读(561)
评论(1) 编辑 收藏 所属分类:
网摘