查找距目標對象最近的對象（前後）

Question

我想實現下面給出的兩個方法。 SomeObject有一個字段類型日期

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

} 


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

} 

假設的createdDate我有5個對象P1，P2，P3，P4，P5中創建日期的升序排列。而目標對象是P3，則1方法應該返回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; 
    } 

Answer 1

你可以做這樣的事情。請確保根據您的需求進行必要的更改，但核心邏輯將保持不變。

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

Answer 2

將以下代碼適應您的目的。它等效於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; 
}