Java komplexe Map mit 2 values ?

[Mx1co]

Hallo, ich schreibe ein Programm in Java. Dieses speichert im Großen und Ganzen viele Werte von variablen ab. Ich habe mich dazu entschieden eine Map zu nutzen, die ein Key hat und als Value eine List besitzt. Diese schaut wie folgt aus :

public static Map<String, List<String>> users = new HashMap<>();

Diese heißt "users". Wie man bereits sehen kann, wird zu jedem String eine List erstellt und in diese werden mehrere Strings eingetragen. Jedoch möchte ich nun ein zweites value für diesen key haben, nämlich einen Integer. Im Endeffekt soll dann u.a die List und einen Integer für einen String-key zugewiesen werden. Ich hoffe ihr habt mein Problem verstanden. Der Integer hat jedoch nichts mit der List zu tun! Gibt es eine Möglichkeit, solch ein Model als Map zu erstellen ohne, dass ich eine zweite HashMap erstellen müsste ? Danke im Vorraus !

 

[httpdigest]

public class MapValue {
  public List<String> stringListe = new ArrayList<>();
  public int derInteger;
}
...
public static Map<String, MapValue> users = new HashMap<>();

 

[krgewb]

@httpdigest Ich habe es so verstanden, dass der Integer-Wert nur zu dem key gehören soll. Er schreib sogar "Der Integer hat jedoch nichts mit der List zu tun!"

 

[httpdigest]

Na und? Sowohl die Liste als auch der Integer sind ja mit demselben Key der Map assoziiert. Es hindert einen ja nichts daran, die Liste und den Integer in derselben MapValue Instanz getrennt voneinander zu setzen.
Wenn man keine zwei Maps verwenden will, ist das die einzige Möglichkeit.
Insofern haben der Integer-Wert und die Liste zwangsläufig was miteinander zu tun, nämlich dass sie eben zu demselben Key in der Map gehören bzw. damit logisch assoziiert sind.

 

[mihe7]

@krgewb Nimm mal Postleitzahlen als Schlüssel. Dann kannst Du einmal eine Liste der zur PLZ zugehörigen Straßennamen haben (stringListe) und einmal die Anzahl der unter dieser PLZ gemeldeten Einwohner (derInteger).

 

[httpdigest]

Das einzige, was mit einem komplexen Werte-Typ etwas schwieriger wird, sind die ganzen Map-Operationen wie das Prüfen auf Existenz eines Wertes aber nicht des anderen, auch wenn z.B. noch null als gültiger Wert zulässig sein soll, etc.
Hierfür kann man sich auch eine eigene Map schreiben (die dann selbstverständlich nicht java.util.Map implementieren kann):

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
public class TwoValueMap<K, V1, V2> {
  private class Value {
    Optional<V1> v1 = Optional.empty();
    Optional<V2> v2 = Optional.empty();
  }
  private final Value EMPTY = new Value();
  private final Map<K, Value> map;
  public TwoValueMap() {
    this(HashMap::new);
  }
  public TwoValueMap(Supplier<? extends Map<K, ?>> mapSupplier) {
    @SuppressWarnings("unchecked")
    Map<K, Value> map = (Map<K, TwoValueMap<K, V1, V2>.Value>) mapSupplier.get();
    this.map = map;
  }
  public V1 getV1(K key) {
    return map.getOrDefault(key, EMPTY).v1.orElse(null);
  }
  public V2 getV2(K key) {
    return map.getOrDefault(key, EMPTY).v2.orElse(null);
  }
  public V1 putV1(K key, V1 v1) {
    Value v = map.computeIfAbsent(key, k -> new Value());
    V1 old = v.v1.orElse(null);
    v.v1 = Optional.of(v1);
    return old;
  }
  public V2 putV2(K key, V2 v2) {
    Value v = map.computeIfAbsent(key, k -> new Value());
    V2 old = v.v2.orElse(null);
    v.v2 = Optional.of(v2);
    return old;
  }
  public boolean containsV1(K key) {
    return map.getOrDefault(key, EMPTY).v1.isPresent();
  }
  public boolean containsV2(K key) {
    return map.getOrDefault(key, EMPTY).v2.isPresent();
  }
}

 

[Mx1co]

Das einzige, was mit einem komplexen Werte-Typ etwas schwieriger wird, sind die ganzen Map-Operationen wie das Prüfen auf Existenz eines Wertes aber nicht des anderen, auch wenn z.B. noch null als gültiger Wert zulässig sein soll, etc.
Hierfür kann man sich auch eine eigene Map schreiben (die dann selbstverständlich nicht java.util.Map implementieren kann):

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
public class TwoValueMap<K, V1, V2> {
  private class Value {
    Optional<V1> v1 = Optional.empty();
    Optional<V2> v2 = Optional.empty();
  }
  private final Value EMPTY = new Value();
  private final Map<K, Value> map;
  public TwoValueMap() {
    this(HashMap::new);
  }
  public TwoValueMap(Supplier<? extends Map<K, ?>> mapSupplier) {
    @SuppressWarnings("unchecked")
    Map<K, Value> map = (Map<K, TwoValueMap<K, V1, V2>.Value>) mapSupplier.get();
    this.map = map;
  }
  public V1 getV1(K key) {
    return map.getOrDefault(key, EMPTY).v1.orElse(null);
  }
  public V2 getV2(K key) {
    return map.getOrDefault(key, EMPTY).v2.orElse(null);
  }
  public V1 putV1(K key, V1 v1) {
    Value v = map.computeIfAbsent(key, k -> new Value());
    V1 old = v.v1.orElse(null);
    v.v1 = Optional.of(v1);
    return old;
  }
  public V2 putV2(K key, V2 v2) {
    Value v = map.computeIfAbsent(key, k -> new Value());
    V2 old = v.v2.orElse(null);
    v.v2 = Optional.of(v2);
    return old;
  }
  public boolean containsV1(K key) {
    return map.getOrDefault(key, EMPTY).v1.isPresent();
  }
  public boolean containsV2(K key) {
    return map.getOrDefault(key, EMPTY).v2.isPresent();
  }
}

Danke dir für deine lange Antwort! Jedoch habe ich tatsächlich noch eine weitere Frage und ich wäre dir dankbar wenn du das beantworten könntest . Ich arbeite in meinem Programm natürlich mit mehreren Klassen und möchte übersichtshalber die Map in einer extra Klasse haben (auch in einem anderen package). Die anderen Klassen müssen natürlich auf die verschiedenen Values zugreifen können (wie du schon dafür Methoden geschrieben hast) und ebenfalls in diese Values setzen (auch deine Methoden). Wie kann ich aber nun auf diese Methoden außerhalb der Klasse mit der Map zugreifen ? ich weis, das hört sich albern an aber einfach nur die Methoden zu static zu setzen hat wenig Nutzen... Danke im voraus!

 

[temi]

Wie kann ich aber nun auf diese Methoden außerhalb der Klasse mit der Map zugreifen ?

Indem du allen Instanzen, die Zugriff auf die Daten benötigen, eine Referenz auf diese Daten, z.B. im Konstruktor übergibst. Das nennt man auch Dependency Injection.

Meiner Ansicht nach ist constructor injection die sauberste Lösung, weil damit klar ausgedrückt wird, dass die jeweilige Klasse eine Abhängigkeit zu einer anderen Klasse (hier die Daten) hat.

Ist der Parametertyp im Konstruktor dann noch ein passendes Interface, dann lässt sich die Klasse auch noch einfacher testen, weil leicht Mockobjekte übergeben werden können. Oder vielleicht möchtest du ja irgendwann man die Daten aus einer Datenbank holen...

 

[temi]

So ungefähr (quick and dirty)

public interface UserDataProvider {
    User getUser(String key);
}

public class UserDataMap implements UserDataProvider {
    private Map<String, UserData> values;
   
    // Restlicher Code weggelassen
   
    @Override
    public User getUser(final String key) {
        return values.get(key);
    }
}

// die Klassen, die diese Daten benötigen

public class Foo {
    private final UserDataProvider users;
   
    public Foo(final UserDataProvider users) {
        this.users = users;
    }
   
    // Restlicher Code weggelassen
}

public class Bar {
    private final UserDataProvider users;
   
    public Bar(final UserDataProvider users) {
        this.users = users;
    }
   
    // Restlicher Code weggelassen
}

// irgendwo z.B. in der main()

UserDataProvider users = new UserDataMap();

Foo foo = new Foo(users);
Bar bar = new Bar(users);