Zugriff auf Maps ohne Cast in Java

vorhergehende Artikel in: Java
22.11.2017

Collections im Zusammenspiel mit Generics erlauben es, ohne Cast auf Elemente gleichen Typs typsicher zuzugreifen - was aber wenn man typsicher auf Elemente unterschiedlicher Typen in einer Collection zugreifen möchte, ohne zu casten? Hier die Vorstellung einer möglichen Antwort

Die Einführung von Generics in Java machte einiges im Quelltext übersichtlicher: Unter anderem Ist es jetzt nicht mehr notwendig, aus Collections entnommene Objekte zu casten, um mit Ihnen weiterarbeiten zu können. Damit wird der Quelltext übersichtlicher und leichter zu verstehen. Viele haben beklagt, daß die Informationen über die Template-Parameter zur Laufzeit nicht zur Verfügung stehen, aber das ist Geschmackssache, beziehungsweise durch einfache Maßnahmen nachrüstbar. Collections im Zusammenspiel mit Generics erlauben es, ohne Cast auf Elemente gleichen Typs zuzugreifen – für den Anwendungsfall, daß Elemente verschiedenen Typs in einer Collection gespeichert werden, hilft das nicht weiter. Als Veranschaulichung sei folgendes Beispiel gegeben:

java.util.Map m=new java.util.HashMap();
m.put("double",java.lang.Double.valueOf(3.1415));
m.put("int",java.lang.Integer.valueOf(1234));
m.put("string","huhu");

Der Zugriff auf die einzelnen Elemente muß normalerweise über einen Cast erfolgen. Man könnte dafür natürlich eine JavaBean erzeugen und verwenden, die in diesem Fall wie folgt aussehen könnte:

public class Bean
{
	private double d;
	private int i;
	private java.lang.String s;
	public  getI()
	{
		return i;
	}
	public void setI(int o)
	{
		i=o;
	}
	public  getD()
	{
		return d;
	}
	public void setD(double o)
	{
		d=o;
	}
	public  getS()
	{
		return s;
	}
	public void setS(String o)
	{
		s=o;
	}
}

Falls es aber aus irgendwelchen Gründen keine Option ist, eine solche Bean-Klasse einzusetzen, ist es extrem hinderlich, deswegen extra jedesmal beim Zugriff auf eines der Elemente einen Cast schreiben zu müssen. Wenn beim Zugriff auf die Elemente über ihren Namen der Typ bekannt ist, lässt sich einfach ein weiteres Generics-Feature zur Lösung heranziehen: eine generische Methode. Diese sähe dann wie folgt aus:

public <T> T fetch(java.lang.String key,Class<T> cls)
{
	Object o;
	o=m.get(key);
	return cls.cast(o);
}

Damit kann man dann zum Beispiel folgende Zugriffe realisieren (das Beispiel oben wird fortgeführt):

java.lang.Double d1=fetch("double", java.lang.Double.class);

Für Fundamentaldatentypen (oder jeden anderen, oft benötigten Klassentyp) kann man noch Abkürzungen wie folgt definieren:

public int fetchInt(java.lang.String key)
{
	return fetch(key, java.lang.Integer.class).intValue();
}

Aktualisierung vom 22. November 2017

Hier eine mögliche vollständige Implementierung dieser Idee:

public class TypeSafeHashMap<T,V> extends java.util.HashMap<T,V>
{
	public TypeSafeHashMap(int initialCapacity, float loadFactor)
	{
		super(initialCapacity, loadFactor);
	}

	public TypeSafeHashMap(int initialCapacity)
	{
		super(initialCapacity);
	}

	public TypeSafeHashMap()
	{
	}

	public TypeSafeHashMap(Map<? extends T, ? extends V> m)
	{
		super(m);
	}

	public <U extends V> U fetch(T key,Class<U> cls)
	{
		V o;
		o=get(key);
		return cls.cast(o);
	}
/*	public int fetchInt(T key)
	{
		return fetch(key, Integer.class).intValue();
	}
*/
/*	public static void main(java.lang.String[] args)
	{
		TypeSafeHashMap<String,Number> tsmap=new TypeSafeHashMap();
		tsmap.put("1",Integer.valueOf(1));
		tsmap.put("2",Double.valueOf(2));
		Integer a=tsmap.fetch("1", java.lang.Integer.class).intValue();
		JComponent b=tsmap.fetch("1", JPanel.class);
	}
*/}

Artikel, die hierher verlinken

GC-Minimierung in Java

05.11.2017

Auf meinen Fahrten von und zur Arbeit schweife ich hin und wieder gedanklich ein wenig ab. Hier das Ergebnis meiner jüngsten Gedankenexpedition...

DBMS in Software

24.02.2017

Im Job haben wir an einer Ausschreibung teilgenommen, die eine Java-Anwendung fordert, in der die Anwender neue Objekte definieren können sollen. Normalerweise würde das bedeuten, neue Tabellen in einer relationalen Datenbank anzulegen - leider würde das aber auch die Nutzung eines OR-Mappers, bzw. von Container Managed Persistence ausschließen.

Redux in Java

11.11.2016

Nachdem ich bei Heise einen Artikel darüber gelesen hatte, wollte ich versuchen, das Redux-Konzept in Java zu implementieren

Alle Artikel rss Wochenübersicht Monatsübersicht Github Repositories Gitlab Repositories Mastodon Über mich home xmpp


Neueste Artikel

  • Github hat keine Ahnung von Crypto und Sicherheit

    Morgen - am 1.2.2023 - soll mein neuer $dayjob anfgangen - und damit die Quelle, aus der ich die Mittel beziehe, weiterhin meine Kuchenzutaten bezahlen zu können. Das wird irgendwas mit Sicherheit sein. Und am Tag davor hat sich - wer eigentlich genau? - überlegt: "Komm, lass ihn uns nochmal so richtig auf Betriebstemperatur überkochen!". Aber - der Reihe nach...

    Weiterlesen...
  • Aktualisierung TileServer - Restrukturierung

    Ich habe meinen Tile-Server für OpenStreetMap-Daten aktualisiert

    Weiterlesen...
  • Drunken Bishop in Java

    Ich habe neulich wieder einmal Lust auf eine kleine Fingerübung gehabt und deshalb ein Verfahren in Java implementiert, das ich ursprünglich als Möglichkeit kennenlernte, zwei Schlüssel beim Versuch des Aufbaus einer Verbindung mittels SSH zu vergleichen...

    Weiterlesen...

Manche nennen es Blog, manche Web-Seite - ich schreibe hier hin und wieder über meine Erlebnisse, Rückschläge und Erleuchtungen bei meinen Hobbies.

Wer daran teilhaben und eventuell sogar davon profitieren möchte, muß damit leben, daß ich hin und wieder kleine Ausflüge in Bereiche mache, die nichts mit IT, Administration oder Softwareentwicklung zu tun haben.

Ich wünsche allen Lesern viel Spaß und hin und wieder einen kleinen AHA!-Effekt...

PS: Meine öffentlichen GitHub-Repositories findet man hier - meine öffentlichen GitLab-Repositories finden sich dagegen hier.