How can I store multiple values under a single key in a Java HashMap?

Storing Multiple Values under a Single Key in a HashMap

Maps in Java associate keys with single values, but you may encounter the need to store multiple values under the same key. This question explores how to achieve this functionality.

Map with List as Value

One approach is to use a map where the value is a list. This allows you to store multiple values as a list associated with the key. However, this has the limitation that the list can contain any number of values, not just two.

Using a Wrapper Class

You could also create a separate wrapper class that holds the values and place instances of this wrapper in the map. This approach requires defining a class and creating instances for each key, resulting in additional code.

Tuple-Based approach

If you want to enforce a fixed number of values, you can use a tuple class (often found in libraries or by implementing your own). Maps can then store tuples as values, ensuring a consistent structure for multiple values under a key.

Multiple Maps

Another option is to use multiple maps, one for each value. This approach is straightforward but may introduce the risk of the maps getting out of sync if not handled carefully.

Examples

Map with List as Value

import java.util.*;

class Person {
  String name;
  public Person(String name) { this.name = name;  }
  public String toString() { return this.name; }
}

class HashMapMultiple {

  public HashMapMultiple() {

    Map<String, List<Person>> peopleByForename = new HashMap<>();

    List<Person> people = new ArrayList<>();
    people.add(new Person("Bob Smith"));
    people.add(new Person("Bob Jones"));
    peopleByForename.put("Bob", people);

    List<Person> bobs = peopleByForename.get("Bob");
    Person bob1 = bobs.get(0);
    Person bob2 = bobs.get(1);

    System.out.println("Bob1: " + bob1);
    System.out.println("Bob2: " + bob2);
  }

  public static void main(String[] args) {
    new HashMapMultiple();
  }
}

Using a Wrapper Class

import java.util.*;

class Person { String name; public Person(String name) { this.name = name; } public String toString() { return this.name; } }

class Wrapper {
  public Wrapper(Person person1, Person person2) { this.person1 = person1; this.person2 = person2; }

  public Person getPerson1() { return this.person1; }
  public Person getPerson2() { return this.person2; }

  private Person person1;
  private Person person2;
}

class HashMapMultiple {

  public HashMapMultiple() {

    Map<String, Wrapper> peopleByForename = new HashMap<>();

    peopleByForename.put("Bob", new Wrapper(new Person("Bob Smith"), new Person("Bob Jones")));

    Wrapper bobs = peopleByForename.get("Bob");
    Person bob1 = bobs.getPerson1();
    Person bob2 = bobs.getPerson2();

    System.out.println("Bob1: " + bob1);
    System.out.println("Bob2: " + bob2);
  }

  public static void main(String[] args) {
    new HashMapMultiple();
  }
}

Tuple-Based Approach

This approach requires a tuple class:

import java.util.*;

class Person { String name; public Person(String name) { this.name = name; } public String toString() { return this.name; } }

class Tuple2<T1,T2>  {
  public Tuple2(T1 val1, T2 val2) { this.val1 = val1; this.val2 = val2; }
  public T1 val1;
  public T2 val2;
}

class HashMapMultiple {

  public HashMapMultiple() {

    Map<String, Tuple2<Person, Person>> peopleByForename = new HashMap<>();

    peopleByForename.put("Bob", new Tuple2<Person, Person>(new Person("Bob Smith"), new Person("Bob Jones")));

    Tuple2<Person, Person> bobs = peopleByForename.get("Bob");
    Person bob1 = bobs.val1;
    Person bob2 = bobs.val2;

    System.out.println("Bob1: " + bob1);
    System.out.println("Bob2: " + bob2);
  }

  public static void main(String[] args) {
    new HashMapMultiple();
  }
}

Multiple Maps

import java.util.*;

class Person { String name; public Person(String name) { this.name = name; } public String toString() { return this.name; } }

class HashMapMultiple {

  public HashMapMultiple() {

    Map<String, Person> firstPersonByForename = new HashMap<>();
    Map<String, Person> secondPersonByForename = new HashMap<>();

    firstPersonByForename.put("Bob", new Person("Bob Smith"));
    secondPersonByForename.put("Bob", new Person("Bob Jones"));

    Person bob1 = firstPersonByForename.get("Bob");
    Person bob2 = secondPersonByForename.get("Bob");

    System.out.println("Bob1: " + bob1);
    System.out.println("Bob2: " + bob2);
  }

  public static void main(String[] args) {
    new HashMapMultiple();
  }
}

The above is the detailed content of How can I store multiple values under a single key in a Java HashMap?. For more information, please follow other related articles on the PHP Chinese website!