Java的繼承陣列的建設和協變返回

Question

（標題聽起來有點太花哨，但我無法找到匹配的，所以我們希望它是描述性的。）

我的代碼工作片如下：

@SuppressWarnings("unchecked") 
public static Copyable[] copyOf(Copyable[] objects, Class type) { 
    Copyable[] copies = Arrays.copyOf(objects, objects.length, type); 
    for(int i=0; i < copies.length; ++i) { 
     if(objects[i] == null) 
      throw new IllegalArgumentException("Copyable[] contains null reference", new NullPointerException()); 
     copies[i] = objects[i].copy(); 
    } 

    return copies; 
} 

不像我想的那麼漂亮，因爲我必須傳入數組類，但它適用於我想要的操作：分配一個可複製實現器的新數組，並使用實現的方法填充它。

我遇到的問題是，這是由GWT編譯的，它的JRE Emulation庫barfs在正確的Java上沒有實現。我需要這樣做，而不調用Arrays.copyOf（），並希望沒有反射。

注：我正在研究一個clone（）版本，但並不真的想依賴clone（）。我覺得必須有一個更清潔的解決方案。

Answer 1

如何：

public static Copyable[] copyOf(Copyable[] objects) { 
    Copyable[] copies = new Copyable[objects.length]; 
    for(int i=0; i < copies.length; ++i) { 
     if(objects[i] == null) 
      throw new IllegalArgumentException("Copyable[] contains null reference", new NullPointerException()); 
     copies[i] = objects[i].copy(); 
    } 
    return copies; 
} 

沒有必要使元素本身的拷貝前的objects數組實際上覆制到copies。

編輯

如果你的可複製對象序列化，你可以序列化和反序列化，然後在數組中創建一個副本。 gwt-test-utils中有一個實用函數DeepCopy.java，它可以完全滿足你的需求。

Answer 2

爲什麼你不能這樣做： Copyable[] copies = new Copyable[objects.length];？ 該行分配了數組，然後您已經使用包含的for循環填充該數組。

Answer 3

與泛型

也許：

public interface Copyable<T> { 
    T copy(); 
} 



import java.lang.reflect.Array; 
import java.util.ArrayList; 
import java.util.List; 

public class Test { 
    static class My implements Copyable<My> { 
    int x; 

    public My copy() { 
     My my = new My(); 
     my.x = this.x; 
     return my; 
    } 
    } 

    @SuppressWarnings("unchecked") 
    public static <T extends Copyable<T>> T[] copyOf(T[] objects, Class<T> type) { 
    List<T> copies = new ArrayList<T>(); 
    for (int i = 0; i < objects.length; ++i) { 
     if (objects[i] == null) throw new IllegalArgumentException("Copyable[] contains null reference", 
      new NullPointerException()); 
     copies.add((T) objects[i].copy()); 
    } 
    T typeVar = null; 
    try { 
     typeVar = (T) Class.forName(type.getName()).newInstance(); 
    } catch (InstantiationException e) { 
     e.printStackTrace(); 
    } catch (IllegalAccessException e) { 
     e.printStackTrace(); 
    } catch (ClassNotFoundException e) { 
     e.printStackTrace(); 
    } 
    Object t = Array.newInstance(typeVar.getClass(),0); 
    return copies.toArray((T[])t); 
    } 

    public static void main(String[] args) { 
    My[] stuff = new My[1]; 
    My elem = new My(); 
    elem.x = 1; 
    stuff[0] = elem; 
    My[] copies = copyOf(stuff, My.class); 
    System.out.println(copies[0].x); 
    } 
} 

Answer 4

大廈GriffeyDog's answer和some fun I had with generics recently，這裏是沒有Class對象的解決方案，直接作用於數組：

@SuppressWarnings("unchecked") 
public static <T extends Copyable> T[] copyOf(T[] objects) { 
    T[] copies = (T[]) new Object[objects.length]; 
    for (int i = 0; i < copies.length; ++i) { 
     if (objects[i] == null) 
      throw new IllegalArgumentException(/*...*/); 
     copies[i] = (T) objects[i].copy(); 
    } 
    return copies; 
} 

Answer 5

你可以依靠clone()用於陣列本身，然後使用您的copy()爲每個對象：

@SuppressWarnings("unchecked") 
public static Copyable[] copyOf(Copyable[] objects) { 
    Copyable[] copies = (Copyable[]) objects.clone(); 
    for(int i=0; i < copies.length; ++i) { 
     if(objects[i] == null) 
      throw etc; 
     copies[i] = objects[i].copy(); 
    } 
    return copies; 
} 

每個數組都實現clone（）方法，該方法返回數組的淺表副本。所以我認爲它足夠乾淨以滿足您的需求。

請注意，這樣，你也不需要參數Class type。