1. Overview

In this tutorial we’ll illustrate the most useful ways you can leverage Guava to work with Java Maps.

Let’s start very simple and create a HashMap without the new operator, using Guava:

Map<String, String> aNewMap = Maps.newHashMap();

2. ImmutableMap

Next – let’s see how to create ImmutableMap using Guava:

@Test
public void whenCreatingImmutableMap_thenCorrect() {
 Map<String, Integer> salary = ImmutableMap.<String, Integer> builder()
 .put("John", 1000)
 .put("Jane", 1500)
 .put("Adam", 2000)
 .put("Tom", 2000)
 .build();

 assertEquals(1000, salary.get("John").intValue());
 assertEquals(2000, salary.get("Tom").intValue());
}

3. SortedMap

Now – let’s take a look at creating and working with a SortedMap.

In the following example – we’re creating a sorted map using the corresponding Guava builder:

@Test
public void whenUsingSortedMap_thenKeysAreSorted() {
 ImmutableSortedMap<String, Integer> salary = new ImmutableSortedMap
 .Builder<String, Integer>(Ordering.natural())
 .put("John", 1000)
 .put("Jane", 1500)
 .put("Adam", 2000)
 .put("Tom", 2000)
 .build();

 assertEquals("Adam", salary.firstKey());
 assertEquals(2000, salary.lastEntry().getValue().intValue());
}

4. BiMap

Next – let’s discuss how to use BiMap. We can use BiMap to map keys back to values as it makes sure the values are unique.

In the following example – we create a BiMap and the we get its inverse():

@Test
public void whenCreateBiMap_thenCreated() {
 BiMap<String, Integer> words = HashBiMap.create();
 words.put("First", 1);
 words.put("Second", 2);
 words.put("Third", 3);

 assertEquals(2, words.get("Second").intValue());
 assertEquals("Third", words.inverse().get(3));
}

5. Multimap

Now – let’s take a look at Multimap.

We can use Multimap to associate each key with multiple values as in the following example:

@Test
public void whenCreateMultimap_thenCreated() {
 Multimap<String, String> multimap = ArrayListMultimap.create();
 multimap.put("fruit", "apple");
 multimap.put("fruit", "banana");
 multimap.put("pet", "cat");
 multimap.put("pet", "dog");

 assertThat(multimap.get("fruit"), containsInAnyOrder("apple", "banana"));
 assertThat(multimap.get("pet"), containsInAnyOrder("cat", "dog"));
}

5. Table

Let’s now take a look at the Guava Table; we use Table if we need more than one key to index a value.

In the following example – we’re going to use a table to store the distances between cities:

@Test
public void whenCreatingTable_thenCorrect() {
 Table<String,String,Integer> distance = HashBasedTable.create();
 distance.put("London", "Paris", 340);
 distance.put("New York", "Los Angeles", 3940);
 distance.put("London", "New York", 5576);

 assertEquals(3940, distance.get("New York", "Los Angeles").intValue());
 assertThat(distance.columnKeySet(), 
 containsInAnyOrder("Paris", "New York", "Los Angeles"));
 assertThat(distance.rowKeySet(), containsInAnyOrder("London", "New York"));
}

We can also use Tables.transpose() to flip the row and column keys as in the following example:

@Test
public void whenTransposingTable_thenCorrect() {
 Table<String,String,Integer> distance = HashBasedTable.create();
 distance.put("London", "Paris", 340);
 distance.put("New York", "Los Angeles", 3940);
 distance.put("London", "New York", 5576);

 Table<String, String, Integer> transposed = Tables.transpose(distance);

 assertThat(transposed.rowKeySet(), 
 containsInAnyOrder("Paris", "New York", "Los Angeles"));
 assertThat(transposed.columnKeySet(), containsInAnyOrder("London", "New York"));
}

6. ClassToInstanceMap

Next – Let’s take a look at ClassToInstanceMap. We can use ClassToInstanceMap if we want the object’s class to be the key as in the following example:

@Test
public void whenCreatingClassToInstanceMap_thenCorrect() {
 ClassToInstanceMap<Number> numbers = MutableClassToInstanceMap.create();
 numbers.putInstance(Integer.class, 1);
 numbers.putInstance(Double.class, 1.5);

 assertEquals(1, numbers.get(Integer.class));
 assertEquals(1.5, numbers.get(Double.class));
}

7. Group List Using Multimap

Next – let’s see how to group a List using Multimap. In the following example – we group a List of names by their length using Multimaps.index():

@Test
public void whenGroupingListsUsingMultimap_thenGrouped() {
 List<String> names = Lists.newArrayList("John", "Adam", "Tom");
 Function<String,Integer> func = new Function<String,Integer>(){
 public Integer apply(String input) {
 return input.length();
 }
 };
 Multimap<Integer, String> groups = Multimaps.index(names, func);

 assertThat(groups.get(3), containsInAnyOrder("Tom"));
 assertThat(groups.get(4), containsInAnyOrder("John", "Adam"));
}

8. Conclusion

In this quick tutorial we discussed the most common and useful usecases of working with Maps using the Guava library.