如何在運行時創建通用集合<T>？

Question

我正在寫一個方法，用「Predicate」過濾特定集合，並返回一個僅包含過濾元素的新集合（Predicate返回true的集合）。

事情是這樣的：

public <T> Collection<T> filter(Collection<T> collection, Closure<T> predicate); 

我知道，在Java中，我不能只在運行時創建一個新的Collection()，因爲類型擦除的。

我也通過向方法傳遞一個額外參數來調用T.newInstance（）來了解「解決方法」。

這看起來像：

public <T> Collection<T> filter(Class<? extends Collection<T>> collectionToInstanciate, Collection<T> collection, Closure<T> predicate) { 

     // create the new Collection 
     Collection<T> container = collectionToInstanciate.newInstance(); 

     // and then add only filtered items 
     Iterator<T> iter = collection.iterator(); 
     while (iter.hasNext()) { 
      T obj = iter.next(); 

      // if Predicate.invoke() returns true, then keep element, otherwise skip it 
      if (predicate.invoke(obj)) { 
       container.add(obj); 
      } 
     } 
     return container; 
    } 

但我應該怎麼叫我的方法是什麼？

舉例來說，如果我想只有一列整數的奇數，我想要做的：

// instanciate ArrayList<Integer> = [1, 2, 3, 4, 5] 
    ArrayList<Integer> array = ...; 

    // return a new LinkedList<Integer> with only odd numbers 
    filter(LinkedList<Integer>.class, array, new Closure<Integer>() { 
     public Boolean invoke(Integer arg_p) { 
      return (arg_p % 2 == 0); 
     } 
    }); 

    // should return [2, 4] as a LinkedList<Integer> 

的問題是，

LinkedList<Integer>.class 

不能編譯。

我該如何聲明，以正確instanciate過濾器（）方法LinkedList？

問候，

Answer 1

泛型是一個編譯時功能，並擁有在運行時沒有什麼意義。如果你想創建一個LinkedList，那就是你所做的。你不能讓編譯器根據你在運行時做的事情給你一個錯誤。

更簡單的解決方案是傳遞您想要填充的類的實例。

List<Integer> result = filter(new LinkedList<Integer>(), array, 
    new Predicate<Integer>() { 
     public boolean invoke(Integer arg_p) { 
      return (arg_p % 2 == 0); 
     } 
    }); 

它稍微短一點，可以在編譯時檢查。

注意：這些謂詞中的很多作爲一個簡單的循環要簡單得多，速度更快。

List<Integer> result = new LinkedList<Integer>(); 
for(Integer i: array) 
    if (i % 2 == 0) 
     result.add(i); 

Answer 2

身邊的另一種方式，從彼得Lawrey答案，並LuiggiMendoza的評論，是利用過濾器（）方法是這樣的：

List<Integer> result = filter(
     LinkedList.class, // instead of new LinkedList<Integer>() 
     array, 
     new Predicate<Integer>() { 
      public boolean invoke(Integer arg_p) { 
       return (arg_p % 2 == 0); 
      } 
     }); 

，在過濾（）方法：

public <T> Collection<T> filter(Class<? extends Collection> collectionToInstanciate, Collection<T> collection, Closure<T> predicate) { 

    // create the new Collection as a raw Collection, and cast it back to Collection<T> 
    Collection<T> container = (Collection<T>) collectionToInstanciate.newInstance(); 

    // and then add only filtered items 
    Iterator<T> iter = collection.iterator(); 
    while (iter.hasNext()) { 
     T obj = iter.next(); 

     // if Predicate.invoke() returns true, then keep element, otherwise skip it 
     if (predicate.invoke(obj)) { 
      container.add(obj); 
     } 
    } 
    return container; 
}