Methode, die einen arry von objekten speichert in einer datei

[LetsSebi]

Hey, ich habe folgendes Problem, ichw eiß nicht wie ich, eien methode schreiben soll, die meine erstellten objekten in ein array reingibt und danach in einer datei ausgibt!

 

[infos9]

Die Objekte könntest du serializable machen und das Array in eine Liste packen, dann alles mit ObjectOutputStream schreiben

 

[LetsSebi]

import java.io.*;

public class DataStreamBsp{
   private String s;
   private int i;
   private byte b;
   private double d;
   private boolean t;
//*************************************
   public DataStreamBsp(String s, int i, byte b, double d, boolean t){
      this.s = s;
      this.i = i;
      this.b = b;
      this.d = d;
      this.t = t;
   }
//**********************************
   public String toString (){
      return " s= "+s
           +" i= "+i
           +" b= "+b
           +" d= "+d
           +" t= "+t;
   }
   //**********************************
   public boolean speichern(String fileName){
      try{
         DataOutputStream ds = new DataOutputStream(new FileOutputStream(fileName));

         ds.writeUTF(s); //Alternativen: writeChars, writeBytes
         ds.writeInt(i);
         ds.writeByte(b);
         ds.writeDouble(d);
         ds.writeBoolean(t);
            //es gibt auch writeFloat, writeShort, writeLong,....



         ds.close();
         return true;
      }catch(IOException e){
         System.out.println("Specihern ging scheif: \n"+e.getMessage());
      }
      return false;
   }
   public static void arraySpeichern(String fName, String DataOutputStream){
      ,mnbjhbkihjbkijoiklujh = gaga;

   }




   //*******************
   //Ue: (1)schreibe ein methode, die ein arry von solchen objekten speichert
   //   (2)schreibe ein methode, die eine solche Datein hereinliest --> liefert arry
   //    (3)testen!
   //   (4)schreibe einen Konstruktor, der eienn filenamen �bhernimmt und das objekt aus der datei initialisiert
   //*******************
   public boolean laden(String fileName){
      try{
         DataInputStream ds = new DataInputStream(new FileInputStream(fileName));

         s=ds.readUTF(); //Alternativen: writeChars, writeBytes
         i=ds.readInt();
         b=ds.readByte();
         d=ds.readDouble();
         t=ds.readBoolean();
            //es gibt auch writeFloat, writeShort, writeLong,....



         ds.close();
         return true;
      }catch(IOException e){
         System.out.println("Specihern ging scheif: \n"+e.getMessage());
      }
      return false;
   }
   //zum testen
   public static void main(String[] args){


      DataStreamBsp ds1 = new DataStreamBsp("Hallo",12,(byte)1,1.7321,true);

      System.out.println(ds1+"\n--->das war ds1");

      ds1.speichern("Bin1.BIN3i");

      DataStreamBsp ds2 = new DataStreamBsp("Morning",7,(byte)3,3.14159165,false);

      System.out.println(ds2+"\n--->das war ds2");

      ds2.speichern("Bin2.BIN3i");

      //absichtlich 1->2, 2->1, damit mana uch was siehtt....
      ds1.laden("Bin2.BIN3i");
      ds2.laden("Bin1.BIN3i");

      System.out.println(ds1+"\n--->das war ds1");
      System.out.println(ds2+"\n--->das war ds2");

      DataStreamBsp dsGeladen = new DataStreamBsp("",0,(byte)0,0,false);

      dsGeladen.laden(Console.readLine("Dateiname: "));
      System.out.println(dsGeladen+"\n--->das war dsGeladen");
   }

 

[infos9]

Hier bitte

import java.io.*;
import java.util.Arrays;
import java.util.List;

public class DataStreamBsp implements Serializable {
    private static final long serialVersionUID = 1L;
    private String s;
    private int i;
    private byte b;
    private double d;
    private boolean t;

    // *************************************
    public DataStreamBsp(String s, int i, byte b, double d, boolean t) {
        this.s = s;
        this.i = i;
        this.b = b;
        this.d = d;
        this.t = t;
    }

    // **********************************
    public String toString() {
        return " s= " + s + " i= " + i + " b= " + b + " d= " + d + " t= " + t;
    }

    // **********************************
    public static boolean speichern(String fileName, DataStreamBsp dsb) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fileName))) {
            oos.writeObject(dsb);
            return true;
        } catch (IOException e) {
            System.out.println("Specihern ging scheif: \n" + e.getMessage());
            return false;
        }
    }

    public static void arraySpeichern(String fileName, DataStreamBsp[] array) {
        List<DataStreamBsp> asList = Arrays.asList(array);
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fileName))) {
            oos.writeObject(asList);
        } catch (IOException e) {
            System.out.println("Specihern ging scheif: \n" + e.getMessage());
        }
    }

    public static DataStreamBsp[] arrayLaden(String fileName) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fileName))) {
            return ((List<DataStreamBsp>) ois.readObject()).toArray(new DataStreamBsp[0]);
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("Array Laden ging scheif: \n" + e.getMessage());
            return null;
        }
    }

    // *******************
    // Ue: (1)schreibe ein methode, die ein arry von solchen objekten speichert
    // (2)schreibe ein methode, die eine solche Datein hereinliest --> liefert arry
    // (3)testen!
    // (4)schreibe einen Konstruktor, der eienn filenamen �bhernimmt und das objekt
    // aus der datei initialisiert
    // *******************
    public static DataStreamBsp laden(String fileName) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fileName))) {
            return (DataStreamBsp) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("Laden ging scheif: \n" + e.getMessage());
            return null;
        }
    }

    // zum testen
    public static void main(String[] args) {

        DataStreamBsp ds1 = new DataStreamBsp("Hallo", 12, (byte) 1, 1.7321, true);

        System.out.println(ds1 + "\n--->das war ds1");

        speichern("Bin1.BIN3i", ds1);

        DataStreamBsp ds2 = new DataStreamBsp("Morning", 7, (byte) 3, 3.14159165, false);

        System.out.println(ds2 + "\n--->das war ds2");

        speichern("Bin2.BIN3i", ds2);

        // absichtlich 1->2, 2->1, damit mana uch was siehtt....
        ds1 = laden("Bin2.BIN3i");
        ds2 = laden("Bin1.BIN3i");

        System.out.println(ds1 + "\n--->das war ds1");
        System.out.println(ds2 + "\n--->das war ds2");

        DataStreamBsp[] dsba = { ds1, ds2 };
        arraySpeichern("Bin1.BIN3i.a", dsba);
        DataStreamBsp[] dsba2 = arrayLaden("Bin1.BIN3i.a");

        System.out.println(Arrays.toString(dsba2));
    }
}

 

[Barista]

Die Objekte könntest du serializable machen und das Array in eine Liste packen, dann alles mit ObjectOutputStream schreiben

Falls die Objekte (Klassen) mal geändert werden, könnten die Daten verlorens sein, weil das zurück-Deserialisieren nicht klappt.

Auf jeden Fall eine eigene serialversionid vergeben!
(Wird auch von Eclipse generiert, sicher auch von IntelliJ oder anderer IDE)

Alternativ als XML oder JSON speichern.

 

[LetsSebi]

Falls die Objekte (Klassen) mal geändert werden, könnten die Daten verlorens sein, weil das zurück-Deserialisieren nicht klappt.

Auf jeden Fall eine eigene serialversionid vergeben!
(Wird auch von Eclipse generiert, sicher auch von IntelliJ oder anderer IDE)

Alternativ als XML oder JSON speichern.

ich weiß leider nicht, was du meinst und was Serializable ist

 

[kneitzel]

Wollen wir mal etwas auf den TE eingehen statt in einer Diskussion abzudriften, die dem TE nicht weiter hilft.
@mrBrown evtl. die Diskussion um die id Absplitten. Dann kann Tobias erläutern, wieso er meint, dass die nicht gesetzt werden darf oder auf bestimmte Werte gesetzt werden muss oder warum Deine Aussagen falsch sein sollen ...

Serializeable / serialVersionUID
(Erläuterung - dient dem speichern/laden eigener Klassen! Dürfte für eure Aufgabe uninteressant sein - ebenso wie die Diskussion um serialVersionUID ... Das musst Du (noch) nicht kennen. Und ob das überhaupt behandelt werden wird ist offen ...)

ich weiß leider nicht, was du meinst und was Serializable ist

Serializeable ist erst einmal nur ein Interface: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/Serializable.html

Diese spielt bei der Objekt oder Binary Serialisierung eine Rolle und kennzeichnet erst einmal Klassen, die serialisiert werden können.
https://www.baeldung.com/java-serialization gibt (auf Englisch) diesbezüglich eine kleine Übersicht (wie viele andere Seiten im Internet auch.)

Diese Binary Serialisierung hat aber gewisse "Probleme". Ein Problem ist, dass die Klasse selbst nicht gespeichert wird sondern nur Angaben zu der Klasse. Diese sind aber nicht eindeutig:
a) Weniger problematisch: Es kann eine Klasse mehrfach geben. Da aber in der Regel Namespaces verwendet werden, ist hier das Problem erst einmal nicht wirklich vorhanden.
b) Eine Klasse wird mit der Zeit verändert. Felder verändern sich (Du machst auf Date ein LocalDate, aus int ein double oder was weiss ich), Felder kommen hinzu oder entfallen. Ich habe mir die Details der Speicherung nicht angesehen: ggf. kann die Reihenfolge auch wichtig sein! Wenn solch eine Veränderung eingetreten ist, dann wird die Binary Darstellung ungültig.

Es wird z.B. ein Date gelesen, aber das kann nicht in ein LocalDate gespeichert werden.

Daher haben Klassen noch eine interne Versionierung. Dies ist einfach eine statische long Variable serialVersionUID - und diese kann man setzen.
Wenn man diese gesetzt hat, dann ist sicher gestellt: Wenn Du Code mehrfach übersetzt, dann lädt er die Binary Version. Aber wenn nun eine Änderung dafür sorgt, dass die Binary-Darstellung nicht mehr stimmig ist, dann verändert man diese Version. Dadurch wird verhindert, dass beim Laden keine dubiosen Effekte auftreten

XML und JSON
(Ebenfalls uninteressant! Das wird hier in der Aufgabe wohl eher nicht verlangt!)
Generell ist es aber auch schon so, wie es @Barista in #9 am Ende geschrieben hat: Man kann statt der Binary Form auch andere Darstellungen wählen. JSON und XML kommen da in Frage. Und da gibt es sehr leistungsfähige Libraries, die dies sehr einfach machen.

Eure Aufgabe
Bei der euch gestellten Aufgabe dürfte es so sein, dass ihr aber auf diese Binary Serialization setzen sollt. Denn damit habt ihr ja schon erfolgreich erste Werte geschrieben. Ihr seid also in der Lage, die üblichen Werte zu schreiben.
Und ihr könnte beliebige Werte nacheinander schreiben ... beim Lesen müsst ihr diese nur in der richtigen Reihenfolge lesen.

Bei einem Array wäre also nur zu überlegen: Was habt da denn? Und was brauchst du, um es zu erstellen?
Für das Array brauchst Du:
a) die Größe - ohne die Größe kannst Du es nicht erstellen
b) die Werte des Arrays.

Daher vermute ich, dass ihr zu einer Lösung kommen solltet, in der ihr beim Speichern:
- die Größe des zu speichernden Arrays (int Wert) speichern sollt
- dann über das Array gehen und alle Werte speichern.

Das Laden läuft ebenso:
- Erst wird die Größe geladen. Damit kannst Du dann das neue Array erstellen
- Dann gehst Du durch und lädst in jedes Element des Arrays den Wert.

==> Damit bleibst Du bei dem bekannten Wissen und wendest dies nur an.