Eine Map mit X -> List<Y>?

[xZise]

Moin,
gibt es eine Möglichkeit einfach eine Map zu implementieren, die zu einem X eine Liste von Elementen des Typs Y zurückgibt?

Also so etwas wie eine normale Map, aber halt mit ein paar Bequemlichkeiten. Also dass die Liste nicht selber erstellt werden muss, sondern dann einfach leer ist?

Ich habe mich schon daran versucht, aber irgendwie will er nicht so richtig:

private MapListHelper<X, Y> mlh = new HashMap<X, List<Y>>();

MfG
Fabian

 

[Marco13]

Wenn es eine "echte" Map sein soll, hat man da nicht viele Möglichkeiten: Bei einer
Map<X, Y>
muss man map.put(x,y) machen können, und bei map.get(x) kriegt man ein Y zurück. Da "transparent" eine List reinmogeln geht nicht. Sowas wie
Map<X, List<Y>> map = new HashMap<X, List<Y>>();
würde gehen. Ich bau' mir für sowas dann ggf. noch zwei kleine statische Helper

    private static <X,Y> void addToMap(Map<X, List<Y>> map, X key, Y value)
    {
        List<Y> list = map.get(key);
        if (list == null)
        {
            list = new ArrayList<Y>();
            map.put(key, list);
        }
        list.add(value);
    }
    private static <X,Y> void removeFromMap(Map<X, List<Y>> map, X key, Y value)
    {
        List<Y> list = map.get(key);
        if (list != null)
        {
            list.remove(value);
            if (list.size() == 0)
            {
                map.remove(key);
            }
        }
    }

Semantische Details sind noch zu klären: Liefert
List<Y> list = map.get(nichtEnthaltenerKey);
eine Collections.emptyList() oder 'null' zurück? Muss man sich überlegen.

Wenn es größer aufgezogen sein soll, bieten solche Bibliotheken wie guava-libraries - Project Hosting on Google Code oder AFAIK auch Collections - Home schon vorgefertigte Klassen dafür, die meistens "MultiMap" oder so ähnlich heißen.

 

[SlaterB]

private MapListHelper<X, Y> mlh = new HashMap<X, List<Y>>();
->
private Map<X, List<Y>> mlh = new HashMap<X, List<Y>>();

 

[xZise]

Moin,
@Marco: Das wäre die andere Alternative.

@SlaterB:

private MapListHelper<X, Y> mlh = new HashMap<X, List<Y>>();
->
private Map<X, List<Y>> mlh = new HashMap<X, List<Y>>();

Und wo ist jetzt der Nutzen? Eine normale Map kann ich bedienen. Aber dann kann man nicht einfach einen Eintrag hinzufügen in die Liste sondern muss gucken ob er existiert etc.pp. Genau das sollte meine Klasse erledigen.

MfG
Fabian

PS: Sowas wie "Class helper" kann Java nicht? Ansonsten wäre das doch auch eine Möglichkeit oder, die statischen Methoden von dir Marco als class helper zu verwenden.

 

[SlaterB]

> Und wo ist jetzt der Nutzen?

na, nicht den zweiten Schritt vor dem ersten, ich habe nur deine falsche Syntax korrigiert
jetzt wo ich sehe, was deine Klasse alles kann schlage ich
> private MapListHelper<X, Y> mlh = new MapListHelper<X, Y>(map übergeben, class übergeben);
vor, so wie es in deiner Klasse eben definiert ist,

Class<? extends List<y>> wird es aber nicht geben, reicht doch einfach nur Class<? extends List>

 

[xZise]

Naja ich habe die ursprungsidee falsch aufgesetzt. Weil eigentlich wollte ich map nur um ein/zwei Methoden erweitern.

Ich habe jetzt Marcos Idee übernommen und erweitert. Damit funktioniert es ganz gut.

MfG
Fabian

 

[Marco13]

Ja, die Factory für Lists drängt sich da natürlich auf
(Reflection könnte eine Alternative sein)

Aber wie oben schon angedeutet sollte man sich über die Semantik noch Gedanken machen: Die Frage, ob eine Map 'null' als Keys und Values erlaubt steht i.a. in den JavaDocs. In diesem Fall kommen noch diffizile Details dazu:

addToMap(map,key,value);
map.containsKey(key); // true
removeFromMap(map,key,value);
List couldBeAnEmtpyListButIsNull = map.get(key);
map.containsKey(key); // false - warum?
...

EDIT: Nur nebenbei: Das ist ja alles OK so, wie es ist. Es sollte nur ggf. dokumentiert sein (und bei dir ist es dokumentiert, von daher ist alles in Ordnung)

 

[xZise]

Moin,
ich selber habe auch überlegt ob die leere Liste gelöscht werden soll. Aber wieder: Wenn man nachträglich die Klasse erweitern könnte (für den fall das die Map<x, List<y>> ist) im Stil von Helper Classes, dann würde ich einfach speichern, ob er leere Listen automatisch entfernt.

MfG
Fabian

 

[Gelöschtes Mitglied 5909]

hast du dir mal den MapBuilder von google collections angeguggt?

Der ist sehr mächtig - Beispiel:

ConcurrentMap<User, RecGraph> recommendations =
   new MapMaker()
      .weakKeys()
      .expiration(10, TimeUnit.MINUTES)
      .makeComputingMap(
         new Function<User, RecGraph>() {
           public RecGraph apply(User user) {
             return createExpensiveGraph(user);
           }
         });

Da gibts sicher auch noch mehr

Wenn nicht kannst du immernoch eine MultiMap nehmen, z.b. commons.collections