通用方法參數 - Java

Question

我有兩個幾乎相同的方法，但我試圖避免代碼重複。

他們每個人都拿一個獨特的對象作爲參數，並從中找出最高值。

下面是一個例子：

public Integer getHighestIndexValue(List<ObjectA> list) { 
    int highestValue; 
    List<Integer> indexes = new ArrayList<Integer>(); 
    for (ObjectA a: list) { 
     indexes.add(Integer.parseInt(a.getA())); 
    } 
    highestValue = Collections.max(indexes); 

    return highestValue; 

} 

或者：

public Integer getHighestIndexValue(List<ObjectB> list) { 
    int highestValue; 
    List<Integer> indexes = new ArrayList<Integer>(); 
    for (ObjectB b: list) { 
     indexes.add(Integer.parseInt(b.getB())); 
    } 
    highestValue = Collections.max(indexes); 

    return highestValue; 

} 

使用這兩個泛型參數如何合併？

我嘗試創建一個BaseClass，它包含這兩個類並將其擴展到方法簽名中。它仍然需要鑄造。

public <T extends BaseClass> Integer getHighestIndexValue(List<T> objectList) { 
    int highestValue; 
    List<Integer> indexes = new ArrayList<Integer>(); 

    for (T objects: objectList) { 
     indexes.add(Integer.parseInt(objects.getAorB())); ------ this line needs casting 
    } 
    highestValue = Collections.max(indexes); 

    return highestValue; 

} 

我以前使用過泛型但尚未使用泛型參數。

有沒有解決這個辦法嗎？

Answer 1

可以將getA和getB組合成一個單一的接口方法嗎？

例如：

interface ProvidesIndex { 
    Integer getIndex(); 
} 

現在，你可以簡單地調用getIndex，你的方法簽名是：

public Integer getHighestIndexValue(List<? extends ProvidesIndex> list) 

作爲一個側面說明，如果你定義接口來擴展Comparable<ProvidesIndex>即：

interface ProvidesIndex extends Comparable<ProvidesIndex> 

然後您可以使用Collections.max直接在最初的列表上：

List<ProvidesIndex> list = new ArrayList<ProvidesIndex>(); 
list.add(new ObjectA()); 
list.add(new ObjectB()); 
Integer max = Collections.max(list).getIndex(); 

Answer 2

您可以在一個Java命令中執行此操作。下面是這兩個Java 5的和更緊湊的Java 8：

public static class ObjectA { 
    public String getA() { return "1"; /* test */ } 
} 

public static class ObjectB { 
    public String getB() { return "1"; /* test */ } 
} 

// Java 5+ versions 

public static void sampleA7(List<ObjectA> list) { 
    int maxValue = Integer.parseInt(Collections.max(list, new Comparator<ObjectA>() { 
     @Override 
     public int compare(ObjectA a, ObjectA b) { 
      return Integer.parseInt(a.getA()) - Integer.parseInt(b.getA()); 
     } 
    }).getA()); 
} 

public static void sampleB7(List<ObjectB> list) { 
    int maxValue = Integer.parseInt(Collections.max(list, new Comparator<ObjectB>() { 
     @Override 
     public int compare(ObjectB a, ObjectB b) { 
      return Integer.parseInt(a.getB()) - Integer.parseInt(b.getB()); 
     } 
    }).getB()); 
} 

// Java 8+ versions 

public static void sampleA8(List<ObjectA> list) { 
    Optional<Integer> maxValue = list.stream().map(a -> Integer.parseInt(a.getA())).max((a, b) -> a - b); 
} 

public static void sampleB8(List<ObjectB> list) { 
    Optional<Integer> maxValue = list.stream().map(a -> Integer.parseInt(a.getB())).max((a, b) -> a - b); 
} 

Answer 3

通過拉曼添加到答案：

public Integer getHighestIndexValue(List<? extends CommonInterface> list) { 
    int highestValue; 
    List<Integer> indexes = new ArrayList<Integer>(); 

    for (CommonInterface a: list) { 
     indexes.add(Integer.parseInt(a. getIndex())); 
    } 

    highestValue = Collections.max(indexes); 

    return highestValue; 
} 

Answer 4

Guava有一個優雅的解決方案是：

//general purpose function to get A, can be used in transform(), etc 
private static final Function<ObjectA, Integer> GET_A = new Function<>() { 
    @Override 
    public Integer apply(ObjectA a) { 
     return a.getA(); 
    } 
} 

Integer highestIndex = Collections.max(Collections2.transform(list, GET_A)); 

或者，如果你需要指數最高的元素，

ObjectA highest = Ordering.natural().onResultOf(GET_A).max(list); 

然後將其擴展爲ObjectB，您只需實現一個GET_B函數。

再回到您的輔助方法（現在基本上是無關緊要的，你有一個班輪）：

public <T> Integer getHighestIndex(List<? extends T> list, Function<? super T, Integer> indexPlucker) { 
    return Collections.max(Collections2.transform(list, indexPlucker)); 
} 

Answer 5

它可能不是一個好主意，如果你想使這個代碼的通用，使用一個整數的ArrayList來做實際的比較。如果其中一個對象是一個Long，比你的最大整數大？相反，你的目標必須與某種方式，這樣你就可以找到「最大」（什麼是最大的一組字符串的？）

所以我想嘗試這樣的

import java.util.List; 

public abstract class MathMax<E> { 
    public abstract boolean isGreaterThan(E x1, E x2); 
    public E getHighestIndexValue(List<E> list){ 
     E highestValue = null; 
     for (E a: list) { 
      if (isGreaterThan(a,highestValue)){ 
       highestValue = a; 
      } 
     } 
     return highestValue; 
    } 
} 

和

的方法

import java.util.ArrayList; 
import java.util.List; 

public class MathMaxA extends MathMax<ObjectA> { 

    @Override 
    public boolean isGreaterThan(ObjectA x1, ObjectA x2) { 
     // do your comparison here, careful with null values 
     return false; 
    } 

    public static void main(String[] args) { 
     MathMaxA m = new MathMaxA(); 
     List<ObjectA> list = new ArrayList<ObjectA>(); 
     System.out.println(m.getHighestIndexValue(list)); 
    } 
}