时间计算

今天药忘吃喽~ 2022-08-27 11:59 159阅读 0赞

时间计算

public class Test \{

public static void main(String\[\] args) \{  
        Time t1 = new Time(1, 11, 32, 18);  
        Time t2 = new Time(16, 58, 18);  
        System.out.println("   t1: " + t1);  
        System.out.println("   t2: " + t2);  
        System.out.println("t1-t2: " + t1.subtractTime(t2));  
        System.out.println("t1+t2: " + t1.addTime(t2));  
         
        Time t3 = new Time("13:22:44");  
        System.out.println("   t3: " + t3);  
         
        Time t4 = new Time("16-58-18", "-");  
        System.out.println("   t4: " + t4);  
         
        System.out.println("t2==t4? " + t2.equals(t4));  
    \}  
\}

import java.text.DecimalFormat;  
import java.util.Arrays;

/\*\*  
 \* 时间计算工具类  
 \*/  
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("//EE//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;  
    \}  
\}