welche Speichermethode verwenden?

[magic_halli]

Hi,

ich möchte zur Laufzeit gewisse Sachen dynamisch abspeichern, um damit dann später zu arbeiten. Ich muss diese Werte so speichern, dass ich dann später auf jeden Datensatz zugreifen kann (bspw. über Index) und jeder Datensatz somit auch eindeutig identifizierbar ist!

Es müsste für meine Zwecke eigentlich so sein, dass ich irgendwie ein ArrayA habe, in dem mein 'Variantenname' (String) steht und ein weiteres ArrayB, in dem zu jedem Eintrag aus ArrayA verschiedene Sachen zugeordnet sind. Das wäre eigentlich perfekt für eine 'Datenbank mit 2 Tabellen' :wink: ... aber Datenbanken kommen nicht in Frage!

symbolisch; Bsp:

ArrayA                                     ArrayB
----------                                 ----------

[Index] <String>                           [Index] [Index_von_A] <String><Double>
                                           [Index] [Index_von_A] <String><Double>

speziell; Bsp:

ArrayA                                     ArrayB
----------                                 ----------

[0] sVariante1                             [0] [0] sName 5.3145
                                           [1] [0] sName2 3.1415

Ich hoffe, ich habe das einigermaßen verständlich rübergebracht?!
Leider weiß ich nicht recht, welche Speichermethoden ich hierfür nutzen muß, damit ich sowas realisieren kann. Der Ausdruck Array ist von mir hier erstmal eher symbolisch gemeint, da ich nicht weiß, ob man das mit ArrayListen, HashMaps, StringArrays etc. am besten lösen kann.

Was meint ihr?


Danke und Gruß.

 

[The_S]

HashMap!?

 

[magic_halli]

HashMap!?

...ist das die Antwort, oder Deine Meinung und Du bist Dir hierbei aber auch nicht sicher?

 

[tuxedo]

Das war die Antwort. Das "?" sollte wohl nur ein verwirrtes "wie? du kennst hashmaps noch nicht?" zum Ausdruck bringen ;-) Aber natürlich sind das alles nur mutmaßungen meinerseits.

Nichts desto trotz: HashMaps oder ähnliches, gerade weil

...eindeutig identifizierbar...

- Alex

 

[magic_halli]

Doch, ich kenne HashMaps... Ich bin mir nur grade eben unschlüssig, wie das dann auf mein obiges Beispiel betrachtet, mit HashMap(<Key><Value>) funktionieren soll!
Ich hätte ja dann zu jedem Eintrag in HashMap A einen/mehrere Einträge in HashMap B drinstehen. In der HashMap B brauche ich ja erstmal zu jedem Eintrag die Zuordnung zu A und dann außerdem meine Values dazu! Ich habe ja aber als Values 2 Sachen zum Abspeichern (einmal String und Double)... weißt wie ich meine?

Ich wüßte jetzt nicht, dass das geht, da eine HashMap doch immer nur aus Key/Value-Paaren besteht und nicht Key/Value/Value... oder?!

 

[tuxedo]

Geschachtelte HashMaps?

-->

HashMap<String, HashMap<String, Double>>

Bezogen auf dein Tabellenbeispiel:

HashMap<Integer, HashMap<Integer, String>>

Der erste Integer gibt die Zeile an
Der zweite Integer gibt die Spalte an
Der String enthäklt den Inhalt der bezeichneten Tabellenzelle

Gruß Alex

 

[Joker]

edit: oben stehts ja schon

 

[The_S]

"HashMap?" Weil deine Fragestellung nicht ganz eindeutig war (was sie mir immer noch nicht 100pro ist).

 

[magic_halli]

...aaah ja. Geschachtelte HashMaps - macht Sinn. :wink:
Die "innere" HashMap hat aber auf jeden Fall mehr Datensätze als die "äußere" - geht das dann?! Boah, je länger ich darüber nachdenke, umso mehr komme ich durcheinander... dabei hab ich noch nichtmal mit programmieren begonnen. :roll:

 

[tuxedo]

Ja, das geht prima. Hab ich schon x-fach so gemacht.

- Alex

 

[magic_halli]

"HashMap?" Weil deine Fragestellung nicht ganz eindeutig war (was sie mir immer noch nicht 100pro ist).

Mh, ich versuch das Problem mal anhand eines simplen Beispiels in Worten zu erklären:
Ich habe mehrere Autos. Zu jedem Auto möchte ich gewisse Eckdaten speichern, z.B. Leistung 150, Verbrauch 6.5, kmh 220.
Diese Daten lese ich für jedes Auto zur Laufzeit aus und möchte diese Abspeichern, um mir diese später wieder herzuholen und auszulesen. Die Frage war eben, welche Methodik verwende ich hierfür am besten?!
Mal ein Codebeispiel mit Pseudocode:

for(i=0;i<Anzahl_Autos,i++){
     String sAuto = Anzahl_Auto[i];     //bspw. "Golf"
     
     for(int j=0;j<Eckdaten_Auto;j++){
          String sName = Eckdaten_Auto.getName(j);     //bspw. Leistung
          Double dValue = Eckdaten_Auto.getValue(j);     //bspw. 150.0
          //nun das speichern dieser Eckdaten zu jedem Auto - das war eigentlich der Kern der Frage
          //ich hab bspw. 10Autos (sAuto) mit jeweils 5 Eckdaten hier erhalten
     }
}

So, jetzt hab ich mir nochmal richtig Mühe mit der Beschreibung gegeben?! :wink:
Das würde dann bedeuten, ich habe in der HashMap A 10 Datensätze, die wiederrum ihren Value aus HashMap B holen, welche ja dann 50 Datensätze hat.

 

[magic_halli]

Ja, das geht prima. Hab ich schon x-fach so gemacht.

Wie sieht denn dafür ein simples Grundgerüst aus, wenn ich verschachtelte HashMaps speichern will und dabei natürlich die Zugehörigkeit gewährleistet ist? Hast Du mal eben so ein Codesnipplet zur Hand? (Dann bekomme ich hoffentlich meinen Knoten aus dem Kopf!)

 

[Joker]

in dem Fall kannst du, wenn ich das richtig Verstanden habe, auf die Verschachtelte HashMap verzichten.

Stattdessen erstellst du eine Klasse "AutoDaten":

class AutoDaten {
    
    private int leistung;
    private float verbrauch;
    private int topspeed;

    public AutoDaten(int leistung, float verbrauch, int topspeed) {
       this.leistung=leistung;
       this.verbrauch=verbrauch;
       this.topspeed=topspeed;
    }
    public int getLeistung() {
        return leistung;
    }

    public void setLeistung(int leistung) {
        this.leistung = leistung;
    }

    public int getTopspeed() {
        return topspeed;
    }
   
    public void setTopspeed(int topspeed) {
        this.topspeed = topspeed;
    }

    public float getVerbrauch() {
        return verbrauch;
    }

    public void setVerbrauch(float verbrauch) {
        this.verbrauch = verbrauch;
    }
    
    
   
}

und eine HashMap mit:

HashMap<String, AutoDaten> carMap = new HashMap<String,AutoDaten>

neue Autos legst du z.B. so an:

carMap.put("Golf", new AutoDaten(150,7.5,200));

und kannst sie mit

AutoDaten carData = carMap.get("Golf");
System.out.println("Leistung: "+carData.getLeistung()); 
System.out.println("TopSpeed: "+carData.getTopSpeed());
System.out.println("Verbrauch: "+carData.getVerbrauch());

wieder ausgegeben, oder auch die Werte mit den set Methoden verändern. Wenn du dann in Zukunft noch mehr Daten speichern möchtest musst du nur sie nur in der Klasse AutoDaten hinzufügen und über die get/set Methoden nach außen bereitstellen.

 

[ARadauer]

also wenn die eckdaten der autos immer ziehmlich gleich sind würd ich auch ein datenobjekt auto machen und dieses über einen schlüssel in die hashmap einordnen.

wenn die aber immer grundlegend verschieden eigenschaften hast, kann ja das auto eine hashmap beinhalten und dann sind die autos wieder in der hashmap drin. find ich ehrlich schöner, als einfach hashmaps in hashmaps abzulegen.

 

[magic_halli]

Mh, das mit dem Auto war mal von mir zum besseren Verständnis ein willkürlich gewähltes Beispiel!

Ich kann das nicht in einer Klasse machen, da ich vorher nicht weiß, wieviel Einträge zu einem Key aus HashMap A gehören können.
Da ich mein Java-Programm in Zusammenhang mit einem techn. Zeichenprogramm verwende, variieren, je nachdem was gerade für ein Modell geladen ist, auch diese Zuordnungen (Values --> entspricht quasi HashMap B - Einträge).
Also kann ich bspw. zu jeder Variante (=Key in A) 3 zugehörige Einträge (=Value in A bzw. dann Key/Value in B) haben... wenn ich dann ein neues Modell lade und mein Java-Programm erneut ausführe, können es durchaus 6 zugehörige Einträge sein usw. Also das ist echt voll dynamisch! ...und mir brummt inzwischen auch der Kopf!

Ich finde das ziemlich schwer zu erklären... hoffe es war halbwegs verständlich.
Schicke mir doch einfach mal so ein Codesegment von verschachtelten HashMaps (wie Du´s schon x-mal gemacht hast), damit ich mir das mal reinziehen und besser nachvollziehen kann. Das wäre prima :toll:

Gruß.

 

[tuxedo]

Wie der Herr wünschen ...

		// "Tabelle" basteln
		HashMap<Integer, HashMap<Integer, String>> table = new HashMap<Integer, HashMap<Integer, String>>();
		
		// "Zeile" Basteln
		HashMap<Integer, String> row0 = new HashMap<Integer, String>();
		for(int column=0; column<10; column++)
			row0.put(column, "i'am row 0 column "+column);

		// "Zeile" Basteln		
		HashMap<Integer, String> row1 = new HashMap<Integer, String>();
		for(int column=0; column<10; column++)
			row1.put(column, "i'am row 1 column "+column);

		// "Zeile" Basteln
		HashMap<Integer, String> row2 = new HashMap<Integer, String>();
		for(int column=0; column<10; column++)
			row2.put(column, "i'am row 2 column "+column);
		
		// Tabelle füllen
		table.put(0, row0);
		table.put(1, row1);
		table.put(2, row2);
		
		
		// Zelle aus Zeile 1 Spalte 4 holen
		System.out.println(table.get(1).get(4));

Ergebnis beim ausführen:

i'am row 1 column 4

Verstanden? Du kannst dir natürlich ein schicken "gerüst" drum rum basteln mit dem du direkt Zellen füllen und zellen lesen kannst. Aber das solltest du jetzt alleine hinbekommen.