有没有时分秒这种日期类型？

Question

我想做一个时间的加减，但不想包含年月日，有没有对应的类型？

Answer 1

.java.util.Calendar
Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。 

Answer 2

写一个自己的Date,扩展Date,如:
public class MyDate extends Date {
   public MyDate(Date d){
       //自动把年月日换成某个固定的。
   }}至于加减计算，myDate.getTime()后，自己算吧。

Answer 3

没有这类，下面是我原来写的，可以参考一下：public class Test {    public static void main(String[] args) {
        Time t1 = new Time(21, 0);
        Time t2 = new Time(20, 5);        Time diff = t1.subtractTime(t2);
        
        System.out.println(diff);
        System.out.println("Minute = " + diff.get(Time.MINUTE));
        System.out.println("Second = " + diff.get(Time.SECOND));
    }
}
import java.text.DecimalFormat;
import java.util.Arrays;/**
 * 时间计算工具类
 * 
 * @author bao110908
 */
public class Time {    /**
     * 时间字段常量，表示“秒”
     */
    public final static int SECOND = 0;
    
    /**
     * 时间字段常量，表示“分”
     */
    public final static int MINUTE = 1;
    
    /**
     * 时间字段常量，表示“时”
     */
    public final static int HOUR = 2;
    
    /**
     * 时间字段常量，表示“天”
     */
    public final static int DAY = 3;    /**
     * 各常量允许的最大值
     */
    private final int[] maxFields = { 59, 59, 23, Integer.MAX_VALUE - 1 };
    
    /**
     * 各常量允许的最小值
     */
    private final int[] minFields = { 0, 0, 0, Integer.MIN_VALUE };
    
    /**
     * 默认的字符串格式时间分隔符
     */
    private String timeSeparator = ":";
    
    /**
     * 时间数据容器
     */
    private int[] fields = new int[4];    
    
    /**
     * 无参构造，将各字段置为 0
     */
    public Time() {
        this(0, 0, 0, 0);
    }    /**
     * 使用时、分构造一个时间
     * @param hour      小时
     * @param minute    分钟
     */
    public Time(int hour, int minute) {
        this(0, hour, minute, 0);
    }    /**
     * 使用时、分、秒构造一个时间
     * @param hour      小时
     * @param minute    分钟
     * @param second    秒
     */
    public Time(int hour, int minute, int second) {
        this(0, hour, minute, second);
    }
    
    /**
     * 使用一个字符串构造时间<br/>
     * Time time = new Time("14:22:23");
     * @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("14-22-23", "-");
     * @param time      字符串格式的时间
     */
    public Time(String time, String timeSeparator) {
        if(timeSeparator != null) {
            setTimeSeparator(timeSeparator);
        }
        String pattern = patternQuote(this.timeSeparator);
        String matcher = new StringBuffer()
                                .append("\\d+?").append(pattern)
                                .append("\\d+?").append(pattern)
                                .append("\\d+?")
                                .toString();
        if(!time.matches(matcher)) {
            throw new IllegalArgumentException(time + ", time format error, HH"
                    + this.timeSeparator + "mm" + this.timeSeparator + "ss");
        }        
        String[] times = time.split(pattern);
        set(DAY, 0);
        set(HOUR, Integer.parseInt(times[0]));
        set(MINUTE, Integer.parseInt(times[1]));
        set(SECOND, Integer.parseInt(times[2]));
    }
    
    /**
     * 设置时间字段的值
     * @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] + 1);
        // 进行进位计算
        int carry = value / (maxFields[field] + 1);
        if(carry > 0) {
            int upFieldValue = get(field + 1);
            set(field + 1, upFieldValue + carry);
        }
    }    /**
     * 获得时间字段的值
     * @param field     时间字段常量
     * @return          该时间字段的值
     */
    public int get(int field) {
        if(field < 0 || field > fields.length - 1) {
            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 = 0;     // 进位标志
        for (int i = 0; i < fields.length; i++) {
            int sum = fields[i] + time.fields[i] + up;
            up = sum / (maxFields[i] + 1);
            result.fields[i] = sum % (maxFields[i] + 1);
        }
        return result;
    }    /**
     * 将时间进行“减”运算，即减去一个时间
     * @param time      需要减的时间
     * @return          运算后的时间
     */
    public Time subtractTime(Time time) {
        Time result = new Time();
        int down = 0;       // 退位标志
        for (int i = 0, k = fields.length - 1; i < k; i++) {
            int difference = 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;
        return result;
    }
    
    /**
     * 获得时间字段的分隔符
     * @return
     */
    public String getTimeSeparator() {
        return timeSeparator;
    }    /**
     * 设置时间字段的分隔符（用于字符串格式的时间）
     * @param timeSeparator     分隔符字符串
     */
    public void setTimeSeparator(String timeSeparator) {
        this.timeSeparator = timeSeparator;
    }    /**
     * 正则表达式引用处理方法，源自 JDK @link java.util.regex.Pattern#quote(String)
     */
    private String patternQuote(String s) {
        int slashEIndex = s.indexOf("\\E");
        if (slashEIndex == -1)
            return "\\Q" + s + "\\E";        StringBuilder sb = new StringBuilder(s.length() * 2);
        sb.append("\\Q");
        slashEIndex = 0;
        int current = 0;
        while ((slashEIndex = s.indexOf("\\E", current)) != -1) {
            sb.append(s.substring(current, slashEIndex));
            current = slashEIndex + 2;
            sb.append("\\E\\\\E\\Q");
        }
        sb.append(s.substring(current, s.length()));
        sb.append("\\E");
        return sb.toString();
    }    public String toString() {
        DecimalFormat df = new DecimalFormat("00");
        return new StringBuffer().append(fields[DAY]).append(", ")
                    .append(df.format(fields[HOUR])).append(timeSeparator)
                    .append(df.format(fields[MINUTE])).append(timeSeparator)
                    .append(df.format(fields[SECOND]))
                    .toString();
    }    public int hashCode() {
        final int PRIME = 31;
        int result = 1;
        result = PRIME * result + Arrays.hashCode(fields);
        return result;
    }    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final Time other = (Time) obj;
        if (!Arrays.equals(fields, other.fields)) {
            return false;
        }
        return true;
    }
}

Answer 4

用这个java.util.Calendar，时间的都可以做到。

Answer 5

没有这样的方法，前面的大牛都会过了，下面是我的方法
getTimes获取毫秒值，然后毫秒值按照int类型的加减方法加减，之后再把毫秒值转成时间截取里面的时分秒部分