import javatextDecimalFormat;
import javautilArrays;
/**
* 时间计算工具类
*/
public class Time {
/**
* 时间字段常量表示秒
*/
public final static int SECOND = ;
/**
* 时间字段常量表示分
*/
public final static int MINUTE = ;
/**
* 时间字段常量表示时
*/
public final static int HOUR = ;
/**
* 时间字段常量表示天
*/
public final static int DAY = ;
/**
* 各常量允许的最大值
*/
private final int[] maxFields = { IntegerMAX_VALUE };
/**
* 各常量允许的最小值
*/
private final int[] minFields = { IntegerMIN_VALUE };
/**
* 默认的字符串格式时间分隔符
*/
private String timeSeparator = :;
/**
* 时间数据容器
*/
private int[] fields = new int[];
/**
* 无参构造将各字段置为
*/
public Time() {
this( );
}
/**
* 使用时分构造一个时间
* @param hour 小时
* @param minute 分钟
*/
public Time(int hour int minute) {
this( hour minute );
}
/**
* 使用时分秒构造一个时间
* @param hour 小时
* @param minute 分钟
* @param second 秒
*/
public Time(int hour int minute int second) {
this( hour minute second);
}
/**
* 使用一个字符串构造时间<br/>
* Time time = new Time(::);
* @param time 字符串格式的时间默认采用:作为分隔符
*/
public Time(String time) {
this(time null);
}
/**
* 使用天时分秒构造时间进行全字符的构造
* @param day 天
* @param hour 时
* @param minute 分
* @param second 秒
*/
public Time(int day int hour int minute int second) {
set(DAY day);
set(HOUR hour);
set(MINUTE minute);
set(SECOND second);
}
/**
* 使用一个字符串构造时间指定分隔符<br/>
* Time time = new Time( );
* @param time 字符串格式的时间
*/
public Time(String time String timeSeparator) {
if(timeSeparator != null) {
setTimeSeparator(timeSeparator);
}
String pattern = patternQuote(thistimeSeparator);
String matcher = new StringBuffer()
append(\\d+?)append(pattern)
append(\\d+?)append(pattern)
append(\\d+?)
toString();
if(!timematches(matcher)) {
throw new IllegalArgumentException(time + time format error HH
+ thistimeSeparator + mm + thistimeSeparator + ss);
}
String[] times = timesplit(pattern);
set(DAY );
set(HOUR IntegerparseInt(times[]));
set(MINUTE IntegerparseInt(times[]));
set(SECOND IntegerparseInt(times[]));
}
/**
* 设置时间字段的值
* @param field 时间字段常量
* @param value 时间字段的值
*/
public void set(int field int value) {
if(value < minFields[field]) {
throw new IllegalArgumentException(value +
time value must be positive);
}
fields[field] = value % (maxFields[field] + );
// 进行进位计算
int carry = value / (maxFields[field] + );
if(carry > ) {
int upFieldValue = get(field + );
set(field + upFieldValue + carry);
}
}
/**
* 获得时间字段的值
* @param field 时间字段常量
* @return 该时间字段的值
*/
public int get(int field) {
if(field < || field > fieldslength ) {
throw new IllegalArgumentException(field + field value is error);
}
return fields[field];
}
/**
* 将时间进行加运算即加上一个时间
* @param time 需要加的时间
* @return 运算后的时间
*/
public Time addTime(Time time) {
Time result = new Time();
int up = ; // 进位标志
for (int i = ; i < fieldslength; i++) {
int sum = fields[i] + timefields[i] + up;
up = sum / (maxFields[i] + );
resultfields[i] = sum % (maxFields[i] + );
}
return result;
}
/**
* 将时间进行减运算即减去一个时间
* @param time 需要减的时间
* @return 运算后的时间
*/
public Time subtractTime(Time time) {
Time result = new Time();
int down = ; // 退位标志
for (int i = k = fieldslength ; i < k; i++) {
int difference = fields[i] + down;
if (difference >= timefields[i]) {
difference = timefields[i];
down = ;
} else {
difference += maxFields[i] + timefields[i];
down = ;
}
resultfields[i] = difference;
}
resultfields[DAY] = fields[DAY] timefields[DAY] + down;
return result;
}
/**
* 获得时间字段的分隔符
* @return
*/
public String getTimeSeparator() {
return timeSeparator;
}
/**
* 设置时间字段的分隔符（用于字符串格式的时间）
* @param timeSeparator 分隔符字符串
*/
public void setTimeSeparator(String timeSeparator) {
thistimeSeparator = timeSeparator;
}
/**
* 正则表达式引用处理方法源自 JDK @link javautilregexPattern#quote(String)
*/
private String patternQuote(String s) {
int slashEIndex = sindexOf(\\E);
if (slashEIndex == )
return \\Q + s + \\E;
StringBuilder sb = new StringBuilder(slength() * );
sbappend(\\Q);
slashEIndex = ;
int current = ;
while ((slashEIndex = sindexOf(\\E current)) != ) {
sbappend(ssubstring(current slashEIndex));
current = slashEIndex + ;
sbappend(\\E\\\\E\\Q);
}
sbappend(ssubstring(current slength()));
sbappend(\\E);
return sbtoString();
}
public String toString() {
DecimalFormat df = new DecimalFormat();
return new StringBuffer()append(fields[DAY])append( )
append(dfformat(fields[HOUR]))append(timeSeparator)
append(dfformat(fields[MINUTE]))append(timeSeparator)
append(dfformat(fields[SECOND]))
toString();
}
public int hashCode() {
final int PRIME = ;
int result = ;
result = PRIME * result + ArrayshashCode(fields);
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != objgetClass())
return false;
final Time other = (Time) obj;
if (!Arraysequals(fields otherfields)) {
return false;
}
return true;
}
}
