Java根据MM-dd和HH:mm格式日期计算时长与大小比较_Java

1.如何根据多个"mm-dd"格式的日期（可能跨年）来计算总时长

特别处理当日和次日的情况

解决方案

方法思路

将输入的"mm-dd"格式转换为完整的日期（考虑跨年情况）
对日期进行排序
计算相邻日期之间的时间差
累加得到总时长

import java.time.*;
import java.time.format.datetimeformatter;
import java.time.temporal.chronounit;
import java.util.*;

public class datedurationcalculator {
    
    // 主计算方法
    public static duration calculatetotalduration(list<string> monthdaystrings, localdate today) {
        if (monthdaystrings == null || monthdaystrings.isempty()) {
            return duration.zero;
        }

        // 转换所有日期为localdate（处理跨年）
        list<localdate> dates = convertmonthdaytodates(monthdaystrings, today);
        
        // 对日期进行排序
        collections.sort(dates);
        
        // 计算总时长
        duration totalduration = duration.zero;
        for (int i = 0; i < dates.size() - 1; i++) {
            localdate start = dates.get(i);
            localdate end = dates.get(i + 1);
            
            // 计算两个日期之间的天数
            long daysbetween = chronounit.days.between(start, end);
            
            // 如果日期连续（当日和次日）
            if (daysbetween == 1) {
                totalduration = totalduration.plus(duration.ofdays(1));
            } else {
                // 非连续日期，只计算单个日期
                totalduration = totalduration.plus(duration.ofdays(1));
            }
        }
        
        // 加上最后一个日期
        return totalduration.plus(duration.ofdays(1));
    }
    
    // 将mm-dd转换为localdate，处理跨年情况
    private static list<localdate> convertmonthdaytodates(list<string> monthdaystrings, localdate today) {
        datetimeformatter formatter = datetimeformatter.ofpattern("mm-dd");
        list<localdate> dates = new arraylist<>();
        
        for (string monthday : monthdaystrings) {
            monthday md = monthday.parse(monthday, formatter);
            
            // 获取可能的年份（今年或明年）
            localdate date = md.atyear(today.getyear());
            if (date.isbefore(today)) {
                // 如果日期已经过去，则认为是明年
                date = md.atyear(today.getyear() + 1);
            }
            
            dates.add(date);
        }
        
        return dates;
    }
    
    public static void main(string[] args) {
        // 示例使用
        localdate today = localdate.now();
        list<string> dates = arrays.aslist("12-25", "12-26", "01-01", "01-02");
        
        duration duration = calculatetotalduration(dates, today);
        
        system.out.println("总天数: " + duration.todays());
        system.out.println("总小时数: " + duration.tohours());
    }
}

关键点说明

1.跨年处理：

使用monthday类解析"mm-dd"格式
比较日期与当前日期，决定使用今年还是明年的年份

2.当日和次日判断：

使用chronounit.days.between()计算日期差
差值为1表示是连续的当日和次日

3.总时长计算：

连续日期计算为完整时间段
非连续日期单独计算

4.输出结果：可以获取总天数、小时数等不同单位的时长

2.比较多个"mm-dd"格式的日期（月份-日期）大小

可以使用以下几种方法

只比较日期：

import java.time.monthday;
import java.time.format.datetimeformatter;

public class comparetwodates {
    public static void main(string[] args) {
        string date1 = "12-31";
        string date2 = "01-01";
        
        datetimeformatter formatter = datetimeformatter.ofpattern("mm-dd");
        monthday md1 = monthday.parse(date1, formatter);
        monthday md2 = monthday.parse(date2, formatter);
        
        int result = md1.compareto(md2);
        
        if (result < 0) {
            system.out.println(date1 + " 早于 " + date2);
        } else if (result > 0) {
            system.out.println(date1 + " 晚于 " + date2);
        } else {
            system.out.println(date1 + " 等于 " + date2);
        }
    }
}

比较日期并进行排序：

import java.time.monthday;
import java.time.format.datetimeformatter;
import java.util.arrays;
import java.util.collections;
import java.util.list;

public class monthdaycomparison {
    public static void main(string[] args) {
        list<string> dates = arrays.aslist("12-31", "01-01", "06-15", "03-22");
        
        // 转换为monthday对象并排序
        datetimeformatter formatter = datetimeformatter.ofpattern("mm-dd");
        collections.sort(dates, (a, b) -> {
            monthday md1 = monthday.parse(a, formatter);
            monthday md2 = monthday.parse(b, formatter);
            return md1.compareto(md2);
        });
        
        system.out.println("排序后的日期: " + dates);
        // 输出: [01-01, 03-22, 06-15, 12-31]
    }
}

注意事项

跨年问题：mm-dd 格式不包含年份信息，比较时只考虑月日
格式一致性：确保所有日期使用相同的格式（如都使用"mm-dd"或"m-d"）
性能考虑：对于大量日期，monthday 方法比字符串分割更高效
错误处理：实际应用中应添加格式验证和异常处理

最佳实践推荐

对于 java 8 及以上版本，推荐使用 monthday 类进行比较，因为：

代码更简洁
内置日期有效性检查
提供丰富的日期操作方法

3.汇总多个"hh:mm"格式的时间点，计算它们的总时长

import java.time.duration;
import java.time.localtime;
import java.time.format.datetimeformatter;
import java.util.list;

public class streamtimesum {
    public static void main(string[] args) {
        list<string> times = list.of("08:15", "01:30", "00:45");
        
        duration total = times.stream()
            .map(t -> localtime.parse(t, datetimeformatter.ofpattern("hh:mm")))
            .map(t -> duration.ofhours(t.gethour()).plusminutes(t.getminute()))
            .reduce(duration.zero, duration::plus);
        
        system.out.printf("总时长: %d小时%d分钟%n", 
            total.tohours(), 
            total.tominutes() % 60);
        // 输出: 总时长: 10小时30分钟
    }
}

注意事项

格式验证：实际应用中应添加格式验证，确保输入都是有效的"hh:mm"格式
负数处理：如果业务需要处理负时间，需要额外逻辑
性能考虑：对于大量时间点，stream api可能稍慢于传统循环
时间溢出：当总时长超过24小时，确保显示逻辑能正确处理

最佳实践推荐

对于现代java项目，推荐使用方法一（java 8 duration类）：

代码更简洁易读
内置时间计算功能
自动处理进位和溢出
提供丰富的转换和操作方法

4.比较多个"hh:mm"格式时间的大小

只比较时间：

import java.time.localtime;
import java.time.format.datetimeformatter;
import java.util.arrays;
import java.util.collections;
import java.util.list;

public class timecomparison {
    public static void main(string[] args) {
        list<string> times = arrays.aslist("08:15", "13:30", "09:45", "05:00");
        
        // 转换为localtime对象并排序
        datetimeformatter formatter = datetimeformatter.ofpattern("hh:mm");
        collections.sort(times, (a, b) -> {
            localtime t1 = localtime.parse(a, formatter);
            localtime t2 = localtime.parse(b, formatter);
            return t1.compareto(t2);
        });
        
        system.out.println("按时间排序: " + times);
        // 输出: [05:00, 08:15, 09:45, 13:30]
    }
}

比较时间并进行排序：

import java.time.localtime;
import java.time.format.datetimeformatter;

public class comparetwotimes {
    public static void main(string[] args) {
        string time1 = "13:45";
        string time2 = "09:30";
        
        datetimeformatter formatter = datetimeformatter.ofpattern("hh:mm");
        localtime t1 = localtime.parse(time1, formatter);
        localtime t2 = localtime.parse(time2, formatter);
        
        int result = t1.compareto(t2);
        
        if (result < 0) {
            system.out.println(time1 + " 早于 " + time2);
        } else if (result > 0) {
            system.out.println(time1 + " 晚于 " + time2);
        } else {
            system.out.println(time1 + " 等于 " + time2);
        }
    }
}

找出最早最晚时间：

import java.time.localtime;
import java.time.format.datetimeformatter;
import java.util.arrays;
import java.util.list;

public class findminmaxtime {
    public static void main(string[] args) {
        list<string> times = arrays.aslist("08:15", "13:30", "09:45", "05:00");
        datetimeformatter formatter = datetimeformatter.ofpattern("hh:mm");
        
        localtime min = localtime.max;
        localtime max = localtime.min;
        
        for (string timestr : times) {
            localtime time = localtime.parse(timestr, formatter);
            if (time.isbefore(min)) {
                min = time;
            }
            if (time.isafter(max)) {
                max = time;
            }
        }
        
        system.out.println("最早时间: " + min.format(formatter));
        system.out.println("最晚时间: " + max.format(formatter));
    }
}