Java 查找距离目标对象最近的对象（之前和之后）

我想实现下面给出的两种方法SomeObject具有日期类型的字段createdDate

private SomeObject getNearestObjectBeforeTargetObjectsCreatedDate(List<SomeObject> someObjectList, SomeObject targetObject){

}


private SomeObject getNearestObjectAfterTargetObjectsCreatedDate(List<SomeObject> someObjectList, SomeObject targetObject){

}

private SomeObject getNearestObjectBeforeTargetObjectsCreatedDate（列出someObjectList，someobjecttargetobject）{
}
私有SomeObject getNearestObjectAfterTargetObjectsCreatedDate（列出someObjectList、SomeObject targetObject）{
}

假设我有5个对象P1，P2，P3，P4，P5，按创建日期的升序排列。而目标对象是P3，那么第一个方法应该返回P2，第二个方法应该返回P4

目前我有类似这样的wirtten

private SomeObject getNearestPortFolio(List<SomeObject> someObjectList, SomeObject targetObject){
    SomeObject returnObject = targetObject;

      for(SomeObject someObject : someObjectList) {
        // if the current iteration's date is "before" the target date
          if(someObject.getCreatedDate().compareTo(targetObject.getCreatedDate()) < 0) {

              if (someObject.getCreatedDate().compareTo(returnObject.getCreatedDate()) > 0){
                  returnObject = someObject;
          }

      }
     }
      return returnObject;
    }

private SomeObject getNearestPortFolio（列出someObjectList、someobjecttargetobject）{
SomeObject returnObject=targetObject；
for（SomeObject SomeObject:someObjectList）{
//如果当前迭代的日期在目标日期之前
如果（someObject.getCreatedDate（）.compareTo（targetObject.getCreatedDate（））<0）{
如果（someObject.getCreatedDate（）.compareTo（returnObject.getCreatedDate（））>0）{
returnObject=someObject；
}
}
}
返回对象；
}

您可以这样做。确保根据需要进行必要的更改，但核心逻辑将保持不变

// Note that if the target is the first element, this will return null.
private static String getNearestBefore(List<String> test, String target) {
    String returnObj = null;
    String previous = null;
    for (String someObj : test) {
        if (someObj.equals(target)) { //Insert your condition here
            returnObj = previous;
        }
        previous = someObj;
    }
    return returnObj;
}

// Note that if the target is the last element, this will return null.
private static String getNearestAfter(List<String> test, String target) {
    String returnObj = null;
    boolean nextSatisfied = false;
    for (String someObj : test) {
        if (nextSatisfied) {
            returnObj = someObj;
            break;
        }
        if (someObj.equals(target)) { //Insert your condition here
            nextSatisfied = true;
        }
    }
    return returnObj;
}

//请注意，如果目标是第一个元素，则返回null。
私有静态字符串getNearestBefore（列表测试，字符串目标）{
字符串returnObj=null；
字符串previous=null；
for（字符串someObj:test）{
如果（someObj.equals（target））{//请在此处插入条件
returnObj=先前的；
}
先前=某个对象；
}
返回OBJ；
}
//注意，如果目标是最后一个元素，则返回null。
私有静态字符串getNearestAfter（列表测试，字符串目标）{
字符串returnObj=null；
布尔值nextsatified=false；
for（字符串someObj:test）{
如果（下一个已满足）{
returnObj=someObj；
打破
}
如果（someObj.equals（target））{//请在此处插入条件
nextsatified=true；
}
}
返回OBJ；
}

根据您的目的调整以下代码。它与

getNearestObjectAfter

等效。该函数返回下一个元素的索引，该索引大于目标

键

。无需将

键

包括在目标列表中。必须对目标列表进行排序

public static <T extends Comparable<? super T>> int upperBound(List<T> list, T key)
{
  int index = Collections.binarySearch(list, key);
  return (0 <= index) ? upperBound(list, key, index) : -index - 1;
}

protected static <T extends Comparable<? super T>> int upperBound(List<T> list, T key, int index)
{
  // -- PRE: 0 <= index < size

  int size = list.size();
  if (list instanceof RandomAccess)
  {
    while (   (++index < size)
           && (0 == list.get(index).compareTo(key)))
    {
      // -- nothing additional to do
    }
  }
  else
  {
    for ( ListIterator<? extends T> I = list.subList(++index, size).listIterator()
        ; I.hasNext()
        ; )
    {
      if (0 == I.next().compareTo(key))
      {
        ++index;
      }
      else
      {
        break;
      }
    }
  }

  return index;
}

---

public static编写自定义比较器并使用树集？@subwrajyotimajumder:请查看我当前的实现
public static <T> int upperBound(List<? extends T> list, T key, Comparator<? super T> comparator)
{
  int index = Collections.binarySearch(list, key, comparator);
  return (0 <= index) ? upperBound(list, key, index, comparator) : -index - 1;
}

protected static <T> int upperBound(List<? extends T> list, T key, int index, Comparator<? super T> comparator)
{
  // -- PRE: 0 <= index < size

  int size = list.size();
  if (list instanceof RandomAccess)
  {
    while (   (++index < size)
           && (0 == comparator.compare(list.get(index), key)))
    {
      // nothing additional to do
    }
  }
  else
  {
    for ( ListIterator<? extends T> I = list.subList(++index, size).listIterator()
        ; I.hasNext()
        ; )
    {
      if (0 == comparator.compare(I.next(), key))
      {
        ++index;
      }
      else
      {
        break;
      }
    }
  }

  return index;
}