2D Array aus HashMaps

[Hans_Maulwurf]

Hallo

ich hab mal wieder eine knifflige Sache. Ich möchte "einfach" nur ein 2 dimensionales Array erstellen, dessen Elemente HashMaps sind (aus String und Object).

Leider funktioniert das so nicht:

HashMap<String, Object>[][] StyleMaps = new HashMap<String, Object>[2][3];

Gibt es überhaupt einen weg dieses Konstrukt zu erstellen?

Vielleicht hat ja jemand einen Tipp für mich

Vielen Dank schonmal.


Gruß,
Hans

 

[Gast2]

Du kannst von einem generischen Typen kein Array erstellen. Folgendes würde gehen:

@SuppressWarnings("unchecked")
HashMap<String, Object>[][] styledMaps = new HashMap[2][3];

 

[Hans_Maulwurf]

Ist diese Warnung, die durch @SuppressWarning unterdrückt wird, dramatisch?

 

[Marco13]

Um das ganze mal eine Stufe weiter oben zu hinterfragen: Brauchst du Zugriff auf jede einzelne Map, oder ist das nur eine verkappte 3D-Datenstruktur? Erstelle dir ein Interface

interface DataStructure
{
    public Map<String, Object> get(int x, int y);
}

oder gleich

interface DataStructure
{
    public Object get(int x, int y, String z);
}

und überleg' dir später, wie du es implementieren kannst.

 

[Hans_Maulwurf]

Nein, es ist keine 3d-Struktur

Es sind Eigenschaften für 2D-Zellen, welche ich vorher dynamisch variiere. Zum Schluss muss ich aber trotzdem rausfinden, welche Zellen gemeinsame Eigenschaften habe. Deshalb benutze ich HashMaps, da diese sich mittels equals schön vergleichen lassen.

Mit interface habe ich leider noch keine Erfahrungen gemacht. Was für Vorteile bringt mir das?

 

[Marco13]

Also dann das erste Interface - wobei es vermutlich nicht direkt in dieser Form passen würde. Die bisherige Beschreibung klingt ein bißchen nach einer ~"Structure of Arrays". Also, als würde es sowas geben wie

int cellValues[][] = ...
int cellSizes[][] = ...
Map cellProperties[][] = ...

im Gegensatz zu einer Struktur wie

class Cell
{ 
    int value;
    int size;
    Map properties;
}
Cell cells[][] = ...

Aber das kann täuschen. Es gibt Fälle, wo (und sei es nur für einzelne Elemente einer solchen "Cell") ein zusätzlicher Array für eine bestimmte Eigenschaft der Zellen angebracht ist. Aber man sollte beide Optionen in Betracht gezogen haben. Etwas mehr Infos zum eigentlichen Ziel wären da nicht verkehrt, sonst ist das nur Spekulation.


Man kann Statt "HashMap" auch einfach das interface (!) "Map" verwenden. Sowas wie

Map<String, Integer> map0 = new HashMap<String, Integer>();
map0.put("Hallo", 123);

Map<String, Integer> map1 = new TreeMap<String, Integer>();
map1.put("Hallo", 123);

System.out.println(map0.equals(map1));

gibt [c]true[/c] aus. So ist das "equals" für alle vernünftigen Implementierungen von Map eben definiert.


Der Vorteil von interfaces allgemein ist zu Grundlegend, als dass ich ihn nochmal auswalzen würde, das wichtiste hier: Man kann die Implementierung nachher ändern. Wenn man ein Interface hat wie

interface DataStructure
{
    public Map get(int x, int y);
}

dann kann man ganz allgemein schreiben

Map map = dataStructure.get(x,y);

Das Interface selbst kann man implementieren, wie man will:

class SimpleDataStructure implements DataStructure
{
    private Map data[][] = new Map[1000][1000]; // Wenn's sein muss...
    public Map get(int x, int y) { return data[x][y]; }
}

oder eben

class SparseDataStructure implements DataStructure
{
    private Map<IntPair, Map> data = new HashMap<IntPair, Map>()
    public Map get(int x, int y) { return data.get(IntPair.of(x, y); }
}

und kann damit schwuppdiwupp und vollkommen transparent auch mal virtuell (d.h. wenn sie "dünn besetzt" ist, im Sinne einer Sparse Matrix) eine etwas größere DataStructure erstellen:

Map map = dataStructure.get(1223423, 23423423); // Kein Problem...

Welche Eigenschaften haben die Zellen? Gibt es schon eine Cell-Klasse? Um wie viele Zellen geht es? Ist die Datenstruktur vielleicht "dünn besetzt"?

 

[Hans_Maulwurf]

Also die Eigenschaften, welche ich in der Map stornieren wollte, sind im Moment:

		HashMap <String, Object> basicMapStyle = new HashMap <String, Object> ();
		basicMapStyle.put("font", (short) 5);
		basicMapStyle.put("borderBottom", (short) 0);
		basicMapStyle.put("borderTop", (short) 0);
		basicMapStyle.put("borderLeft", (short) 0);
		basicMapStyle.put("borderRight", (short) 0);
		basicMapStyle.put("bottomBorderColor", (short) 64);
		basicMapStyle.put("topBorderColor", (short) 64);
		basicMapStyle.put("leftBorderColor", (short) 64);
		basicMapStyle.put("rightBorderColor", (short) 64);
		basicMapStyle.put("fillForegroundColor", (short) 64);
		basicMapStyle.put("fillBackgroundColor", (short) 64);

Im Moment habe ich "nur" ein 2d-Array, welches den reinen Text der Zellen beinhaltet, und eben parallel dazu die das 2d-Array mit den dazugehörigen Maps, welche am Anfang dieser basicMapStyle entsprechen. Anhand des Textes werden dann dynamisch die Eigenschaften "ausgelesen" und gesetzt. Wenn alles funktioniert ist es das kleinste Problem, beides in eine eigene Cell-Klasse zu verpacken.

Die Größe des 2d-Arrays kann leicht 100*500 erreichen.

 

[SlaterB]

ich denke, die ursprüngliche Frage ist beantwortet,
bevor zu diesem einfachen und immer noch vorderen Thema zu viele umsonst reinschauen, setze ich auf 'Erledigt'