Java 将时间段拆分为小时间隔

如何使用java将时间段（10:00:00PM-20:30:00PM）划分为每小时一次的间隔，以获得以下结果

10:00:00 - 11:00:00
11:00:00 - 12:00:00
12:00:00 - 13:00:00
13:00:00 - 14:00:00
15:00:00 - 16:00:00
16:00:00 - 17:00:00
17:00:00 - 18:00:00
19:00:00 - 20:00:00
20:00:00 - 20:30:00

---

对启动和停止进行

LocalTime

在开始时再加一小时

LocalTime lt = start.plusHours( 1 ) ;

请注意不可变对象。我们得到一个新的

LocalTime

对象，而不是改变原始对象

通过调用

isBefore

、

isAfter

和

isEqual

方法与stop进行比较。如果还没有过站，再加一个小时。如果要通过停车点，则使用停车点本身，而不是下一个小时

收集到

列表

如果要将每个条目作为一对

LocalTime

对象进行跟踪，请使用一对

LocalTime

成员字段定义一个名为

TimeSlot

的类。在Java14中预览的新记录功能在这里会做得很好

所有这些都已经在堆栈溢出上讨论过很多次了。搜索以了解更多信息

示例应用程序 下面是一个工作示例应用程序。这使用了在2020.1 IDE中定义的、在Java 14中预览的新的

记录
功能

package work.basil.example;

import java.time.Duration;
import java.time.LocalTime;

public record LocalTimeRange(LocalTime start , LocalTime stop)
{
}

我们可以想象一下

我们重写
toString
以生成四种标准ISO 8601格式之一的文本：HH:MM/HH:MM。我们为指定的四种格式定义枚举。我们的
format
方法使用这些标志之一以四种标准格式之一生成文本

如果有人问我们，我们就产生一个对象。此类表示未附加到时间线的时间跨度（以小时-分钟-秒为刻度）

因为这是一个
记录
，所以我们不需要重写
等于
&
哈希代码
。对于start和end
LocalTime
对象的部分，我们也不需要getter方法

package work.basil.example;

import java.time.Duration;
import java.time.LocalTime;

public record LocalTimeRange(LocalTime start , LocalTime end)
{
    public enum Format
    { START_AND_END, START_AND_DURATION, DURATION_AND_END, DURATION_ONLY }  // Per ISO 8601 standard.

    @Override
    public String toString ( ) { return this.format( Format.START_AND_END ); } // Per ISO 8601 standard.

    public Duration toDuration ( ) { return Duration.between( this.start , this.end ); }

    public String format ( LocalTimeRange.Format format )
    {
        return switch ( format )
                {
                    case START_AND_END -> this.start + "/" + this.end;
                    case START_AND_DURATION -> this.start.toString() + "/" + this.toDuration().toString();
                    case DURATION_AND_END -> this.toDuration().toString() + "/" + this.end.toString();
                    case DURATION_ONLY -> this.toDuration().toString();
                };
    }
}

我们需要一种方法来创建每小时的时间范围

private List < LocalTimeRange > hourlyRanges ( final LocalTime start , final LocalTime stop )
{
    // Verify arguments
    Objects.requireNonNull( start , "Received null time-of-day for start. Message # 51521a5c-5f49-4c74-98e3-fce2587edf77." );
    Objects.requireNonNull( stop , "Received null time-of-day for stop. Message # 41b98429-4edb-4209-a12f-e266dcae4a90." );

    // Logic
    int initialCapacity = java.lang.Math.toIntExact( Duration.between( start , stop ).toHours() + 1 ); // Returns the value of the long argument; throwing an exception if the value overflows an int.
    ArrayList < LocalTimeRange > ranges = new ArrayList <>( initialCapacity );
    LocalTime localTime = start;
    while ( ! localTime.isAfter( stop ) )
    {
        LocalTimeRange range = null;
        LocalTime hourLater = localTime.plusHours( 1 );
        if ( ! hourLater.isAfter( stop ) )
        {
            range = new LocalTimeRange( localTime , hourLater );
        } else
        {
            range = new LocalTimeRange( localTime , stop );
        }
        Objects.requireNonNull( range );
        ranges.add( range );
        // Prepare for next loop.
        localTime = hourLater;
    }
    ranges.trimToSize();
    return Objects.requireNonNull( ranges );
}

private ListhourlyRanges（最终本地时间开始，最终本地时间停止）
{
//验证参数
Objects.requirennoull（start，“收到启动的空时间。消息#51521a5c-5f49-4c74-98e3-fce2587edf77”）；
Objects.requirennoull（stop，“接收到stop.Message#41b98429-4edb-4209-a12f-e266dcae4a90的一天中的空时间”）；
//逻辑
int initialCapacity=java.lang.Math.toIntExact（Duration.between（start，stop）.toHours（）+1）；//返回长参数的值；如果值溢出int，则引发异常。
ArrayListranges=新的ArrayList（初始容量）；
LocalTime LocalTime=start；
而（！localTime.isAfter（stop））
{
LocalTimeRange=null；
LocalTime hourLater=LocalTime.plusHours（1）；
如果（！hourLater.isAfter（停止））
{
范围=新的LocalTimeRange（localTime，hourLater）；
}否则
{
范围=新的LocalTimeRange（localTime，停止）；
}
对象。requirennull（范围）；
范围。添加（范围）；
//准备下一个循环。
本地时间=小时后；
}
ranges.trimToSize（）；
返回对象。requirennull（范围）；
}

和一些代码来练习它

LocalTime start = LocalTime.parse( "10:00:00" );
LocalTime end = LocalTime.parse( "20:30:00" );
List < LocalTimeRange > ranges = this.hourlyRanges( start , end );

System.out.println( "ranges = " + ranges );
System.out.println( ranges.stream().map( range -> range.toDuration() ).collect( Collectors.toList() ) );
System.out.println( ranges.stream().map( range -> range.format( LocalTimeRange.Format.START_AND_END ) ).collect( Collectors.toList() ) );
System.out.println( ranges.stream().map( range -> range.format( LocalTimeRange.Format.START_AND_DURATION ) ).collect( Collectors.toList() ) );
System.out.println( ranges.stream().map( range -> range.format( LocalTimeRange.Format.DURATION_AND_END ) ).collect( Collectors.toList() ) );
System.out.println( ranges.stream().map( range -> range.format( LocalTimeRange.Format.DURATION_ONLY ) ).collect( Collectors.toList() ) );

LocalTime start=LocalTime.parse（“10:00:00”）；
LocalTime end=LocalTime.parse（“20:30:00”）；
Listranges=this.hourlyRanges（开始、结束）；
System.out.println（“范围=”+范围）；
System.out.println（ranges.stream（）.map（range->range.toDuration（））.collect（collector.toList（））；
System.out.println（ranges.stream（）.map（range->range.format（LocalTimeRange.format.START_和_END））.collect（Collectors.toList（））；
System.out.println（ranges.stream（）.map（range->range.format（LocalTimeRange.format.START_和_DURATION））.collect（Collectors.toList（））；
System.out.println（ranges.stream（）.map（range->range.format（LocalTimeRange.format.DURATION_和_END））.collect（Collectors.toList（））；
System.out.println（ranges.stream（）.map（range->range.format（仅限LocalTimeRange.format.DURATION_））.collect（Collectors.toList（））；

运行时：

范围=[10:00/11:00，11:00/12:00，12:00/13:00，13:00/14:00，14:00/15:00，15:00/16:00，16:00/17:00，17:00/18:00，18:00/19:00，19:00/20:00，20:00/20:30]

[PT1H，PT1H，PT1H，PT1H，PT1H，PT1H，PT1H，PT1H，PT1H，PT30M]

[10:00/11:00、11:00/12:00、12:00/13:00、13:00/14:00、14:00/15:00、15:00/16:00、16:00/17:00、17:00/18:00、18:00/19:00、19:00/20:00、20:00/20:30]

[10:00/PT1H、11:00/PT1H、12:00/PT1H、13:00/PT1H、14:00/PT1H、15:00/PT1H、16:00/PT1H、17:00/PT1H、18:00/PT1H、19:00/PT1H、20:00/PT30M]

[PT1H/11:00、PT1H/12:00、PT1H/13:00、PT1H/14:00、PT1H/15:00、PT1H/16:00、PT1H/17:00、PT1H/18:00、PT1H/19:00、PT1H/20:00、PT30M/20:30]

[PT1H，PT1H，PT1H，PT1H，PT1H，PT1H，PT1H，PT1H，PT1H，PT30M]


关于java.time
该框架内置于Java8及更高版本中。这些类取代了麻烦的旧日期时间类，例如，&

要了解更多信息，请参阅。并搜索堆栈溢出以获得许多示例和解释。规格是

该项目现已启动，建议迁移到类

您可以直接与数据库交换java.time对象。使用兼容的或更高版本。不需要字符串，也不需要
java.sql.*
类。Hibernate5和JPA2.2支持java.time

从哪里获得java.time类


、和更高版本-标准Java API的一部分，带有捆绑实现。

Java9添加了一些次要功能和修复

及

大多数java.time功能都在中向后移植到Java6和Java7



更高版本的Android捆绑包实现了java.time类
对于早期的Android（这解决了我的部分问题：

private ArrayList<String> setInterval(String start, String stop) throws ParseException {
    String strStart;
    String strEnd;
    ArrayList<String> arrayList = new ArrayList<>();
    SimpleDateFormat df = new SimpleDateFormat("HH:mm:ss", Locale.getDefault());
    Date dStart = df.parse(start);
    Date dStop = df.parse(stop);
    Calendar cal = Calendar.getInstance();
    cal.setTime(dStart);
    cal.add(Calendar.HOUR, 1); //minus number would decrement the days
    while (cal.getTime().before(dStop)) {
        strStart = df.format(cal.getTime());
        cal.add(Calendar.HOUR, 1);
        strEnd = df.format(cal.getTime());
        arrayList.add(strStart + " - " + strEnd);
    }
    return arrayList;
}

private ArrayList setInterval（字符串开始、字符串停止）抛出ParseException