Common Ancestor a Java Array e List

Question

In .NET, sia la matrice che l'elenco hanno Enumerable come antenato, quindi un metodo che accetta Enumerable come argomento può ricevere sia array che list come argomento. Mi chiedo se c'è qualcosa di simile in Java?

Answer 1

No, non c'è alcun equivalente in Java. In genere suggerisco di progettare metodi API per ricevere List<T>, Collection<T> o Iterable<T>. Mentre questi precludono allo direttamente al chiamando il metodo con un array, è possibile racchiudere un array molto facilmente usando Arrays.asList. Questo è più flessibile per il chiamante rispetto alla specifica di un array come parametro del metodo, che forza una singola implementazione.

Sono d'accordo che non è l'ideale però.

Si noti che in .NET, gli array monodimensionali non implementano solo IEnumerable<T> - implementano anche IList<T>.

Answer 2

Entrambi derivano da java.lang.Object. Tuttavia, questo non è legato alla collezione, che penso sia quello che stai cercando.

Answer 3

L'array e l'elenco in Java non condividono un antenato comune diverso da java.lang.Object.

Entrambi può accedere utilizzando il ciclo foreach, in questo modo:

String [] array = new String [] { "foo", "bar", "baz", }; 
List<String> list = Arrays.asList("x", "y", "z"); 

for (String s : array) 
    System.out.println(s); 

for (String s : list) 
    System.out.println(s); 

Answer 4

Non hanno un antenato comune, tuttavia, ci sono metodi per lanciare tra i due tipi a seconda delle necessità -

• List.toArray()
• Arrays.asList()

Così si potrebbe fornire un sovraccarico metodo per trasmettere a un tipo comune, ad esempio

public void doAll(MyType[] array) { 
    doAll(Arrays.asList(array)); 
} 

public void doAll(List<MyType> list) { 
    //... process List here. 
} 

Answer 5

Fondamentalmente, gli array hanno un tipo implicito che è una sottoclasse di oggetto. Vedere Arrays nella JLS:

public static void main(String[] args) { 
      int[] ia = new int[3]; 
      System.out.println(ia.getClass()); 
      System.out.println(ia.getClass().getSuperclass()); 
    } 

    > class [I 
    > class java.lang.Object 

Il modo in cui gli array e le liste sono gestite inoltre, non è lo stesso se si considera covariance/contravariance.

List<Object> l = new ArrayList<String>(); // complain 
Object[] l2 = new String[1]; // ok 

l2[0] = 4; // throw ArrayStoreException. 

Diventa ancora peggio se consideriamo i farmaci generici, ma questo è un altro argomento. Tutto sommato, non conosco la logica di questo progetto, ma dobbiamo conviverci.

Answer 6

Iterable<T> è l'equivalente Java di IEnumerable<T>. Tutte/la maggior parte delle collezioni implementano questa interfaccia (incluso ArrayList e array), quindi sì. Ma non è un "antenato" (che non è nemmeno in .NET), ma un'interfaccia comune.