Non è possibile creare un array di LinkedList in Java ...?

Sto lavorando su una classe di matrice sparsa che deve utilizzare un array di LinkedListper memorizzare i valori di una matrice. Ogni elemento della matrice (cioè ciascuno LinkedList) rappresenta una riga della matrice. Inoltre, ogni elemento nella LinkedListmatrice rappresenta una colonna e il valore memorizzato.

Nella mia classe, ho una dichiarazione dell'array come:

private LinkedList<IntegerNode>[] myMatrix;

E, nel mio costruttore per il SparseMatrix, cerco di definire:

myMatrix = new LinkedList<IntegerNode>[numRows];

L'errore che finisco per ottenere è

Impossibile creare un array generico di LinkedList<IntegerNode>.

Quindi, ho due problemi con questo:

1. Cosa sto facendo di sbagliato, e
2. Perché il tipo è accettabile nella dichiarazione per l'array se non può essere creato?

IntegerNodeè una classe che ho creato. E tutti i miei file di classe sono impacchettati insieme.

Non è possibile utilizzare la creazione di array generici. È un difetto / caratteristica dei generici java.

I modi senza avvisi sono:

1. Utilizzo di List of Lists invece di Array of Lists:

   List< List<IntegerNode>> nodeLists = new LinkedList< List< IntegerNode >>();

2. Dichiarazione della classe speciale per Array of Lists:

   class IntegerNodeList {
       private final List< IntegerNode > nodes;
   }
   

Per qualche motivo devi eseguire il cast del tipo e fare la dichiarazione in questo modo:

myMatrix = (LinkedList<IntegerNode>[]) new LinkedList<?>[numRows];

A parte i problemi di sintassi, mi sembra strano usare un array e un elenco collegato per rappresentare una matrice. Per poter accedere a celle arbitrarie della matrice, probabilmente vorresti un array effettivo o almeno un ArrayListper contenere le righe, poiché LinkedListdevi attraversare l'intero elenco dal primo elemento a qualsiasi elemento particolare, O(n)un'operazione, al contrario di molto più veloce O(1)con ArrayListo un array effettivo.

Dato che hai menzionato che questa matrice è scarsa, forse un modo migliore per memorizzare i dati è come una mappa di mappe, dove una chiave nella prima mappa rappresenta un indice di riga e il suo valore è una mappa di riga le cui chiavi sono un indice di colonna , con il valore che è la tua classe IntegerNode. Così:

private Map<Integer, Map<Integer, IntegerNode>> myMatrix = new HashMap<Integer, Map<Integer, IntegerNode>>();

// access a matrix cell:
int rowIdx = 100;
int colIdx = 30;
Map<Integer, IntegerNode> row = myMatrix.get(rowIdx); // if null, create and add to matrix
IntegerNode node = row.get(colIdx); // possibly null

Se devi essere in grado di attraversare la matrice riga per riga, puoi fare in modo che la mappa di riga digiti a TreeMap, e lo stesso per attraversare le colonne in ordine di indice, ma se non hai bisogno di quei casi, HashMapè più veloce di TreeMap. I metodi di supporto per ottenere e impostare una cella arbitraria, gestendo valori nulli non impostati, sarebbero utili, ovviamente.

class IntegerNodeList extends LinkedList<IntegerNode> {}

IntegerNodeList[] myMatrix = new IntegerNodeList[numRows]; 

myMatrix = (LinkedList<IntegerNode>[]) new LinkedList[numRows];

lanciare in questo modo funziona ma ti lascia comunque con un brutto avvertimento:

"Sicurezza del tipo: l'espressione di tipo List [] richiede una conversione non selezionata .."

Dichiarazione di una classe speciale per array di elenchi:

class IntegerNodeList { private final List< IntegerNode > nodes; }

è un'idea intelligente per evitare l'avviso. forse un po 'più bello è usare un'interfaccia per questo:

public interface IntegerNodeList extends List<IntegerNode> {}

poi

List<IntegerNode>[] myMatrix = new IntegerNodeList[numRows];

si compila senza avvisi.

non sembra tanto male, vero?

List<String>[] lst = new List[2];
lst[0] = new LinkedList<String>();
lst[1] = new LinkedList<String>();

Nessun avvertimento. NetBeans 6.9.1, jdk1.6.0_24

Non esiste una creazione di array generici in Java 1.5 (o 1.6 per quanto ne so). Vedi https://community.oracle.com/message/4829402 .

Se eseguo le operazioni seguenti, viene visualizzato il messaggio di errore in questione

LinkedList<Node>[] matrix = new LinkedList<Node>[5];

Ma se rimuovo solo il tipo di elenco nella dichiarazione, sembra che abbia la funzionalità desiderata.

LinkedList<Node>[] matrix = new LinkedList[5];

Queste due dichiarazioni sono drasticamente diverse in un modo di cui non sono a conoscenza?

MODIFICARE

Ah, penso di essermi imbattuto in questo problema ora.

L'iterazione sulla matrice e l'inizializzazione degli elenchi in un ciclo for sembrano funzionare. Anche se non è l'ideale come alcune delle altre soluzioni offerte.

for(int i=0; i < matrix.length; i++){

    matrix[i] = new LinkedList<>();
}

Hai bisogno di un array di List, un'alternativa è provare:

private IntegerNode[] node_array = new IntegerNode[sizeOfYourChoice];

Quindi node_array[i]memorizza il (primo) nodo head di un ArrayList<IntegerNode>o LinkedList<IntegerNode>(qualunque sia l'implementazione dell'elenco dei preferiti).

Con questo design, perdi il metodo di accesso casuale list.get(index), ma puoi comunque attraversare l'elenco iniziando con l'archivio del nodo head / fist nell'array type safe.

Questa potrebbe essere una scelta progettuale accettabile a seconda del tuo caso d'uso. Ad esempio, utilizzo questo design per rappresentare un elenco di grafo di adiacenza, nella maggior parte dei casi d'uso richiede comunque di attraversare l'elenco di adiacenza per un dato vertice invece di accedere casualmente a qualche vertice nell'elenco.