Java convert {String,String}[] to Map<String,String[]>

Question

Given the class:

 public class CategoryValuePair
 {
      String category;
      String value;
 }

And a method:

public Map<String,List<String>> convert(CategoryValuePair[] values);

Given that in values we can receive many entries with the same category, I want to convert these into a Map grouped on category.

Is there a quick / efficient way to perform this conversion?

Answer 1

As far as I know there is not easier way than iterating on values, and then putting the values in the map (like some predefined method).

Map<String, List<String>> map = new HashMap<String, List<String>>();
if (values != null) {
    for (CategoryValuePair cvp : values) {
      List<String> vals = map.get(cvp.category);
      if (vals == null) {
        vals = new ArrayList<String>();
        map.put(cvp.category, vals);
      }
      vals.add(cvp.value);
    }
}

I changed the map values from String[] to List<String> since it seems easier to me to use that so you don't have to hassle with array resizing.

Answer 2

public Map<String, List<String>> convert(CategoryValuePair[] values) {
    Map<String, List<String>> toReturn = new HashMap<String, List<String>>();
    if (values != null) {
        for (CategoryValuePair categoryValuePair : values) {
            if (!toReturn.containsKey(categoryValuePair.category)) {
                toReturn.put(categoryValuePair.category, new ArrayList<String>());
            }
            toReturn.get(categoryValuePair.category).add(categoryValuePair.value);
        }
    }
    return toReturn;
}

Answer 3

Just for the sake of implementation... The method returns Map and also checks for duplicates in the arrays... though performance wise its heavy ...

public Map<String,String[]> convert(CategoryValuePair[] values)
{
    Map<String, String[]> map = new HashMap<String, String[]>();
    for (int i = 0; i < values.length; i++) {
        if(map.containsKey(values[i].category)){
            Set<String> set = new HashSet<String>(Arrays.asList(map.get(values[i].category)));
            set.add(values[i].value);
            map.put(values[i].category, set.toArray(new String[set.size()]));
        }else {
            map.put(values[i].category, new String[]{values[i].value});
        }
    }

    return map;
}

Answer 4

To make it in fewer lines of code, use Google Collections:

public Map<String, Collection<String>> convert(CategoryValuePair[] values) {
    Multimap<String, String> mmap = ArrayListMultimap.create();
    for (CategoryValuePair value : values) {
        mmap.put(value.category, value.value);
    }
    return mmap.asMap();
}

If you don't want to allow duplicate values, replace ArrayListMultimap with HashMultimap.

Answer 5

With lambdaj you just need one line of code to achieve that result as it follows:

group(values, by(on(CategoryValuePair.class).getCategory()));