How to use Multimaps (Map String, ArrayList String )

Question

I was using an array to store player names, userIDs, uniqueIDs, and frag counts, but after reading about multimaps in the tutorials, it seems that would be much more efficient. However, I guess I don't quite understand it. Here's how I wanted things stored in my string array:
String[] connectedUsers = {"user1_name", "user1_userid", "user1_uniqueid", "user1_frags"
                                        "user2_name"...}and here is how I'm attempting to setup and use the 'multimap':
public class Main {
    static Map<String, ArrayList<String>> connectedUsers;
    public void updatePlayers(String name, String status) {
        String[] statusSplit = status.split(" ");
        if (connectedUsers.containsKey(name)) {
            connectedUsers.put(name, statusSplit[0]);
        else {
            connectedUsers.put(name, statusSplit[0]);
    }It's quite obvious I don't understand how this works, but should I even set this multimap up this way? Perhaps I should use a regular map with a string array for the values?

Answer 1

You're cool MrOldie. Its just that alarm bells start ringing in my head when people come on and post as much as you do.
* Created on Jul 28, 2005 by @author Tom Jacobs
package tjacobs;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
* ManyMap is a map that allows more than one value to be stored with any key
* <p>
* There are a number of methods in the class that have been deprecated because
* the original functionality of Map has been violated to accomodate the concept
* of the ManyMap
public class ManyMap<T, T2> implements Map<T, T2> {
     private HashMap<T, ArrayList<T2>> mInnerMap;
     public ManyMap() {
          mInnerMap = new HashMap<T, ArrayList<T2>>();
      * @deprecated
     public T2 get(Object obj) {
          ArrayList<T2> ar = _get(obj);
          if (ar == null || ar.size() == 0) {
               return null;
          return ar.get(0);
     public Iterator<T2> getAll(Object obj) {
          ArrayList<T2> ar = _get(obj);
          if (ar == null || ar.size() == 0) {
               return null;
          return ar.iterator();          
     public T2 put(T obj1, T2 obj2) {
          ArrayList<T2> ar = _getNotNull(obj1);
          ar.add(obj2);
          return obj2;
     public Set<Map.Entry<T, T2>> entrySet() {
          TreeSet<Map.Entry<T, T2>> entries = new TreeSet<Map.Entry<T, T2>>();
          Iterator<T> _i = mInnerMap.keySet().iterator();
          while (_i.hasNext()) {
               T key = _i.next();
               Iterator<T2> vals = mInnerMap.get(key).iterator();
               while (vals.hasNext()) {
                    Entry<T, T2> entry = new Entry<T, T2>(key, vals.next());
                    entries.add(entry);
          return entries;
     public int size() {
          return mInnerMap.size();
     public int valuesSize() {
          int vals = 0;
          Iterator<T> _i = mInnerMap.keySet().iterator();
          while (_i.hasNext()) {
               T key = _i.next();
               ArrayList<T2> ar = mInnerMap.get(key);
               vals += ar.size();
          return vals;
     public void clear() {
          mInnerMap.clear();
     public void putAll(Map<? extends T, ? extends T2> map) {
          Iterator _i = map.entrySet().iterator();
          while(_i.hasNext()) {
               Map.Entry<? extends T, ? extends T2> entry = (Map.Entry<? extends T, ? extends T2>) _i.next();
               put(entry.getKey(), entry.getValue());
     public Collection <T2> values() {
          LinkedList ll = new LinkedList();
          Iterator<ArrayList<T2>> _i = mInnerMap.values().iterator();
          while (_i.hasNext()) {
               ll.addAll(_i.next());
          return ll;
     public boolean containsValue(Object val) {
          Iterator<ArrayList<T2>> values = mInnerMap.values().iterator();
          while (values.hasNext()) {
               if (values.next().contains(val)) return true;
          return false;
     public boolean containsKey(Object key) {
          return mInnerMap.containsKey(key);
     public T2 remove(Object obj) {
          Iterator<ArrayList<T2>> values = mInnerMap.values().iterator();
          boolean found = false;
          while (values.hasNext()) {
               if (values.next().remove(obj)) {
                    found = true;
          return found ? (T2)obj : null;
     public boolean isEmpty() {
          return valuesSize() == 0;
     @SuppressWarnings("hiding")
     private class Entry<T, T2> implements Map.Entry<T, T2> {
          T key;
          T2 val;
          public Entry (T obj1, T2 obj2) {
               key = obj1;
               val = obj2;
          public T2 getValue() {
               return val;
          public T getKey() {
               return key;
          public T2 setValue(T2 obj) {
               return val = obj;
     public Set<T> keySet() {
          return mInnerMap.keySet();
     public ArrayList<T2> _get (Object obj) {
          return mInnerMap.get(obj);
     public ArrayList<T2> _getNotNull (T obj) {
          ArrayList<T2> list = _get(obj);
          if (list == null) {
               list = new ArrayList<T2>(1);
               mInnerMap.put(obj, list);
          return list;
}Edited by: tjacobs01 on Aug 19, 2008 12:28 PM