Java 如何在ObservableList中使用LocalTime添加缺少的时间？

我正在尝试创建一个日程安排，在这里我只能得到输入的时间和日程安排的名称

我想把日程安排放在一个

列表中

，但是如果没有其他日程安排，该列表应该添加一个新的空日程安排，从

早上6:00开始

，如果没有其他提前时间

我有

可观察列表

，它包含

本地时间

和一些

字符串

示例1: 假设该列表包含3项：

[04:00 AM] [Some String]
[06:30 AM] [Some String]
[05:00 PM] [Some String]

我想在列表中添加从

4:00am

到

5:00pm

的缺失时间，因此列表将为：

[04:00 AM] [Some String]
[05:00 AM] [Some String]
[06:30 AM] [Some String]
[07:00 AM] [Some String]
[08:00 AM] [Some String]
[09:00 AM] [Some String]
[10:00 AM] [Some String]
[11:00 AM] [Some String]
[12:00 PM] [Some String]
[01:00 PM] [Some String]
[02:00 PM] [Some String]
[03:00 PM] [Some String]
[04:00 PM] [Some String]
[05:00 PM] [Some String]

[06:00 AM] [Some String]
[07:00 AM] [Some String]
[08:00 AM] [Some String]
[09:00 AM] [Some String]
[10:00 AM] [Some String]
[11:00 AM] [Some String]
[12:00 PM] [Some String]
[01:00 PM] [Some String]
[02:00 PM] [Some String]
[03:00 PM] [Some String]
[04:00 PM] [Some String]
[05:00 PM] [Some String]

示例2: 假设该列表包含两项：

[08:30 AM] [Some String]
[02:00 PM] [Some String]

我想在列表中添加从

6:00am

到

5:00pm

的缺失时间，因此列表将为：

[04:00 AM] [Some String]
[05:00 AM] [Some String]
[06:30 AM] [Some String]
[07:00 AM] [Some String]
[08:00 AM] [Some String]
[09:00 AM] [Some String]
[10:00 AM] [Some String]
[11:00 AM] [Some String]
[12:00 PM] [Some String]
[01:00 PM] [Some String]
[02:00 PM] [Some String]
[03:00 PM] [Some String]
[04:00 PM] [Some String]
[05:00 PM] [Some String]

[06:00 AM] [Some String]
[07:00 AM] [Some String]
[08:00 AM] [Some String]
[09:00 AM] [Some String]
[10:00 AM] [Some String]
[11:00 AM] [Some String]
[12:00 PM] [Some String]
[01:00 PM] [Some String]
[02:00 PM] [Some String]
[03:00 PM] [Some String]
[04:00 PM] [Some String]
[05:00 PM] [Some String]

示例3: 假设该列表包含1项：

[08:00 PM] [Some String]

我想在列表中添加从

6:00am

到

8:00pm

的缺失时间，因此列表将被删除

[06:00 AM] [Some String]
[07:00 AM] [Some String]
[08:00 AM] [Some String]
[09:00 AM] [Some String]
[10:00 AM] [Some String]
[11:00 AM] [Some String]
[12:00 PM] [Some String]
[01:00 PM] [Some String]
[02:00 PM] [Some String]
[03:00 PM] [Some String]
[04:00 PM] [Some String]
[05:00 PM] [Some String]
[06:00 PM] [Some String]
[07:00 PM] [Some String]
[08:00 PM] [Some String]

如果没有其他提前时间，则时间应在上午06:00开始，否则时间将在该提前时间开始

如果没有其他时间，时间应该在下午5:00结束，否则时间将在该特定时间结束，我只想添加

HOUR

像

increment

HOUR一样，所以不应该有

6:30

，

5:30

，除非手动输入

我正在考虑以下逻辑，但我无法继续，因为我的想法被锁定了

根据从上午到下午的时间对列表进行排序，以获得第一次

检查第一次数据的时间是否等于或小于上午6:00
如果为true，则从该时间开始，继续添加缺少的 直到下午5:00或最后一次到达的时间。
如果为假，则 从早上6:00开始，继续添加缺失的时间，直到5:00 下午或最后一次到达

下面的代码是我目前所拥有的，令人费解

private void fillTheList(){
        ObservableList<DataClass> data = FXCollections.observableArrayList();
        Comparator<DataClass> comparator = Comparator.comparing(DataClass::getLocalTime);

        data.add(new DataClass(convertTime("05:00 PM"), "Sample Content"));
        data.add(new DataClass(convertTime("06:30 AM"), "Sample Content"));

        FXCollections.sort(data,comparator); //Sort the list from AM to PM

        for (DataClass list : data){
            if(list.getLocalTime().isBefore(LocalTime.of(6,0))){
                //The time is less than 6:00 AM then it should start here and Add the missing time but I don't know what to do next...
            }else{
                //the time is not less than 6:00 AM... I don't know what to do next..
            }
        }
        FXCollections.sort(data,comparator); //Sort the list from AM to PM again
}

private LocalTime convertTime(String timeString){
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("hh:mm a");
        return LocalTime.parse(timeString, formatter);
}

---

你必须遵循这些步骤

获取start的值，它将是

06AM

或列表的第一个值，这取决于哪个值是第一个

获取end的值，它只是第二个值

清除列表以删除起始值和结束值

迭代2之间的所有日期，每次递增1小时

结束条件是

i.isBefore（end.plusHours（1））

而不是

i.isBefore（end）

，因为需要包含

end

元素

分类和打印

observeList data=FXCollections.observearraylist（）；
Comparator Comparator=Comparator.comparing（DataClass:：getLocalTime）；
添加（新的数据类（转换时间（“05:00pm”），“样本内容”）；
添加（新的数据类（convertTime（“06:30 AM”），“样本内容”）；
FXCollections.sort（数据、比较器）//将列表从上午排序到下午
// 1. & 2.
LocalTime begin=LocalTime.of（6,0）；
if（data.get（0.getLocalTime（）.isBefore（begin））{
begin=data.get（0.getLocalTime（）；
}
LocalTime end=LocalTime.of（17,0）；
if（end.isBefore（data.get（data.size（）-1.getLocalTime（）））{
end=data.get（data.size（）-1.getLocalTime（）；
}
// 3.
data.clear（）；
// 4. & 5.
for（LocalTime i=begin.withMinute（0）；！i.isAfter（end）；i=i.plusHours（1））{
添加（新数据类（i，“样本内容”）；
}
// 6. 
FXCollections.sort（数据、比较器）//再次将列表从上午排序到下午
系统输出打印项次（数据）；
//  [06:00, 07:00, 08:00, 09:00, 10:00, 11:00, 12:00, 13:00, 14:00, 15:00, 16:00, 17:00]

不完全确定您需要什么，但这可能就是您需要的：

ObservableList<DataClass> data = FXCollections.observableArrayList();

// Need to specify the period that you want the entries to be filled
private void fill(LocalTime from, LocalTime to) {
    // Keep adding new entries until we have reached the end
    while (!from.isAfter(to)) {
        // We need a final variable for stream()
        final LocalTime temp = from;

        // If data does not contain any time that is equivalent to this time
        if (data.stream().noneMatch(d -> temp.equals(d.getLocalTime()))) {
            data.add(new DataClass(temp, "Hello World"));
        }

        // Increment the time by an hour, and wait for next loop cycle
        from = from.plusHours(1);
    }
}

这将强制两个边界值只有小时值。

按以下步骤进行操作

对列表排序

设置可能需要插入的时间（从插入范围的下限开始）

查找时间>=要插入时间的第一个元素的索引

如果元素的时间与要插入的时间不匹配，请在该索引处插入新元素

修改要插入的时间，如果尚未离开插入范围，请继续执行3

---

你自己也在路上。此外，AZRO是正确的，你需要找到最小和最大小时考虑插入，通过比较在数据中的最小和最大时间。Jai是正确的，在插入时间之前，您应该检查时间是否已经在列表中，并且流对此目的很方便。我的版本使用

int

在几个小时内进行迭代，但所有其他版本都正确，即

LocalTime

也可以工作

    int minHour = 6;
    int maxHour = 17;
    if (! data.isEmpty()) {
        // adjust min and max from list contents
        int minExisintgHour = data.get(0).getLocalTime().getHour();
        if (minExisintgHour < minHour) {
            // if the list already contained 4:00 or 4:30,
            // we only need to add hours from 5, so add 1
            minHour = minExisintgHour + 1;
        }
        int maxExisintgHour = data.get(data.size() - 1).getLocalTime().getHour();
        if (maxExisintgHour > maxHour) {
            maxHour = maxExisintgHour;
        }
    }
    for (int hour = minHour; hour <= maxHour; hour++) {
        LocalTime time = LocalTime.of(hour, 0);
        boolean alreadyInData = data.stream().anyMatch(d -> d.getLocalTime().equals(time));
        if (! alreadyInData) {
            data.add(new DataClass(time, "Added beacuse time was missing"));
        }
    }

---

通过使用

。。。。若要

您已经消除了关键信息，我们需要了解您想要实现的目标。生成“缺失”时间的具体规则是什么？间隔时间是几点？它是常数吗？这个问题非常不清楚。

PS：我不确定我要问什么，所以如果有必要，请随时提出编辑建议。

-如果您不知道您需要什么，我们很难知道您需要什么。@Jai-我知道我想实现什么，但我不知道如何问。您能给DataClass类吗？试试看会有帮助的things@azro-更新没有解释的答案不是oneNo数据已添加@KrixMuxDeadpool将取决于

from

和

to

（当然也取决于列表中已有的数据）。将

从.isBefore（to）

更改为

！from.isAfter（to）

以包括结束时间。另外，请注意，这要求两个时间值为整小时值。假设开始时间为

5:30 AM

，则所有内容也将有

30分钟

。谢谢，但有一个小问题，它不会在很早的时间开始，例如

4:30 AM

，最早的时间是remove，它总是在上午6:00开始。此外，已删除分钟的时间

ObservableList<DataClass> data = ...
LocalTime lowerBound = LocalTime.of(6, 0); // or some other input
LocalTime upperBound = LocalTime.of(12 + 5, 0); // or some other input


Comparator<DataClass> comparator = Comparator.comparing(DataClass::getLocalTime);
FXCollections.sort(data, comparator);

int size = data.size();
int index = 0;

while (!lowerBound.isAfter(upperBound)) {
    // find inserting index
    while (index < size && data.get(index).getLocalTime().isBefore(lowerBound)) {
        index++;
    }
    // insert, if not already in list
    if (index >= size || !data.get(index).getLocalTime().equals(lowerBound)) {
        data.add(index, new DataClass(lowerBound, "Inserted"));
        size++;
    }
    lowerBound = lowerBound.plusHours(1);
    index++;
}

final int size = data.size();
int index = 0;

while (!lowerBound.isAfter(upperBound)) {
    // find inserting index
    while (index < size && data.get(index).getLocalTime().isBefore(lowerBound)) {
        index++;
    }
    // insert, if not already in list
    if (index >= size || !data.get(index).getLocalTime().equals(lowerBound)) {
        data.add(new DataClass(lowerBound, "Inserted"));
    } else {
        index++;
    }
    lowerBound = lowerBound.plusHours(1);
}

// merge
DataClass[] merged = new DataClass[data.size()];
int insertionIndex = 0;
int index1 = 0;
int index2 = size;
while (index1 < size && index2 < merged.length) {
    DataClass v1 = data.get(index1);
    DataClass v2 = data.get(index2);
    if (v2.getLocalTime().isBefore(v1.getLocalTime())) {
        merged[insertionIndex] = v2;
        index2++;
    } else {
        merged[insertionIndex] = v1;
        index1++;
    }
    insertionIndex++;
}

// copy remaining
while (index1 < size) {
    merged[insertionIndex++] = data.get(index1++);
}
while (index2 < merged.length) {
    merged[insertionIndex++] = data.get(index2++);
}
data.setAll(merged);

    int minHour = 6;
    int maxHour = 17;
    if (! data.isEmpty()) {
        // adjust min and max from list contents
        int minExisintgHour = data.get(0).getLocalTime().getHour();
        if (minExisintgHour < minHour) {
            // if the list already contained 4:00 or 4:30,
            // we only need to add hours from 5, so add 1
            minHour = minExisintgHour + 1;
        }
        int maxExisintgHour = data.get(data.size() - 1).getLocalTime().getHour();
        if (maxExisintgHour > maxHour) {
            maxHour = maxExisintgHour;
        }
    }
    for (int hour = minHour; hour <= maxHour; hour++) {
        LocalTime time = LocalTime.of(hour, 0);
        boolean alreadyInData = data.stream().anyMatch(d -> d.getLocalTime().equals(time));
        if (! alreadyInData) {
            data.add(new DataClass(time, "Added beacuse time was missing"));
        }
    }

[06:00 AM] [Added beacuse time was missing]
[06:30 AM] [Sample Content]
[07:00 AM] [Added beacuse time was missing]
[08:00 AM] [Added beacuse time was missing]
[09:00 AM] [Added beacuse time was missing]
[10:00 AM] [Added beacuse time was missing]
[11:00 AM] [Added beacuse time was missing]
[12:00 PM] [Added beacuse time was missing]
[01:00 PM] [Added beacuse time was missing]
[02:00 PM] [Added beacuse time was missing]
[03:00 PM] [Added beacuse time was missing]
[04:00 PM] [Added beacuse time was missing]
[05:00 PM] [Sample Content]