zweiseiteige HashMap

[ich²]

Hallo Forum,

gibt es eine "zweiseitige" HashMap? Also praktisch eine HashMap, bei der ich nach key und value suchen kann? Ich kann gewährleisten, dass schlüssel sowie key nur einmal vorkommen.

danke!

mfg

ich²

 

[Ralf Ueberfuhr]

nö. nimm doch 2 hashmaps und halte sie synchron.

 

[ich²]

Hi,

hab ich momentan auch so, aber da beiden in der paintComponent Methode befüllt werden müssen halte ich zwei für nicht gerade Performant. Aber trotzdem danke!

mfg

ich²

 

[bygones]

öh - du kannst in einer normalen Map beidseitig suchen... gibt ja die contains Methoden...
den value dann halt über das entry set iterierend bekommen

 

[Illuvatar]

Hab mal ne kleine Hilfsklasse geschrieben, die dir vielleicht helfen könnte. Ist teilweise nicht so toll, für meine Zwecke hatte das halt ausgereicht, aber wäre ja noch ausbaufähig

	/**
     * Map which allows access either with A or with B. 
     * There are used TreeMaps inside, thus the Maps will be sorted.
     * If there are several equal A or B they will be put in a List.
     * All methods in this class are synchronized.
     * There is no remove method, because it would destroy the equality of the inner maps.
     */
	public class DoubleMap<A,B>
	{
		private Map<A,ArrayList[B]> mapAB = new TreeMap<A,ArrayList[B]>();
		private Map<B,ArrayList<A>> mapBA = new TreeMap<B,ArrayList<A>>();
		public synchronized void put (A a, B b)
		{
			if (mapAB.get(a) == null){
				mapAB.put(a, new ArrayList[B]());
			}
			mapAB.get(a).add (b);
			if (mapBA.get(b) == null){
				System.out.println ("PUT NEW B");
				mapBA.put(b, new ArrayList<A>());
			}
			mapBA.get(b).add(a);
		}
		public synchronized void clear()
		{
			mapAB.clear();
			mapBA.clear();
		}
		public synchronized List<A> getAforB (B b)
		{
			return mapBA.get(b);
		}
		public synchronized List[B] getBforA (A a)
		{
			return mapAB.get(a);
		}
		public synchronized Set<A> getASet()
		{
			return mapAB.keySet();
		}
		public synchronized Set[B] getBSet()
		{
			return mapBA.keySet();
		}
		public synchronized boolean isEmpty()
		{
			return mapAB.isEmpty();
		}
	}

 

[Ralf Ueberfuhr]

hab ich momentan auch so, aber da beiden in der paintComponent Methode befüllt werden müssen halte ich zwei für nicht gerade Performant. Aber trotzdem danke!

Ich halte das für genauso performant, denn der zweimalige Aufruf von HashMap.put dauert nicht wesentlich länger. Und beim Suchen nach Einträgen suchst du ja nicht in beiden Maps.

@illuvatar:

Wäre es nicht geschickter, den HashMap-Typ zu erweitern und die entsprechenden Methoden zu überschreiben?
(Also eine HashMap mit einer inversen HashMap.)

 

[bygones]

Wäre es nicht geschickter, den HashMap-Typ zu erweitern und die entsprechenden Methoden zu überschreiben?
(Also eine HashMap mit einer inversen HashMap.)

ne du erweiterst ja nicht HashMap methoden (als einziges vll die put methode)

 

[ich²]

Hi, danke für die Antworten

Ich halte das für genauso performant, denn der zweimalige Aufruf von HashMap.put dauert nicht wesentlich länger. Und beim Suchen nach Einträgen suchst du ja nicht in beiden Maps.

Naja, ich muss sie auch jedesmal nochmal in der paint löschen und ich hätte dann nur einen put nämlich Value und Value .

@ Illuvater

danke, werd ich mir mal anschauen, aber wenn dann werd ich mir das selber schreiben, da ist der lerneffekt größer .

mfg

ich²

 

[Ralf Ueberfuhr]

Wäre es nicht geschickter, den HashMap-Typ zu erweitern und die entsprechenden Methoden zu überschreiben?
(Also eine HashMap mit einer inversen HashMap.)

ne du erweiterst ja nicht HashMap methoden (als einziges vll die put methode)

Na doch. Im Prinzip ist es eine 2seitige HashMap.

Also in etwa so:

public class DoubleMap<A,B> extends HashMap<A,B> {

  private HashMap<B,A> inverseMap = new HashMap<B,A>();

  public void clear() {
    super.clear();
    inverseMap.clear();
  }

  public B put(A a, B b) {
    inverseMap.put(b,a);
    return super.put(a, b);
  }

  public B remove(A a) {
    final B b = super.remove(a);
    inverseMap.remove(b);
    return b;
  }

  /* Die ist neu:
   * nur "get(B b)" müsste eine Fehlermeldung geben, da A==B sein könnte
   */
  public A getKey(B b) {
    return inverseMap.get(b);
  }

}

An die Kenner: Würde man solche Methoden besser als "synchronized" kennzeichnen?

 

[Illuvatar]

Kommt auf den Einsatzzweck an. Wenn mehrere Threads auf die Map zugreifen, ist es sinnvoll.