Newsgroup: it.comp.java
Titolo: problema lettura file.txt

Scusate la mia domanda banale...ma sono una stud di giurisprudenza che si
trova ad affrontare java dop un breve corso univ e faccio un po fatica..
vengo al problema..
ho costruito una gui che al suo interno attiva(atrraverso due JButton) due
diversi frame..uno per admin(il quale può inserire articoli cancellarli e
atre operazioni) ed uno user. La parte di admin funziona senza problemi.
Nella gui user vorrei visualizzare degli elenchi ordinati per
autore,anno..etc.
Ho pensato di fare un arraylist che ho salvato com admin in un
file.txt(quest lato admin) e lato user vorrei leggere l'array ma non
riesco a farla funzionare.
All'univ è una parte che non abbiamo fatto quella della lett e scritt file
e neppure la gestione delle eccezioni..quindi mi sono arrangiata..
qui di seguito il codice della GUI
public class FrameUser extends javax.swing.JFrame {
    private ArrayList<CD> elencoProdotti = new ArrayList<CD>();
 
    /** Creates new form FrameUser */
    public FrameUser() {
        initComponents();
//leggo il file elencoProdotti.txt per potere visualizzare gli elenchi
 
        String file = "elencoProdotti.txt",line;
        String codice,titoloOriginale, nazione;
        int anno;
        String genere, durata;
        double prezzo;
        String autore, etichetta;        
        CD myProd;
        StringTokenizer token;
 
        try{
            FileReader fr = new FileReader(file);
            Scanner in = new Scanner(fr).useDelimiter(",");
            line = in.nextLine();
            while (line!=null) {
                token = new StringTokenizer(line);
                codice = token.nextToken();
                try {
                    titoloOriginale = token.nextToken();
                    nazione = token.nextToken();
                    anno = Integer.parseInt(token.nextToken());
                    genere = token.nextToken();
                    durata = token.nextToken();
                    prezzo = Double.parseDouble(token.nextToken());
                    autore = token.nextToken();
                    etichetta = token.nextToken();
                    myProd = new
CD(codice,titoloOriginale,nazione,anno,genere,durata,prezzo,autore,etichetta);
                    elencoProdotti.add(myProd);
                } catch (NumberFormatException e){ }
                line = in.nextLine();
            }
            in.close();
        } catch (FileNotFoundException e){ }      
} 
-------------------------------------------------------
metodo per visualizzare elenco
chiaramente nella classe CD ho implementato il metodo compareTo
dell'interfaccia comparable
private void buttonElencoAutoreClick(java.awt.event.ActionEvent evt) {    
 
        Collections.sort(elencoProdotti);
        String str = "";
        CD a;
        for (int i=0; i<elencoProdotti.size(); i++){
            a = elencoProdotti.get(i);
            str = str + a.getDescrizione()+ "\n";
        }
        areaElenchi.setText(str);
    }    
Grazie a tutti..
spero di essere stata chiara
 
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

ciao.
non ho provato a far andare il tuo codice ma a occhio l'errore sta nel
fatto che stai tentando di assegnare direttamente alle tue variabili
(titoloOriginale, nazione, autore, ecc.) il risultato del metodo
nextToken; devono averti informata male, quel metodo non restituisce il
valore del token che analizza, ma il tipo espresso sotto forma di costante
numerica intera (in sostanza quel valore di ritorno ti dice se il token
letto è un numero, una stringa, altro...).
qui hai il reference completo della classe:
http://java.sun.com/javase/6/docs/api/index.html?java/io/StreamTokenizer.html
ed in particolare qui quello del metodo nextToken:
http://java.sun.com/javase/6/docs/api/java/io/StreamTokenizer.html#nextToken()
per conoscere il valore del token devi leggere le variabili membro nval o
sval, sostanzialmente a seconda che il token sia un numero o una stringa
(gli altri casi particolari sono specificati in dettaglio nella
documentazione).
non ho visto se ci sono altri errori, ma intanto ti do un consiglio: se
non sei costretta a memorizzare quel file in formato testuale allora ti
conviene sicuramente memorizzarlo in formato binario, cioè non
human-readable. sarebbe molto più semplice perché potresti sfruttare la
serializzazione di Java senza stare ad impazzire col parsing manuale del
file di testo.
ciò che dovresti fare sarebbe aggiungere l'interfaccia Serializable
all'elenco delle interfacce implementate dalla tua classe CD; poi per
scrivere i dati in formato binario (spero di non averci lasciato errori,
l'ho scritto senza testare):
ArrayList<CD> array = new ArrayList<CD>();
.
.
.
FileOutputStream fos;
try {
	fos = new FileOutputStream("asdasdasd.txt");
}
catch (FileNotFoundException e) {
	return;
}
try {
	new ObjectOutputStream(fos).writeObject(array);
}
catch (IOException e) {
	return;
}
e poi dopo per leggerli:
FileInputStream fis;
try {
	fis = new FileInputStream("asdasdasd.txt");
}
catch (FileNotFoundException e) {
	return;
}
Collection<CD> data = null;
try {
	data = (Collection<CD>)(new ObjectInputStream(fis).readObject());
}
catch (IOException e) {
	return;
}
catch (ClassNotFoundException e) {
	return;
}
(ci sarebbero altre eccezioni unchecked che in questo esempio non ho
gestito, e quelle checked le ho gestite in maniera banale)
ciò che accade in questo modo è che l'oggetto ArrayList<CD> verrà scritto
assieme a tutti gli elementi che contiene (i quali devono essere oggetti
di una classe che implementa Serializable), e il tutto verrà letto così
com'è. se vuoi personalizzare il modo in cui i tuoi oggetti CD vengono
serializzati (ad es. se per risparmiare spazio vuoi evitare che
determinate variabili membro vengano scritte) puoi o usare la keyword
transient oppure reimplementare i metodi readObject e writeObject.
dovresti trovare tutti i dettagli nella documentazione di Serializable:
http://java.sun.com/javase/6/docs/api/index.html?java/io/Serializable.html
ultima cosa: come avrai notato nel codice di lettura mi sono mantenuto sul
generico leggendo un oggetto Collection piuttosto che ArrayList; questo
perché magari in futuro deciderai di utilizzare un'altra struttura dati
(quello che stai memorizzando è praticamente un database, e un array non è
molto performante per un database).
spero di averti aiutata.
ciao


 ciao
Graziee sei stato gentilissimooo!!!!! e chiarissimo
adesso provo con la serializzazione...


 adesso provo con la serializzazione...
e di che; curioso però che ti facciano fare programmazione Java a
GIURISPRUDENZA... dev'essere una di quelle università moderne :D


 GIURISPRUDENZA... dev'essere una di quelle università moderne :D
E' un corso di laurea breve..operatore informatico giuridico
ma ...non è organizzato molto bene
Molto interessante un po difficilotto per una come me che non ha mai
programmato in vita sua...cmq spero di farcela!!
ancora grazie
ciaoooo


 token = new StringTokenizer(line, ",");
ovvero la virgola usata come delimitatore di campi va pecificata quando
asegni il valore alla variabile token.
Spero di essere tato chiaro e uile.
Ciao, Andrea

--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

> token = new StringTokenizer(line, ",");
in.nextLine() devi metterlo nel while sennò leggi una riga sola :)


l' ho messo fuori per inizializzare la variabile e non avere errori all'
ingresso del while.
Ovviamente va ripetuto anche all' interno del while.
Ciao, Andrea
