java长整形转换为时分秒_java如何将长整型的秒数转换成时分秒

importjava.util.Arrays;

/*** 时间计算工具类**@authorfrankiegao123*/public classTime {

/*** 时间字段常量，表示“秒”*/public final static intSECOND= 0;

/*** 时间字段常量，表示“分”*/public final static intMINUTE= 1;

/*** 时间字段常量，表示“时”*/public final static intHOUR= 2;

/*** 时间字段常量，表示“天”*/public final static intDAY= 3;

/*** 各常量允许的最大值*/private final int[] maxFields= { 59, 59, 23, Integer.MAX_VALUE- 1};

/*** 各常量允许的最小值*/private final int[] minFields= { 0, 0, 0, Integer.MIN_VALUE};

/*** 默认的字符串格式时间分隔符*/privateString timeSeparator= ":";

/*** 时间数据容器*/private int[] fields= new int[4];

/*** 无参构造，将各字段置为 0*/publicTime() {

this(0, 0, 0, 0);

}

/*** 使用时、分构造一个时间*@paramhour小时*@paramminute分钟*/publicTime(inthour, intminute) {

this(0, hour, minute, 0);

}

/*** 使用时、分、秒构造一个时间*@paramhour小时*@paramminute分钟*@paramsecond秒*/publicTime(inthour, intminute, intsecond) {

this(0, hour, minute, second);

}

/*** 使用一个字符串构造时间
* Time time = new Time("14:22:23");*@paramtime字符串格式的时间，默认采用“:”作为分隔符*/publicTime(String time) {

this(time, null);

}

/*** 使用天、时、分、秒构造时间，进行全字符的构造*@paramday天*@paramhour时*@paramminute分*@paramsecond秒*/publicTime(intday, inthour, intminute, intsecond) {

initialize(day, hour, minute, second);

}

/*** 使用一个字符串构造时间，指定分隔符
* Time time = new Time("14-22-23", "-");*@paramtime字符串格式的时间*/publicTime(String time, String timeSeparator) {

if(timeSeparator != null) {

setTimeSeparator(timeSeparator);

}

parseTime(time);

}

/*** 设置时间字段的值*@paramfield时间字段常量*@paramvalue时间字段的值*/public voidset(intfield, intvalue) {

if(value < minFields[field]) {

throw newIllegalArgumentException(value + ", time value must be positive.");

}

fields[field] = value % (maxFields[field] + 1);

// 进行进位计算intcarry = value / (maxFields[field] + 1);

if(carry > 0) {

intupFieldValue = get(field + 1);

set(field + 1, upFieldValue + carry);

}

}

/*** 获得时间字段的值*@paramfield时间字段常量*@return该时间字段的值*/public intget(intfield) {

if(field < 0|| field > fields.length- 1) {

throw newIllegalArgumentException(field + ", field value is error.");

}

returnfields[field];

}

/*** 将时间进行“加”运算，即加上一个时间*@paramtime需要加的时间*@return运算后的时间*/publicTime addTime(Time time) {

Time result = newTime();

intup = 0; // 进位标志for(inti = 0; i < fields.length; i++) {

intsum = fields[i] + time.fields[i] + up;

up = sum / (maxFields[i] + 1);

result.fields[i] = sum % (maxFields[i] + 1);

}

returnresult;

}

/*** 将时间进行“减”运算，即减去一个时间*@paramtime需要减的时间*@return运算后的时间*/publicTime subtractTime(Time time) {

Time result = newTime();

intdown = 0; // 退位标志for(inti = 0, k = fields.length- 1; i < k; i++) {

intdifference = fields[i] + down;

if(difference >= time.fields[i]) {

difference -= time.fields[i];

down = 0;

} else{

difference += maxFields[i] + 1- time.fields[i];

down = -1;

}

result.fields[i] = difference;

}

result.fields[DAY] = fields[DAY] - time.fields[DAY] + down;

returnresult;

}

/*** 获得时间字段的分隔符*@return*/publicString getTimeSeparator() {

returntimeSeparator;

}

/*** 设置时间字段的分隔符(用于字符串格式的时间)*@paramtimeSeparator分隔符字符串*/public voidsetTimeSeparator(String timeSeparator) {

this.timeSeparator= timeSeparator;

}

private voidinitialize(intday, inthour, intminute, intsecond) {

set(DAY, day);

set(HOUR, hour);

set(MINUTE, minute);

set(SECOND, second);

}

private voidparseTime(String time) {

if(time == null) {

initialize(0, 0, 0, 0);

return;

}

String t = time;

intfield = DAY;

set(field--, 0);

intp = -1;

while((p = t.indexOf(timeSeparator)) > -1) {

parseTimeField(time, t.substring(0, p), field--);

t = t.substring(p + timeSeparator.length());

}

parseTimeField(time, t, field--);

}

private voidparseTimeField(String time, String t, intfield) {

if(field < SECOND|| t.length() < 1) {

parseTimeException(time);

}

char[] chs = t.toCharArray();

intn = 0;

for(inti = 0; i < chs.length; i++) {

if(chs[i] <= ' ') {

continue;

}

if(chs[i] >= '0'&& chs[i] <= '9') {

n = n * 10+ chs[i] - '0';

continue;

}

parseTimeException(time);

}

set(field, n);

}

private voidparseTimeException(String time) {

throw newIllegalArgumentException(time + ", time format error, HH"+ this.timeSeparator+ "mm"+ this.timeSeparator+ "ss");

}

publicString toString() {

StringBuilder sb = newStringBuilder(16);

//天//sb.append(fields[DAY]).append(',').append(' ');buildString(sb, HOUR).append(timeSeparator);

buildString(sb, MINUTE).append(timeSeparator);

buildString(sb, SECOND);

returnsb.toString();

}

privateStringBuilder buildString(StringBuilder sb, intfield) {

if(fields[field] < 10) {

sb.append('0');

}

returnsb.append(fields[field]);

}

public inthashCode() {

final intPRIME = 31;

intresult = 1;

result = PRIME * result + Arrays.hashCode(fields);

returnresult;

}

public booleanequals(Object obj) {

if(this== obj)

return true;

if(obj == null)

return false;

if(getClass() != obj.getClass())

return false;

finalTime other = (Time) obj;

if(!Arrays.equals(fields, other.fields)) {

return false;

}

return true;

}