Designing einzigen API für zwei verschiedene Typen

Question

Ich habe zwei Listen:

List<Date> list1 = new ArrayList<Date>(); 
List<WDate> list2 = new ArrayList<WDate>(); 

Ich möchte einige Objekte aus diesen Listen entfernen. Diese Funktionalität ist in einer util-Klasse vorhanden.

public static List<Date> removeFromList1(List<Date> dateList) 
{ 
    Iterator<Date> dateItr = dateList.iterator(); 
    while(dateItr.hasNext()) 
    { 
     Date date = dateItr.next(); 
     if(date.compareTo(currentDate) <= 0) 
      dateItr.remove(); 
    } 

    return dateList; 
} 

public static List<WDate> removeFromList2(List<WDate> dateList) 
{ 
    Iterator<WDate> dateItr = dateList.iterator(); 
    while(dateItr.hasNext()) 
    { 
     WDate date = dateItr.next(); 
     if(date.getDate().compareTo(currentDate) <= 0) 
      dateItr.remove(); 
    } 

    return dateList; 
} 

class WDate 
{ 
    Date date; 
    Date getDate() { return date;} 
} 

Wie eine einzelne Dienstprogramm Methode erstellen sowohl die Listen zu dienen? Hier

Answer 1

ist eine mögliche Lösung:

public static <T extends Comparable<T>> List<T> removeFromList(List<T> list, T current) 
{ 
    Iterator<T> itr = list.iterator(); 
    while(itr.hasNext()) 
    { 
     T elm = itr.next(); 
     if(elm.compareTo(current) <= 0) 
      itr.remove(); 
    } 

    return list; 
} 

...

class WDate implements Comparable<WDate> 
{ 
    Date date; 
    Date getDate() { return date;} 

    public WDate(Date date) { 
     this.date = date; 
    } 
    @Override 
    public int compareTo(WDate other) { 
     return date.compareTo(other.date); 
    } 
} 

UPDATE:

Wenn Sie die vergleichbare Schnittstelle implementieren vermeiden wollen, können Sie einen Komparator liefern removeFromList:

public static <T> List<T> removeFromList(List<T> list, T current, 
     Comparator<T> comp) { 
    Iterator<T> itr = list.iterator(); 
    while(itr.hasNext()) 
    { 
     T elm = itr.next(); 
     if(comp.compare(elm, current) <= 0) 
      itr.remove(); 
    } 
    return list; 
} 

UPDATE 2 (für davidxxx)

public static List<Date> removeFromList1(List<Date> dateList) 
{ 
    return removeFromList(dateList, currentDate.getDate()); 
} 

public static List<WDate> removeFromList2(List<WDate> dateList) 
{ 
    return removeFromList(dateList, currentDate); 
} 

Answer 2

Wie Sie nicht eine gemeinsame Schnittstelle für die zwei Arten von Date (java.util.date nicht veränderbar ist) vorstellen können, können Sie nicht eine einzige Methode haben, die die Sicherheit durch eine gebracht hätte Feine Generika verwenden: der einzige gemeinsame Vorfahre ist Object ...
Persönlich denke ich, dass Sie die beiden Methoden, die die sauberste Art und Weise mit Ihren Einschränkungen halten sollten.
Warum? Ich werde versuchen, Risiken zu erklären.
Wenn Sie eine einzige Methode verwenden, wie gesagt, Sie hätten keine Typsicherheit und Sie würden die Verantwortlichkeiten Ihrer Hilfsmethode erhöhen, da sie vorher eine Typprüfung durchführen sollte, um ihre Verarbeitungen durchführen zu können.

Zum Beispiel können Sie tun:

public static <T> List<T> removeFromList(List<T> dateList) { 

    Iterator<T> dateItr = dateList.iterator(); 

    while (dateItr.hasNext()) { 
    T date = dateItr.next(); 

    // check if null value otherwise illegalArgumentexception may be thrown 
    if (date == null) { 
     continue; 
    } 

    // check types 
    boolean isEquals = false; 
    if (date instanceof Date) { 
     if (currentDate.equals(date)) { 
     isEquals = true; 
     } 
    } 
    else if (date instanceof WDate) { 
     WDate wDate = (WDate) date; 
     if (currentDate.equals(wDate.getDate())) { 
     isEquals = true; 
     } 
    } 
    // if unexpected type, we rise an exception 
    else { 
    throw new IllegalArgumentException("type not supported=" + date.getClass()); 
    }  

    //perform removing 
    if (isEquals){ 
     dateItr.remove(); 
    } 
    } 

    return dateList; 
} 

und Sie nun die Methode wie folgt aufrufen:

List<WDate> wdates = new ArrayList<>(); 
WDate wdate = new WDate(); 
wdates.add(wdate); 
removeFromList(wdates); 

Das Problem ist, dass man das Verfahren mit jeder Art in der Liste jetzt:

So werden einige Fehler, die zur Kompilierzeit entdeckt werden konnten, erst zur Laufzeit erkannt n IllegalArgumentException wird ausgelöst.