“Imansible creare array generico di ..” – come creare una matrice di Map ?

Vorrei usare la class simpleJdbcInsert e il metodo executeBatch

public int[] executeBatch(Map[] batch) 

http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/jdbc/core/simple/SimpleJdbcInsert.html

Quindi ho bisogno di passare un array di Map come parametro. Come creare un tale array? Quello che ho provato è

 Map[] myArray = new HashMap[10] 

È un errore: imansible creare un array generico di Map

Una List<Map> sarebbe più semplice, ma suppongo di aver bisogno di un array. Quindi, come creare un array di Map ? Grazie

A causa del modo in cui i farmaci generici in Java funzionano, non è ansible creare direttamente una matrice di un tipo generico (come Map[] ). Invece, si crea una matrice del tipo non elaborato ( Map[] ) e si esegue il cast su Map[] . Ciò causerà un avvertimento del compilatore inevitabile (ma sopprimibile).

Questo dovrebbe funzionare per quello di cui hai bisogno:

 Map[] myArray = (Map[]) new Map[10]; 

Si consiglia di annotare il metodo in cui si verifica con @SupressWarnings("unchecked") , per impedire che venga visualizzato l’avviso.

È ansible creare un array di mappe generico.

  1. Crea un elenco di mappe.

     List> myData = new ArrayList>(); 
  2. Inizializza array.

     Map[] myDataArray = new HashMap[myData.size()]; 
  3. Popolare i dati nella matrice dalla lista.

     myDataArray = myData.toArray(myDataArray); 

Ho avuto qualche difficoltà con questo, ma ho capito alcune cose che condividerò il più semplicemente ansible.

La mia esperienza con i generici è limitata alle raccolte, quindi le uso nelle definizioni di class, come ad esempio:

 public class CircularArray { 

che contiene il membro dati:

 private E[] data; 

Ma non puoi fare e array di tipo generico, quindi ha il metodo:

 @SuppressWarnings("unchecked") private E[] newArray(int size) { return (E[]) new Object[size]; //Create an array of Objects then cast it as E[] } 

Nel costruttore:

 data = newArray(INITIAL_CAPACITY); //Done for reusability 

Questo funziona per generici generici, ma avevo bisogno di una lista che potesse essere ordinata: una lista di Comparables.

 public class SortedCircularArray> { //any E that implements Comparable or extends a Comparable class 

che contiene il membro dati:

 private E[] data; 

Ma la nostra nuova class lancia java.lang.ClassCastException:

 @SuppressWarnings("unchecked") private E[] newArray(int size) { //Old: return (E[]) new Object[size]; //Create an array of Objects then cast it as E[] return (E[]) new Comparable[size]; //A comparable is an object, but the converse may not be } 

Nel costruttore tutto è uguale:

 data = newArray(INITIAL_CAPACITY); //Done for reusability 

Spero che questo aiuti e spero che i nostri utenti più esperti correggeranno me se ho commesso degli errori.

Dal tutorial di Oracle [ sic ]:

Non è ansible creare matrici di tipi parametrizzati. Ad esempio, il seguente codice non viene compilato:

 List[] arrayOfLists = new List[2]; // compile-time error 

Il seguente codice illustra cosa succede quando diversi tipi vengono inseriti in un array:

 Object[] strings = new String[2]; strings[0] = "hi"; // OK strings[1] = 100; // An ArrayStoreException is thrown. 

Se provi la stessa cosa con una lista generica, ci sarebbe un problema:

 Object[] stringLists = new List[]; // compiler error, but pretend it's allowed stringLists[0] = new ArrayList(); // OK stringLists[1] = new ArrayList(); // An ArrayStoreException should be thrown, // but the runtime can't detect it. 

Se sono stati consentiti array di elenchi parametrizzati, il codice precedente non riusciva a generare l’ArrayStoreException desiderato.

Per me, sembra molto debole. Penso che qualsiasi programmatore con una sufficiente conoscenza dei generici, sarebbe perfettamente a posto e si aspetterebbe addirittura che l’ArrayStoredException non venga lanciata in questo caso.

Ancor più, la maggior parte dei programmatori semplicemente farà:

 List arrayOfLists = (List) new List[2]; 

che li metterà esattamente nello stesso rischio che l’ArrayStoreException non viene lanciata.

Per quanto mi riguarda

Frist prova a creare un array di java.lang.Object e quindi a generare il tipo generico T

Esempio:

 class Example{ public DataType array = (DataType[]) new Object[5] ; } 

In questo modo, puoi creare una serie di tipi di dati generici