Question

我的逻辑是在这个问题上让我不知所措，我希望有人能提供一些我可以学习的代码。

在java中我有一个自定义对象列表，该对象的成员之一是某个事件的日期/时间。

我需要能够从当前/当地时间在列表中找到下一次。

即当地时间是下午6点该清单包含：

下午1点，下午3点，下午4点，晚上7点，晚上10点

我需要一种基本上拉出 7pm 的方法，作为下一个处理事件的时间。

任何建议，指示赞赏，thx

Answer 1

你可以假设列表中的第一个dateTime对象最初是最接近的，然后迭代以查找列表中的任何其他dateTime是否更接近你的引用dateTime。这样的事情：

    import java.util.ArrayList;
    import java.util.List;

    import org.joda.time.DateTime;

    public class test {
        public static void main(String[] args) {
            CustomData cd1 = new CustomData("data1", new DateTime(100000));
            CustomData cd2 = new CustomData("data2", new DateTime(200000));
            CustomData cd3 = new CustomData("data3", new DateTime(300000));
            CustomData cd4 = new CustomData("data4", new DateTime(400000));
            List<CustomData> dataList = new ArrayList<CustomData>();

            dataList.add(cd1);
            dataList.add(cd2);
            dataList.add(cd3);
            dataList.add(cd4);

            DateTime closestDate=dataList.get(0).getDateTime();  //initially assume first dateTime to be the closest
            for(CustomData cd:dataList){
                if(cd!=null && cd.getDateTime()!=null && cd.getDateTime().isBefore(closestDate.getMillis()) && cd.getDateTime().isAfter(DateTime.now())){
                    /*if the date time is before the closest date and after the reference DateTime you are comparing(in this case DateTime.now()) update the reference of closestDate */                
                closestDate=cd.getDateTime();
                }
            }

            System.out.println(closestDate);
        }

    }

还可以参考CustomData类：

import org.joda.time.DateTime;

public class CustomData {
    private String name;
    private DateTime dateTime;

    public CustomData(String name, DateTime dateTime) {
        this.name = name;
        this.dateTime = dateTime;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public DateTime getDateTime() {
        return dateTime;
    }

    public void setDateTime(DateTime dateTime) {
        this.dateTime = dateTime;
    }
}

Answer 2

假设：

您的班级Event具有time属性
time属性类型为java.time.LocalTime或其他具有自然顺序的内容（如java.util.Date），或者您可以轻松提供Comparator，< / LI>
您的活动在java.util.List<Event>中未分类，
您的班级Event根据time（implements Comparable<Event>）定义了一个自然订单，或者您提供了Comparator<Event>来比较Event个对象{{1}属性，

基本上是time的相关要点，

class Event

或

import java.time.LocalTime;

public class Event implements Comparable<Event> {
    LocalTime time;
    @Override
    public int compareTo(final Event o) {
        return time.compareTo(o.time);
    }
}

然后您可以使用以下方法之一来获取您正在寻找的事件（当然还有更多方法）：

您可以使用import java.time.LocalTime; public class Event { LocalTime time; public static final Comparator<Event> byTime = new Comparator<Event>() { @Override public int compare(final Event o1, final Event o2) { return o1.time.compareTo(o2.time); } }; } - 每个循环（比较线性搜索）迭代List。
你可以for列表，stream()之后的所有事件，filter()他们，然后选择第一个。
您可以将事件放在sort()中，并向TreeMap询问TreeMap<LocalTime, Event>。

哪种解决方案最佳取决于您实际存储数据的方式。如果ceilingKey()上的访问权限经常基于List<Event>属性进行，则您可能希望在应用程序中永久保留time。在这种情况下，第三种解决方案是最好的。如果它很少完成，我会使用Streams解决方案。第一个解决方案是天真的原始方法，虽然我们已经用这种方式编写了几十年，但我不喜欢它。

以下是这三种解决方案：

TreeMap<LocalTime, Event>

只要它们是public static Event getNextEventUsingComparison(final List<Event> unsortedEvents, final LocalTime timestamp) { Event candidateEvent = null; for (final Event event : unsortedEvents) if (event.getTime().isAfter(timestamp) && (candidateEvent == null || event.getTime().isBefore(candidateEvent.getTime()))) candidateEvent = event; return candidateEvent; } public static Event getNextEventUsingStreams(final List<Event> unsortedEvents, final LocalTime timestamp) { return unsortedEvents.stream().filter(t -> t.getTime().isAfter(timestamp)).sorted().findFirst().orElse(null); } public static Event getNextEventUsingTreeMap(final List<Event> unsortedEvents, final LocalTime timestamp) { final TreeMap<LocalTime, Event> timeEventMap = new TreeMap<>(); for (final Event event : unsortedEvents) timeEventMap.put(event.getTime(), event); final LocalTime key = timeEventMap.ceilingKey(timestamp); return key != null ? timeEventMap.get(key) : null; }，或者你可以提供java.util.Date，它应该与java.time.LocalTime而不是implements Comparable等其他时间类一样好用。

如果你乱用这段代码，你可能想测试一下。这是我用于测试的相关代码：

Comparator

单元测试：

import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;

public class Event implements Comparable<Event> {
    String title;
    LocalTime time;

    public Event(final String title, final LocalTime time) {
        this.title = title;
        this.time = time;
    }

    public Event(final String descriptor) {
        this(descriptor.substring(6), LocalTime.parse(descriptor.substring(0, 5)));
    }

    public String getTitle() { return title; }
    public LocalTime getTime() { return time; }

    @Override
    public int compareTo(final Event o) { return time.compareTo(o.time); }

    public static List<Event> createEventList(final String... descriptors) {
        final List<Event> events = new ArrayList<>();
        for (final String descriptor : descriptors)
            events.add(new Event(descriptor));
        return events;
    }
}

下次进入Java列表

2 个答案: