Newsgroup: it.comp.java
Titolo: Problema parsing

Voglio far leggere una matrice da file txt per poi poterci lavorare. Ho 
effettuato il parsing in Double per ciascun token, utilizzando la classe 
StringTokenizer e assegnando il risultato del parsing all' elemento ij della 
matrice.
tanto per capirsi:
...
     String str=inputfile.readLine();
     while(str!=null){
        StringTokenizer elemento= new StringTokenizer(str);
        for(i=0; i<righe; i++){
          for(j=0; j<colonne; j++){
            while(elemento.hasMoreTokens()){
              matrice[i][j]=Double.parseDouble(elemento.nextToken( ));
              System.out.print(matrice[i][j]+" ");
            }
          }
        }
        str=inputfile.readLine();
        System.out.println();
...
Ho aggiunto le righe ""System.out.print(matrice[i][j]+" "); e 
"System.out.println();" proprio per vedere se ho fatto giusto. 
Effettivamente la stampa a video riproduce perfettamente la matrice che ho 
nel file. Succede però una cosa strana: interrogando l' elemento generico, 
matrice[i][j], restituisce sempre zero (essendo double 0.0 ovviamente) a 
parte il valore matrice[0][0], che in realtà è l'ultimo elemento(ultima riga 
ultima colonna). Dove sta l'errore? Ringrazio quanti mi potranno aiutare, 
sono nuovo del java, sto imparando ma mi attizza un casino.. ;-) 

 Dove sta l'errore?
Che hai messo il ciclo while(elemento.hasMoreTokens()) dentro ai due 
for, quindi di fatto stai assegnando ogni valore sempre alla stessa 
coppia di indici (0,0 appunto).
Saluti
CarMas

sospetto che tu non abbia valorizzato i campi righe e colonne che
quindi varranno sempre zero.
In pratica valorizzi sempre l'elemento [0][0]

Lo so ma se lo metto subito prima dei cicli for lo compilo ma nell'
esecuzione mi da l' eccezione NoSuchElementException dopo avermi
visualizzato solo il primo array. Mi si ferma tutto, anche gestendo
l'eccezione, ovviamente non cambia nulla. Non trova elementi nel file,
a parte la prima riga. Ecco il codice modificato:
while(str2!=null){
        StringTokenizer elemento= new StringTokenizer(str2);
        while(elemento.hasMoreTokens()){
        for(i=0; i<righe; i++){
          for(j=0; j<colonne; j++){
              matrice[i][j]=Double.parseDouble(elemento.nextToken( ));
              System.out.print(matrice[i][j]+" ");
            }
          }
        }
        str2=inputfile2.readLine();
          System.out.println();

Ho creato una classe in cui si determinano in automatico il numero di
righe e colonne, quindi imposto la matrice con matrice[righe][colonne],
con righe e colonne che sono int.

 sono nuovo del java, sto imparando ma mi attizza un casino.. ;-) 
Se e' un esercizio, l'errore te lo devi trovare tu! ;)
Se nel file ci puo' essere una sola matrice...
...se ogni riga del file contiene i dati di una riga della matrice...
...se ragioni sul funzionamento dei cicli for...
...se leggi la documentazione di StringTokenizer...
E' facile, dai! ;)
Ciao!
Roberto

Vedi, io mi sto laureando in economia (lunedì prox tra l' altro), sono
a casa da lavoro in permesso e nn ho tanto tempo di fare esercizio
anche se mi ci metterei volentieri... Cmq grazie prof, se mi dici così
vuol dire che la soluzione c'è da qualche parte.

 vuol dire che la soluzione c'č da qualche parte.
Vabbe', un aiutino... ;)
Nella tua prima versione:
[...]
      String str=inputfile.readLine();
      while(str!=null){
         StringTokenizer elemento= new StringTokenizer(str);
         for(i=0; i<righe; i++){
           for(j=0; j<colonne; j++){
             while(elemento.hasMoreTokens()){
               matrice[i][j]=Double.parseDouble(elemento.nextToken( ));
               System.out.print(matrice[i][j]+" ");
             }
           }
         }
[...]
se leggi quello che hai scritto ti accorgerai che, per ogni
riga letta dal file, con i due for annidati fai una scansione
completa di tutte le righe e di tutte le colonne della matrice,
e non mi sembra questo quello che devi fare...
Se sei attento, e' pure ovvio il motivo per il
quale a video la matrice (in apparenza!) te la vedi giusta...
ATTENTO: e' una pura questione algoritmica. Java non c'entra nulla.
Nella tua seconda versione, invece:
[...]
while(str2!=null){
         StringTokenizer elemento= new StringTokenizer(str2);
         while(elemento.hasMoreTokens()){
         for(i=0; i<righe; i++){
           for(j=0; j<colonne; j++){
               matrice[i][j]=Double.parseDouble(elemento.nextToken( ));
               System.out.print(matrice[i][j]+" ");
             }
           }
         }
[...]
per ogni riga letta, di nuovo con i due for annidati fai una scansione
completa di tutte le righe e di tutte le colonne della matrice,
ma hai spostato fuori il test di hasMoreElements(), quindi esaurisci
gli elementi disponibili molto prima di avere completato la scansione
della matrice, da cui l'eccezione...
Suggerimento: per *ogni* riga letta da file devi compilare *una sola*
riga della matrice!
Ciao!
Roberto
PS. Anch'io ho fatto lo studente-lavoratore (ingegneria), ma cio'
non significa che potessi "tirare via" nello studio... ;)

non significa che potessi "tirare via" nello studio... ;)
Eh eh, lo so... in effetti mancano solo 8 giorni.... e tutto ormai è
pronto..... vabbè dai per stasera mi dedico ai source...
Ti ringrazio per la tua gentilezza. Effettivamente ho cannato di brutto
nei cicli for. Mo 'rebuildo' il codice. Grazie Roberto!!!

 
In bocca al lupo! ;)
Ciao!
Roberto

Ho risolto!!!!!! Grazie Roberto! Per sicurezza ti posto il listato! Cmq
funziona!!!!
BufferedReader inputfile2 = new BufferedReader(new
FileReader("prova.txt"));
     double matrice[][] = new double[righe][colonne];
     String str2;
     for(i=0; i<righe; i++){
       str2=inputfile2.readLine();
       StringTokenizer elemento= new StringTokenizer(str2);
       while(elemento.hasMoreTokens()){
         for(j=0; j<colonne; j++){
          matrice[i][j]=Double.parseDouble(elemento.nextToken());
          System.out.print(matrice[i][j]+" ");
         }
       }
       System.out.println();
     }
     inputfile2.close();
Grazie mille!!!!
Vista la tua buonanima ne approfitto...:
La mia idea è quella di implementare un programmino che legga matrici
ca file (e qui ci siamo...;-)) e possa lavorare sulle matrici stesse
(es: calcolo determinante autovalori ecc ecc). Tu mi dirai: "Usare
Matlab...? No eh?". Ma  sto imparando per cui per imparare faccio pure
questo. Volevo fare in modo che i metodi della classe che chiamerò ad
esempio OperazMatrici{...} abbiano come argomento il file su cui voglio
lavorare. Il tutto, prima ancora di implementare interfacce grafiche
gestendo ad es l'evento  "apri file", da riga di comando (es: digitando
il percorso corretto del file convertendo la stringa in un path
assoluto). Non ti chiedo la soluzione ma una indicazione su che
documentazione seguire, presumo java.io.file.* et similia. Ciao e
grazie ancora.

 documentazione seguire, presumo java.io.file.* et similia. Ciao e
java.io.File e' la classe che ti permette di fare quello che
chiedi e la relativa documentazione del JDK e piu' che esauriente.
Se hai domande specifiche, chiedi pure...
Ciao!
Roberto

Vabbe', del resto devi diventare "economista", mica informatico... ;)
Infatti, ma forse mi sono spiegato male, io ho scritto che voglio
implementare un programmino, non una classe;). Il codice che ho
postato, del quale mi stai pazientemente illuminando, è relativo alla
Classe LeggiMatrice (o MatrixReader, che fa più figo ;)), mentre tutte
le possibili operazioni volevo metterle nella classe denominata ad es.
OperazMatrici (o qualcosa di + figo...). A Robe' intanto te ringraziu
assaje. Se volessi chiederti qualcosa che mezzo preferisci, un post con
dedica?
Ciao e ancora grazie tante.

 Ciao e ancora grazie tante.
Quando programmi ad oggetti, non e' necessaria molta fantasia per
i nomi: se stai "modellando" una matrice, allora e' naturale chiamare
la corrispondente classe...Matrice!!
Uno scheletro possibile:
[...]
public class Matrice
{
    private double[][] values;	
    private int rows;
    private int cols;
    private Matrice()
    {
       // Lo usi quando carichi da file!
    }
    public Matrice(double[][] values)
    {
       // Qui e' meglio copiare l'array passato su quello locale
       // e non limitarsi a memorizzare il reference
       // Per intenderci, non limitarsi ad un this.values = values!
       // Perche'?
    }
    public static Matrice loadFromFile(File f)
    {
      ...
    }
    public int numRows() { return rows; }
    public int numCols() { return cols; }
    public Matrice add(Matrice m) throws IllegalArgumentException
    {
      ...
    }
    public Matrice mulBy(double c)
    {
      ...
    }
    public Matrice mulRowByCol(Matrice m) throws IllegalArgumentException
    {
      ...
    }
    ...
    /** FONDAMENTALE! */
    public boolean equals(Object o)
    {
      ...
    }
    /** DA IMPLEMENTARE IN MODO COERENTE CON equals()!
     *  (Vedi la documentazione della classe Object)
     */
    public int hashCode()
    {
      ...
    }
    ...
}
[...]
Ciao!
Roberto

    {
PFUI... bazzeccole....
Ti prometto che studierò (ne ho molto ancora, lo sapevo anche prima ma 
credimi che mica mi spavento, tutt'altro!!!!). Ora ceno perchè poi mi 
aspetta la Juve. (A proposito: Totti, shhhhhh!, 4, a casa!).
E, ovviamente, dopo la Juve.... Java.
Grazie Roberto!
Ciao! 

 E, ovviamente, dopo la Juve.... Java.
Vedi, io ho la fortuna (sfortuna?!) di odiare visceralmente il calcio
e tutto cio' che vi gravita intorno, cosi' mi rimane molto piu' tempo
per Java; e non solo per quello... ;)
Ciao!
Roberto

 E, ovviamente, dopo la Juve.... Java.
Ovviamente ti sei giocato l'aiuto dei romanisti. Pessima mossa, volevo
tanto aiutarti... peccato che Roberto sia acalcistico.
uL
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Era solo uno sfottò innocuo. Altrimenti se avessi voluto essere stato
più sulla lama (ed in ogni caso più Off Topic del mio inciso) avrei
enunciato le dichiarazioni intellettuali di Totti della settimana
scorsa più l'innocuo 'appoggio' dei tacchetti sul capo di Nedved (che,
per carità, santo non è).  Poi se tu l'hai visto in un modo più
oltraggioso innanzitutto non era nel mio intento ed in ogni caso
guardando la statistica essendo la popolazione pro Roma inferiore a
quella pro Juve ho una percentuale più elevata di trovare esperti di
java con cui nn rischio di 'giocarmi' gli aiuti. Meno male cmq che le
jvm sono insensibili ai colori.

e non solo per quello...
Se è per quello che si intende facilmente, credimi, è molto meno complicato 
star dietro a java...... ;-) ;-) ;-)
Grazie ancora Roberto! Ciao!