Question

下面是交易列表，我需要每15分钟从00:01到00：15、00：16到00:30，00：31到00:45进行交易计数... 23:45（直到一天结束），以防万一，如果在那个特定时间没有交易需要填充0.00，

样本数据：

124385 20191029001650
124385 20191029002050
124385 20191029102050
124391 20191029135007
124391 20191029135507 
124392 20191029144229

预期输出应为0.00,2,0.00,0.00,0.00 ....

我们需要在00:15到00:30之间发送数据，例如“ 2”交易已完成，从10:16到10:30进行“ 1”交易。

Answer 1

用两个成员字段定义一个event类：一个用于交易号的Long整数对象，以及一个LocalDateTime for the date-time value (or Instant`（如果您知道预期的时区或与-的偏移量）世界标准时间）。

package work.basil.example;

import java.time.LocalDateTime;
import java.util.Objects;

final public class Event implements Comparable < Event >
{
    // -------|  Members  |-----------------------------------
    final private Integer transactionId;
    final private LocalDateTime when;

    // -------|  Constructors  |-----------------------------------
    public Event ( Integer transactionId , LocalDateTime when )
    {
        this.transactionId = Objects.requireNonNull( transactionId );
        this.when = Objects.requireNonNull( when );
    }

    // -------|  Accessors  |-----------------------------------
    // Immutable, read-only. So getters only, no setters.
    public Integer getTransactionId ( )
    {
        return transactionId;
    }

    public LocalDateTime getWhen ( )
    {
        return when;
    }

    // -------|  Object  |-----------------------------------

    @Override
    public boolean equals ( Object o )
    {
        if ( this == o ) return true;
        if ( o == null || getClass() != o.getClass() ) return false;
        Event event = ( Event ) o;
        return getTransactionId().equals( event.getTransactionId() ) &&
                getWhen().equals( event.getWhen() );
    }

    @Override
    public int hashCode ( )
    {
        return Objects.hash( getTransactionId() , getWhen() );
    }

    @Override
    public String toString ( )
    {
        return "Event{ " +
                "transactionId=" + transactionId +
                " | when=" + when +
                " }";
    }
}

解析您的传入数据。

对于ID号，请使用Integer类进行解析。

Integer transactionId = Integer.valueOf( input ) ;

对于日期时间，请定义格式格式。

DateTimeFormatter f = DateTimeFormatter.ofPattern( "uuuuMMddHHmmss" ) ;

解析每个字符串。

LocalDateTime ldt = LocalDateTime.parse( input , f ) ;

按每个LocalDateTime对对象进行排序。实现Comparable或创建Comparator对象。两者都已在Stack Overflow中多次讨论，因此请搜索以了解更多信息。

// --------|  Comparator  |-----------------------
/**
 * Comparator by `when`
 */
public static Comparator <Event> WhenComparator = new Comparator<Event>() {

    @Override
    public int compare(Event e1, Event e2) {
        return e1.getWhen().compareTo( e2.getWhen() );
    }
};

从第一个对象开始。采取其LocalDateTime对象。通过调用with并传递LocalTime.MIN创建一个新的。没有区域或偏移，我们知道每天和每个小时都是通用长度，即60分钟，24小时。

如此循环播放，一次添加15分钟。使用Duration以小时-分钟-秒为单位定义时间轴上未附加的时间跨度。

Duration d = Duration.ofMinutes( 15 ) ;

这为您提供开始和停止时间。

如果要将这些LocalDateTime对象调整为偏移量或时区，请提取Instant作为开始和停止位置。在将Interval库添加到项目后，将其包含为ThreeTen-Extra对象。 Interval类提供了方便的比较方法，例如contains。
如果使用LocalDateTime，请考虑制作自己的LocalDateTimeRange类来容纳一对LocalDateTime对象，并实现一个contains( LocalDateTime )方法。

您自己的LocalDateTimeRange可能看起来像这个完全未经测试的原始代码：

package work.basil.example;

import java.time.LocalDateTime;
import java.util.Objects;

public class LocalDateTimeRange
{
    final private LocalDateTime start, end;

    public LocalDateTimeRange ( LocalDateTime start , LocalDateTime end )
    {
        this.start = Objects.requireNonNull( start );
        this.end = Objects.requireNonNull( end );
    }

    public LocalDateTime getStart ( )
    {
        return this.start;
    }

    public LocalDateTime getEnd ( )
    {
        return this.end;
    }

    public boolean contains ( LocalDateTime ldt )
    {
        // Contains is true if the target is greater-than-or-equal-to (not before) the start, and is less-than (before) the ending. 
        // This approach is known as Half-Open, where the beginning is inclusive while the ending is exclusive. 
        return ( ! ldt.isBefore( this.getStart() ) ) && ldt.isBefore( this.getEnd() );
    }

    @Override
    public boolean equals ( Object o )
    {
        if ( this == o ) return true;
        if ( o == null || getClass() != o.getClass() ) return false;
        LocalDateTimeRange that = ( LocalDateTimeRange ) o;
        return getStart().equals( that.getStart() ) &&
                getEnd().equals( that.getEnd() );
    }

    @Override
    public int hashCode ( )
    {
        return Objects.hash( getStart() , getEnd() );
    }

    @Override
    public String toString ( )
    {
        return start + "/" + end; // Return string in standard ISO 8601 format. 
    }


    static public LocalDateTimeRange parse ( )
    {
        // Parse a string in standard ISO 8601 format. 
        …
    }
}

比较手边的对象是否不小于起点且小于终点。这种定义时间跨度的半开放式方法通常是最好的，其中开始是包容性的，而结束是排他性的。

继续循环，直到找到包含手边对象的日期时间的日期时间范围。找到后，将其添加到Map中：

一个Map < LocalDateTimeRange , < Integer > >，您可以在其中递增计数。
一个Map < LocalDateTimeRange , < List< Event > > >，您可以在其中将Event对象添加到List或Set中。

如果在那个特定时间没有事务需要填充0.0

要么将这样的值添加到地图上，要么为该LocalDateRange 键将地图的 value 保留为空。

循环到下一个对象。

完成后，分析您的地图。

提示：教育发布该数据的人员有关：

ISO 8601用于将日期时间值序列化为文本的标准格式。
始终指示时区或UTC偏移的重要性。

上面讨论的所有这些主题已经在Stack Overflow上得到了很多解决。因此，搜索以了解更多信息。并在发布之前彻底搜索Stack Overflow。

如何检查给定时间是否在时间限制之间

1 个答案: