Implement a Multimap in Java

In this post, we will see how to implement a Multimap in Java.

A Multimap is a map that allows mapping of a single key to multiple values. Since JDK doesn’t provides any implementation of the Multimap, programmers often miss it in Java. Although, Google’s Guava Library and Apache Commons Collections both provides implementation of the Multimap interface, wouldn’t it be great to implement our own Multimap class in Java which we can customize to our style.

Well writing a Multimap class is actually very simple in Java. Below is simple custom implementation of Multimap class in Java using a Map and a Collection.

import java.util.*;

class MultiMap<K, V>
{
	private Map<K, Collection<V>> map = new HashMap<>();

	/**
	* Add the specified value with the specified key in this multimap.
	*/
	public void put(K key, V value) {
		if (map.get(key) == null)
			map.put(key, new ArrayList<V>());

		map.get(key).add(value);
	}

	/**
	* Associate the specified key with the given value if not
	* already associated with a value
	*/
	public void putIfAbsent(K key, V value) {
		if (map.get(key) == null)
			map.put(key, new ArrayList<>());

		// if value is absent, insert it
		if (!map.get(key).contains(value)) {
			map.get(key).add(value);
		}
	}

	/**
	* Returns the Collection of values to which the specified key is mapped,
	* or null if this multimap contains no mapping for the key.
	*/
	public Collection<V> get(Object key) {
		return map.get(key);
	}

	/**
	* Returns a Set view of the keys contained in this multimap.
	*/
	public Set<K> keySet() {
		return map.keySet();
	}

	/**
	* Returns a Set view of the mappings contained in this multimap.
	*/
	public Set<Map.Entry<K, Collection<V>>> entrySet() {
		return map.entrySet();
	}

	/**
	* Returns a Collection view of Collection of the values present in 
	* this multimap.
	*/
	public Collection<Collection<V>> values() {
		return map.values();
	}

	/**
	* Returns true if this multimap contains a mapping for the specified key.
	*/
	public boolean containsKey(Object key) {
		return map.containsKey(key);
	}

	/**
	* Removes the mapping for the specified key from this multimap if present
	* and returns the Collection of previous values associated with key, or
	* null if there was no mapping for key.
	*/
	public Collection<V> remove(Object key) {
		return map.remove(key);
	}

	/**
	* Returns the number of key-value mappings in this multimap.
	*/
	public int size() {
		int size = 0;
		for (Collection<V> value: map.values()) {
			size += value.size();
		}
		return size;
	}

	/**
	* Returns true if this multimap contains no key-value mappings.
	*/
	public boolean isEmpty() {
		return map.isEmpty();
	}

	/**
	* Removes all of the mappings from this multimap.
	*/
	public void clear() {
		map.clear();
	}

	/**
	* Removes the entry for the specified key only if it is currently
	* mapped to the specified value and return true if removed
	*/
	public boolean remove(K key, V value) {
		if (map.get(key) != null) // key exists
			return map.get(key).remove(value);

		return false;
	}

	/**
	* Replaces the entry for the specified key only if currently
	* mapped to the specified value and return true if replaced
	*/
	public boolean replace(K key, V oldValue, V newValue) {

		if (map.get(key) != null) {
			if (map.get(key).remove(oldValue))
				return map.get(key).add(newValue);
		}
		return false;
	}
}

class MapUtils
{
	// Multimap implementation in Java
	public static void main(String[] args)
	{
		// create a Multimap from past US presidents list
		MultiMap<String, String> multimap = new MultiMap();

		multimap.put("Zachary", "Taylor");
		multimap.put("John", "Adams");
		multimap.put("John", "Tyler");
		multimap.put("John", "Kennedy");
		multimap.put("George", "Washington");
		multimap.put("George", "Bush");
		multimap.put("Grover", "Cleveland");

		System.out.println("----- Printing Multimap using keySet -----\n");
		for (String lastName : multimap.keySet()) {
			System.out.println(lastName + ": " + multimap.get(lastName));
		}
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

import java.util.*;

class MultiMap<K, V>

{

private Map<K, Collection<V>> map = new HashMap<>();

/**

* Add the specified value with the specified key in this multimap.

public void put(K key, V value) {

if (map.get(key) == null)

map.put(key, new ArrayList<V>());

map.get(key).add(value);

}

/**

* Associate the specified key with the given value if not

* already associated with a value

public void putIfAbsent(K key, V value) {

if (map.get(key) == null)

map.put(key, new ArrayList<>());

// if value is absent, insert it

if (!map.get(key).contains(value)) {

map.get(key).add(value);

}

/**

* Returns the Collection of values to which the specified key is mapped,

* or null if this multimap contains no mapping for the key.

public Collection<V> get(Object key) {

return map.get(key);

}

/**

* Returns a Set view of the keys contained in this multimap.

public Set<K> keySet() {

return map.keySet();

}

/**

* Returns a Set view of the mappings contained in this multimap.

public Set<Map.Entry<K, Collection<V>>> entrySet() {

return map.entrySet();

}

/**

* Returns a Collection view of Collection of the values present in

* this multimap.

public Collection<Collection<V>> values() {

return map.values();

}

/**

* Returns true if this multimap contains a mapping for the specified key.

public boolean containsKey(Object key) {

return map.containsKey(key);

}

/**

* Removes the mapping for the specified key from this multimap if present

* and returns the Collection of previous values associated with key, or

* null if there was no mapping for key.

public Collection<V> remove(Object key) {

return map.remove(key);

}

/**

* Returns the number of key-value mappings in this multimap.

public int size() {

int size = 0;

for (Collection<V> value: map.values()) {

size += value.size();

}

return size;

}

/**

* Returns true if this multimap contains no key-value mappings.

public boolean isEmpty() {

return map.isEmpty();

}

/**

* Removes all of the mappings from this multimap.

public void clear() {

map.clear();

}

/**

* Removes the entry for the specified key only if it is currently

* mapped to the specified value and return true if removed

public boolean remove(K key, V value) {

if (map.get(key) != null) // key exists

return map.get(key).remove(value);

return false;

}

/**

* Replaces the entry for the specified key only if currently

* mapped to the specified value and return true if replaced

public boolean replace(K key, V oldValue, V newValue) {

if (map.get(key) != null) {

if (map.get(key).remove(oldValue))

return map.get(key).add(newValue);

}

return false;

}

class MapUtils

{

// Multimap implementation in Java

public static void main(String[] args)

{

// create a Multimap from past US presidents list

MultiMap<String, String> multimap = new MultiMap();

multimap.put("Zachary", "Taylor");

multimap.put("John", "Adams");

multimap.put("John", "Tyler");

multimap.put("John", "Kennedy");

multimap.put("George", "Washington");

multimap.put("George", "Bush");

multimap.put("Grover", "Cleveland");

System.out.println("----- Printing Multimap using keySet -----\n");

for (String lastName : multimap.keySet()) {

System.out.println(lastName + ": " + multimap.get(lastName));

}

Download Run Code

Output:

—– Printing Multimap using keySet —–

George: [Washington, Bush]
Zachary: [Taylor]
John: [Adams, Tyler, Kennedy]
Grover: [Cleveland, Cleveland]

Also See: Google Guava’s Multimap Interface in Java

References: HashMap (Java Platform SE 8 )

1 Star 2 Stars 3 Stars 4 Stars 5 Stars (1 votes, average: 5.00 out of 5)

Thanks for reading.

Please use our online compiler to post code in comments. To contribute, get in touch with us.
Like us? Please spread the word and help us grow. Happy coding 🙂

Sharing is caring:

Leave a Reply