Newsgroup: it.comp.java
Titolo: Errore array multidimensionale costante

Ho provato a dichiarare l'array in questo modo:
    private static final String[][] voltoA;
    voltoA = {"-", "destra", "avanti", "sinistra"; "sinistra", "-",
"destra", "avanti"; "avanti", "sinistra", "-", "destra"; "destra", "avanti",
"sinistra", "-"};
Però mi viene ritornato questo errore:
Percorsi.java [24:1] <identifier> expected
    voltoA={"-", "destra", "avanti", "sinistra"; "sinistra", "-", "destra",
"avanti"; "avanti", "sinistra", "-", "destra"; "destra", "avanti",
"sinistra", "-"};
          ^
Come posso risolvere?
Grazie.

 ha scritto nel messaggio
news:ipRQc.83841$OR2.4...@news3.tin.it...

Prima alloca la memoria per l' array : voltoA=new String[dim1][dim2];
poi gli assegni i valori.
---
Outgoing mail is certified Virus Free.
Checked by AVG anti-virus system (
http://www.grisoft.com
).
Version: 6.0.735 / Virus Database: 489 - Release Date: 06/08/2004

 "sinistra", "-"};
 > [cut]
A quanto ne so io (ma per fortuna non m'č capitato spesso di doverli 
usare) gli array multi-dimensionali vanno inizializzati cosě:
voltoA = {
           {"1","2","3","4"},
           {"1","2","3","4"},
           {"1","2","3","4"},
           {"1","2","3","4"}
          };
Ciao! :)
	Giorgio

 "sinistra", "-"};
Veramente l'errore che viene dato a me e' completamente diverso.
Innanzitutto mi viene dato: "Array constants can only be used in 
initializers"
Questo vale anche per gli array semplici. Ad esempio l'inizializzazine 
corretta di un array di stringhe è:
String[] colori = new String[]{"blu", "rosso", "verde"};
Il secondo problema è che cerchi di inizializzare un array 
bidimensionale con una cosa che sembra tanto un array monodimensonale 
(la stringa "-" non ha certo alcun significato particolare per il 
compilatore).
Direi che nel tuo caso avresti dovuto scrivere qualcosa del tipo:
private static final String[][] voltoA = new String[][]
     {
       {"-", "destra", "avanti", "sinistra", "sinistra"},
       {"-", "destra", "avanti"; "avanti", "sinistra"},
       {"-", "destra"; "destra", "avanti", "sinistra"}
       {"-"}
     };
in questo modo voltoA e' un array di 4 righe. Sulle prime tre righe ci 
sono 5 colonne, mentre sulla quarta c'e' una sola colonna (tieni 
presente che in un array bidimensionale ogni riga è un array 
monodimensionale la cui dimensone può essere diversa da quella delle 
altre righe).
Andrea

 String[] colori = new String[]{"blu", "rosso", "verde"};
Mi sono ricordato adesso che l'operatore new può essere omesso, se si 
inizializza una variabile al momento della sua dichiarazione, e quindi 
puoi scrivere:
String[] colori = {"blu", "rosso", "verde"};
Non puoi però scrivere:
String[] colori;
...
colori = {"blu", "rosso", "verde"};
          ^^^^^^^^^^^^^^^^^^^^^^^^^
 >Array constants can only be used in initializers
Se hai bisogno di assegnare una variabile dopo la dichiarazione devi 
obbligatoriamente scrivere:
String[] colori;
...
colori = new String[]{"blu", "rosso", "verde"};
Andrea


Comunque come è stato già detto è il caso al momento della 
inizializzazione dargli una dimensione.
String[][] colori = new String[dim1][dim2];
e poi gli passi i valori!

 e poi gli passi i valori!
Dipende. Ha senso se si vuole impostare i singoli valori:
     String[][] prova = new String[2][2];
     prova[0][0] = "00";
     prova[0][1] = "01";
     prova[1][0] = "10";
     prova[1][1] = "11";
Non ha senso se poi si vuole utilizzare un array costante. Ad esempio:
    String[][] prova;
    prova = new String[][]{ {"00", "01"}, {"10", "11} };
IMO questa notazione, oltre ad essere piu' compatta è anche più leggibile.
Occorre ricordarsi poi che la dimensione dell'array non fa parte del 
tipo. Questo significa che posso assegnare ad una variabile array di 
dimensione diversa:
    String[][] prova1 = new String[1][1];
       // prova1 è un (riferimento a un) array bidimensionale di una
       // riga e una colonna
    Stinrg[][] prova2 = { {"00", "01"}, {"10", "11} };
       // prova2 è un array bidimensionale di due righe e due colonne
    prova1 = prova2; // OK, ora prova1 ha 2 righe e 2 colonne
Per questo motivo scrivere:
    String[][] prova = new String[2][2];
    prova = new String[][]{ {"00", "01"}, {"10", "11} };
oltre ad essere inutile e dispendioso (l'array che si crea nella 
dichiarazione, in realta', non verrà mai utilizzato e serve solo a far 
lavorare il GC) è anche fuorviante perché nulla impone che la dimensione 
dell'array sia quella specificata nella dichiarazione.
Andrea

 Andrea
Si hai ragione, la soluzione va scelta in base a quel che si deve fare! 
Certo che se i valori si devono inserie tutti insieme allora hai ancora 
più ragione!
Cmq spero di non andare troppo OT, una curiosità visto che le due 
soluzioni sono quasi equivalenti quale preferisci!?
Qualla String[][] prova = { ... } oppure la String[][] prova = new 
String[dim1][dim2] (e successivamente l'assegnazione dei valori) ?
Comunque non è detto che la dichiarazione dell'array e l'assegnazione 
dei valori avvengano nello stesso luogo. Sul fatto poi che String[][] 
prova = { ... } sia più legibile si hai ragione.
Ciao,
jRed

 dei valori avvengano nello stesso luogo.
Se è solo un problema di luogo basta spezzare inizializzazione e 
dichiarazione.
String[][] prova;
...
prova = new String[][]{ {"00", "01"}, {"10", "11} };
Se invece il problema è che i valori sono conosciuti solo a runtime 
(letti da file? input dell'utente? ecc.) ovviamente hai ragione.
Andrea