0

我想实现下面给出的两种方法。SomeObject有一个Date 类型的字段createdDate

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

}


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

}

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

目前我已经写了这样的东西

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;
    }
4

2 回答 2

0

根据您的目的调整以下代码。它相当于getNearestObjectAfter. 该函数返回大于目标的下一个元素的索引key。没有必要key包含在目标列表中。目标列表必须排序。

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 <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;
}
于 2013-04-09T05:54:21.807 回答
0

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

// 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;
}
于 2013-04-09T05:42:17.607 回答