[java] errore programma lettura/scrittura file di testo ad oggetti

[alberto t.]

Ciao a tutti! :)
Ho creato questo programma in java che consenta di leggere e scrivere su un file di testo ad oggetti:
package fileoggetti;

import java.io.*;

public class Main implements Serializable {

public static void main(String[] args) throws Exception {
boolean finedelfile = false;
try {
File a = new File("file.dat");
ObjectInputStream leggi = new ObjectInputStream(new FileInputStream(a));
ObjectOutputStream scrivi = new ObjectOutputStream(new FileOutputStream(a));
while(finedelfile==true){
riga = (Main) leggi.readObject(a);
if (riga == null) {
finedelfile = true;
} else {
Main m = new Main("dsada", "miadsadso", "dasda");
scrivi.writeObject(m);

}}
leggi.close();
scrivi.close();
} catch (IOException eccezione) {
System.out.println(eccezione.getMessage());
} catch (ClassNotFoundException eccezione) {
System.out.println(eccezione.getMessage());
} catch (FileNotFoundException eccezione) {
System.out.println(eccezione.getMessage());

}
}
}


Quando lo lancio mi da questi errori:
init:
deps-jar:
Compiling 1 source file to /home/alberto/NetBeansProjects/fileoggetti/build/classes
/home/alberto/NetBeansProjects/fileoggetti/src/fileoggetti/Main.java:14: cannot find symbol
symbol : variable riga
location: class fileoggetti.Main
riga = (Main) leggi.readObject(a);
/home/alberto/NetBeansProjects/fileoggetti/src/fileoggetti/Main.java:14: readObject() in java.io.ObjectInputStream cannot be applied to (java.io.File)
riga = (Main) leggi.readObject(a);
/home/alberto/NetBeansProjects/fileoggetti/src/fileoggetti/Main.java:15: cannot find symbol
symbol : variable riga
location: class fileoggetti.Main
if (riga == null) {
/home/alberto/NetBeansProjects/fileoggetti/src/fileoggetti/Main.java:18: cannot find symbol
symbol : constructor Main(java.lang.String,java.lang.String,java.lang.String)
location: class fileoggetti.Main
Main m = new Main("dsada", "miadsadso", "dasda");
4 errors
BUILD FAILED (total time: 0 seconds)
Come mai?
Ciao e grazie! :)

[PGI-Bis]

La compilazione fallisce per una varietà di ragioni.

package fileoggetti;

import java.io.*;

public class Main implements Serializable {

public static void main(String[] args) throws Exception {
boolean finedelfile = false;
try {
File a = new File("file.dat");
ObjectInputStream leggi = new ObjectInputStream(new FileInputStream(a));
ObjectOutputStream scrivi = new ObjectOutputStream(new FileOutputStream(a));
while (finedelfile == true) {
riga = (Main) leggi.readObject(a);
if (riga == null) {
finedelfile = true;
} else {
Main m = new Main("dsada", "miadsadso", "dasda");
scrivi.writeObject(m);

}
}
leggi.close();
scrivi.close();
} catch (IOException eccezione) {
System.out.println(eccezione.getMessage());
} catch (ClassNotFoundException eccezione) {
System.out.println(eccezione.getMessage());
} catch (FileNotFoundException eccezione) {
System.out.println(eccezione.getMessage());
}
}
}

In:

riga = (Main) leggi.readObject(a);

"riga" non è riconducibile ad alcuna dichiarazione di nome;
ObjectInputStream non dichiara alcun metodo readObject(T) con T :> File.

In:

Main m = new Main("dsada", "miadsadso", "dasda");

La classe Main non contiene alcuna dichiarazione di costruttore compatibile con l'invocazione:

new Main(String, String, String)

In:

} catch (FileNotFoundException eccezione) {

Questa eccezione è assorbita nella precedente clausola catch(IOException) (perchè FileNotFountException <: IOException)

Una volta risolti questi problemi l'esecuzione del programma rilascerà un'eccezione di IO.

[alberto t.]

riga = (Main) leggi.readObject(a);

"riga" non è riconducibile ad alcuna dichiarazione di nome;
ObjectInputStream non dichiara alcun metodo readObject(T) con T :> File.

In:

Main m = new Main("dsada", "miadsadso", "dasda");

La classe Main non contiene alcuna dichiarazione di costruttore compatibile con l'invocazione:

new Main(String, String, String)
Come faccio a risolvere questi problemi?

[PGI-Bis]

Il problema è che risolvere quei problemi non ti darà un programma che fa quello che vorresti. Comunque, per:

riga = (Main) leggi.readObject(a);

Potresti scrivere:

Main riga = (Main)leggi.readObject();

al posto di:

Main m = new Main("dsada", "miadsadso", "dasda");

metti:

Main m = new Main();

e questa parte:

catch (FileNotFoundException eccezione) {
System.out.println(eccezione.getMessage());
}

La elimini.

Risulta:

package fileoggetti;

import java.io.*;

public class Main implements Serializable {

public static void main(String[] args) throws Exception {
boolean finedelfile = false;
try {
File a = new File("file.dat");
ObjectInputStream leggi = new ObjectInputStream(new FileInputStream(a));
ObjectOutputStream scrivi = new ObjectOutputStream(new FileOutputStream(a));
while (finedelfile == true) {
Main riga = (Main) leggi.readObject();
if (riga == null) {
finedelfile = true;
} else {
Main m = new Main();
scrivi.writeObject(m);

}
}
leggi.close();
scrivi.close();
} catch (IOException eccezione) {
System.out.println(eccezione.getMessage());
} catch (ClassNotFoundException eccezione) {
System.out.println(eccezione.getMessage());
}
}
}

Che compilato con:

javac -d . *.java

ed eseguito con:

java fileoggetti.Main

risulta in:

file.dat (Impossibile trovare il file specificato)

[alberto t.]

file.dat (Impossibile trovare il file specificato)
come faccio a creare questo file?

[PGI-Bis]

Lascia stare il file.

Cosa vuoi far fare al tuo programma?

[alberto t.]

Cosa vuoi far fare al tuo programma?
Voglio poter leggere e scrivere su quel file. Utilizzando il metodo di lettura e scrittura ad oggetti (utilizzando le classi inputstream e outputstream) (byte).

[PGI-Bis]

Allora ti serve prima di tutto un oggetto da serializzare e deserializzare.

public class Main implements Serializable {

}

è ok, nel senso che effettivamente quel "implements Serializable" render la classe un valido argomento per la scrittura con "writeObject". il problema è che la classe Main non ha granchè di significativo da scrivere (non ha campi).

Il tuo:

Main m = new Main("dsada", "miadsadso", "dasda");

suggerisce l'idea che tu voglia fare una prova per un oggetto che abbia tre campi di tipo String. Quella riga funzionerebbe. sia per la sintassi che per lo scopo, se noi avessimo nella classe Main un costruttore e tre campi:

package fileoggetti;

import java.io.*;

public class Main implements Serializable {
private String campo001;
private String campo002;
private String campo003;

public Main(String a, String b, String c) {
campo001 = a;
campo002 = b;
campo003 = c;
}

public String getCampo001() {
return campo001;
}

public String getCampo002() {
return campo002;
}

public String getCampo003() {
return campo003;
}
}

Con questo Main, in ipotesi, potremmo dire:

Main m = new Main("dsada", "miadsadso", "dasda");
objectOutputStream.writeObject(m);

e, ad una successiva lettura:

Main m = (Main)objectInputStream.readObject();

m.getCampo001() restituirebbe "dsada", m.getCampo002() restituirebbe "miadsadso" e m.getCampo002() restituirebbe "dasda".

Per quanto riguarda la scrittura, il fatto è che se il file manca significa che non c'è niente da leggere. Si potrebbe creare un file vuoto ma non ci sarebbe comunque alcunchè da leggere. Puoi dichiarare il file come fai ora:

File a= new File("file.dat");

poi verifichi se "a" esiste:

if(a.exists()) {

} else {

}

Se a esiste si presume che ci sia qualcosa da leggere.

if(a.exists()) {
leggiOggetto(a);
} else {
scriviOggetti(a);
}

I due metodi leggiOggetto e scriviOggetto funzionano ciascuno come hai già scritto nel tuo codice.

Un esempio completo è il seguente:

package fileoggetti;

import java.io.*;

public class Main implements Serializable {

//****************************************Definizione degli oggetti di tipo Main
private String campo001;
private String campo002;
private String campo003;

/** Inizializza un oggetto di tipo Main usando le tre stringhe in argomento
come valori per i campi campo001, campo002 e campo003 */
public Main(String a, String b, String c) {
campo001 = a;
campo002 = b;
campo003 = c;
}

/** Restituisce il valore del campo campo001 */
public String getCampo001() {
return campo001;
}

/** Restituisce il valore del campo campo002 */
public String getCampo002() {
return campo002;
}

/** Restituisce il valore del campo campo003 */
public String getCampo003() {
return campo003;
}

//**************************************************************metodi di classe

/**punto d'entrata della jvm*/
public static void main(String[] args) {
File a = new File("file.dat");
if(a.exists()) {
leggiOggetto(a);
} else {
scriviOggetto(a);
}
}

/** invocato da main, legge l'oggetto di tipo Main contenuto nel file
in argomento */
private static void leggiOggetto(File file) {
ObjectInputStream leggi = null;
try {
FileInputStream fileStream = new FileInputStream(file);
BufferedInputStream bufferedStream = new BufferedInputStream(fileStream);
leggi = new ObjectInputStream(bufferedStream);
Main oggetto = (Main)leggi.readObject();
leggi.close();
leggi = null;
System.out.println("Ho letto l'oggetto Main:");
System.out.println("campo001 = " + oggetto.getCampo001());
System.out.println("campo002 = " + oggetto.getCampo002());
System.out.println("campo003 = " + oggetto.getCampo003());
} catch(FileNotFoundException ex) {
System.err.println("Non trovo il file " + file);
ex.printStackTrace();
} catch(IOException ex) {
System.err.println("Errore durante la lettura del file " + file);
ex.printStackTrace();
} catch(ClassNotFoundException ex) {
System.err.println("Errore nel caricacamento della classe dell'oggetto");
ex.printStackTrace();
} finally {
chiudiFlusso(leggi);
}
}

/** invocat da main, scrive un nuovo oggetto di tipo Main nel file in
argomento */
private static void scriviOggetto(File file) {
ObjectOutputStream scrivi = null;
try {
FileOutputStream fileStream = new FileOutputStream(file);
BufferedOutputStream bufferedStream = new BufferedOutputStream(fileStream);
scrivi = new ObjectOutputStream(bufferedStream);
Main oggetto = new Main("dsada", "miadsadso", "dasda");
scrivi.writeObject(oggetto);
scrivi.flush();
scrivi.close();
scrivi = null;
} catch(FileNotFoundException ex) {
System.err.println("Non trovo il file " + file);
ex.printStackTrace();
} catch(IOException ex) {
System.err.println("Errore durante la scrittura sul file " + file);
ex.printStackTrace();
} finally {
chiudiFlusso(scrivi);
}
}

/**Metodo di appoggio per chiudere un flusso*/
private static void chiudiFlusso(Closeable c) {
if(c != null) {
try {
c.close();
} catch(IOException ex) {
ex.printStackTrace();
}
}
}
}

Nel tuo codice c'era anche un ciclo che mi fa supporre che tu intendessi scrivere più di un oggetto sullo stesso file "file.dat". E' possibile ma in un modo un po' diverso da come avevi iniziato a fare.

[alberto t.]

Innanzitutto grazie della risposta e del tempo dedicato.:)

Se invece vorrei fare il tutto nel Main (senza metodi), come dovrei fare?
Ciao e grazie

[zyzyo91]

l'argomento interessa anche a me grazie :D

[morskott]

Innanzitutto grazie della risposta e del tempo dedicato.:)

Se invece vorrei fare il tutto nel Main (senza metodi), come dovrei fare?
Ciao e grazie

che intendi per "senza metodi"??