Objekte Dauerhaft speichern und evtl. auch ändern?

[mobile]

HI,

bin jetzt so weit, dass ich alles richtig einlesen und ausgeben kann. Jetzt die nächste Sache. Wie kann ich denn meine angelegten Objekte dauerhaft speichern? Ein kleiner bsp. Code wäre echt super.

In diesem Array werden meine Objekte gespeichert:

static MiniDisc[][] md = new MiniDisc[MAX_MD][MAX_TRACK];

Bis jetzt nur zur Laufzeit, dann sind sie futsch, leider! Brächte sie für immer! Denke mal, ich müsste beim erstellen eines Objektes direkt was tu oder?

In dem Array werden eigentlich Objekte unter einem Hauptobjekt gepseichert. Genauer: Unter eine MiniDisc oder CD Nr. werden 20 Titel gepeichert.

Die 20 Track Objekte werden hier erstellt.

public class MiniDisc {
	static short md_nr = 0;
	
	
	private byte track = 0;
	private String interpret = "";
	private String titel = "";
	private String dauer = "";
	
	//...
		
	MiniDisc(byte track, String interpret, String titel, String dauer) {
		this.track = track;
		this.interpret = interpret;
		this.titel = titel;
		this.dauer = dauer;
	}
	
	//....
}

Wenn ich dass dann richtig gespeichert habe. Kann ich die Objekte dann auch öffnen und wieder ändern? Falls man zB. mal ein Lied löscht, oder man sich verschrieben hat etc.

Danke für eure Hilfe

 

[Gast]

stichwort serialisieren / Serializable

oder selbst die daten in eine Datei speichern, gibts viele beispiele im forum und auch in der javainsel gibts da ein paar kapitel zu

 

[mobile]

So habe mir das jetzt mal alles durchgelesen. Aber so richtig blicke ich noch nicht durch. Jetzt steht, da in meinem Buch, dass stitische Variablen nicht mit gespeichert werden. genau anhand dieser Variable wollte ich eigentlich speichern. Also muss ich die wohl erstma irgendwie als nicht statisch speichern.

Also ich zeige euch das mal. In dieses Klasse wird ein Objekt erstellt mit und unter der statischen Variablen in das Array gepsiechert.

public class Erstellen {
	final static short MAX_MD = 100;
	final static byte MAX_TRACK = 4;
	private String interpret = "";
	private String titel = "";
	
	static MiniDisc[][] md = new MiniDisc[MAX_MD][MAX_TRACK];
	
	Erstellen() {
		MiniDisc.md_nr++;
	}
	
	public void einlesen() {
		BufferedReader din = new BufferedReader(new InputStreamReader(System.in));
		
		System.out.println("\nMini Disc Nummer: " + MiniDisc.md_nr + "\n");
		
	    try {	    	
	 	    for(byte i = 0; i < MAX_TRACK; i++) {	 
	 	    	System.out.println("Track    : " + (i + 1));
			     
			    System.out.print("Interpret: ");
			    this.interpret = din.readLine();
			    
			    System.out.print("Titel    : ");
			    this.titel = din.readLine();
					     
			    System.out.print("Dauer    : ");
			    String dauer = din.readLine();
			
			    System.out.println();
			 			    			    
			    MiniDisc m = new MiniDisc(i, this.interpret, this.titel, dauer);
			    
			    md[MiniDisc.md_nr - 1][i] = m;
	    	}
	    }
	    //..hier stehen noch catch anweisungen
	}
}

Mit

MiniDisc m = new MiniDisc(i, this.interpret, this.titel, dauer);

übergebe ich die eingelesen Werte an die nächste Klasse MiniDisc in der dann immer ein Objekt mit Nr. Interpret und Titel erstellt wird, und in dem Array gepseichert wird.

public class MiniDisc {
	static short md_nr = 0;
	
	private byte track = 0;
	private String interpret = "";
	private String titel = "";
	private String dauer = "";
	
	//....
		
	MiniDisc(byte track, String interpret, String titel, String dauer) {
		this.track = track;
		this.interpret = interpret;
		this.titel = titel;
		this.dauer = dauer;
	}
	
	//...
}

Wie kann ich denn jetzt die Objekte die alle schon temporär zur Laufzeit zur Verfügung stehen in dem Array auch dauerhaft speichern?

 

[mobile]

Weiß keiner nen Rat? Klasse Save habe ich schon geschrieben aber das funktioniert nicht! Weß wirklich nicht warum, mach das zum ersten Mal, und aus dem Büchern werde ich auch nciht schlau.

 

[Guest]

Damit ein Objekt serialisiert werden kann, muss es das Interface java.io.Serializable implementieren (siehe MiniDisc)
Serialisiert und Deserialisert wird mit ObjectInputStream und ObjectOutputStream (Methoden load und store).
Die MiniDiscs sind hier in einer Collection ehhmm Liste gespeichert.

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class MiniDiscList
{
   /**
    * Lädt die Liste der MiniDics aus einer Datei.
    * Falls die gegebene Datei nicht existiert, wird eine leere Liste zurückgegeben.
    * 
    * @param mdFile Datei mit serialisierten Minidiscs
    * @return Liste mit Minidiscs
    * @throws IOException Fehler bei der Deserialisierung
    * @throws ClassNotFoundException Fehler bei der Deserialisierung
    */
   @SuppressWarnings("unchecked")
   public static List<MiniDisc> load(File mdFile) throws IOException, ClassNotFoundException
   {
      List<MiniDisc> mdList;
      if(mdFile.exists())
      {
         ObjectInputStream v_Stream = new ObjectInputStream(new FileInputStream(mdFile));
         mdList = (List<MiniDisc>)v_Stream.readObject();
         v_Stream.close();
      }
      else
      {
         mdList = new ArrayList<MiniDisc>();
      }
      return mdList;
   }
   
   /**
    * Speichert die gegebene Liste mit MiniDics in einer Datei.
    * Falls die gegebene Datei nicht existiert, wird eine neue erstellt.
    * 
    * @param mdFile Datei, in die geschrieben wird
    * @param mdList Liste der zu speichernden MiniDiscs
    * @throws IOException Fehler bei der Serialisierung
    */
   public static void store(File mdFile, List<MiniDisc> mdList) throws IOException
   {
      assert mdList != null;
      ObjectOutputStream v_Stream = new ObjectOutputStream(new FileOutputStream(mdFile));
      v_Stream.writeObject(mdList);
      v_Stream.close();
   }
   
   public static void main(String args[]) throws Exception
   {
      File mdFile = new File("md.dat");
      
      List<MiniDisc> mdList = load(mdFile);
      
      mdList.add(new MiniDisc());
      mdList.add(new MiniDisc());
      mdList.add(new MiniDisc());
      mdList.add(new MiniDisc());
      mdList.add(new MiniDisc());
      
      store(mdFile, mdList);
   }
}

class MiniDisc implements Serializable
{
   private static final long serialVersionUID = -5009805326091172496L;

   private Integer md_nr; 
   private Byte track; 
   private String interpret; 
   private String titel; 
   private String dauer;
   
   public MiniDisc()
   {
   }

   ... Getter und Setter
}

 

[mobile]

huuu....... versteh rein nichts! Danke trotzdem für deine Mühe. Denke ich sollte mei Programm noch mal überdenken. Am besten geh ich mal langsam durch was ich brauche. Klasse für Klasse Schritt für Schritt. Erstmal nur rein das speichern der MiniDisc. Wäre ganz gut, wenn mir dabei einer helfen könnte.

 

[JPKI]

huuu....... versteh rein nichts!

Es ist zwar schon länger her, aber in diesem Thread hab ich dir doch haarklein geschildert, wie man serialisiert, oder?