groovy

Add putEach method to Map

Details

  • Type: New Feature New Feature
  • Status: Closed Closed
  • Priority: Minor Minor
  • Resolution: Fixed
  • Affects Version/s: 1.5.4
  • Fix Version/s: 1.6.1, 1.7.0
  • Component/s: groovy-jdk
  • Labels:
    None
  • Number of attachments :
    0

Description

I've frequently run across the situation where I want to create a map from two equal sized lists, using one list for the keys and a second list for the values.

Maybe I'm missing something, but I can't seem to find a compact way to do this that doesn't require a for loop or an intermediate variable. The best I've come up with is to add this method to Map:

Map.metaClass.putEach = { List keylist, List valuelist ->
assert keylist.size == valuelist.size
for (int i=0; i < keylist.size; i++)

{ delegate.put(keylist[i], valuelist[i]) }

delegate
}

This allows you to just call putEach on any Map passing in two equal sized lists, e.g.:

assert [:].putEach(['key1', 'key2', 'key3'], ['value1', 'value2', 'value3']) == ['key1':'value1', 'key2':'value2', 'key3':'value3']

Since this seems generally useful, it might be something worth adding to the base GDK.

Activity

Ascending order - Click to sort in descending order
Hide
Permalink
Jim LoVerde added a comment -

Just a note, I've also written another version that doesn't require the lists to be the same size.

Map.metaClass.putEach = { List keylist, List valuelist ->
int count = Math.max(keylist.size, valuelist.size)
for (int i=0; i < count; i++)

{ def key = (keylist.size > i) ? keylist[i] : null def value = (valuelist.size > i) ? valuelist[i] : null delegate.put(key, value) }

delegate
}

This version is more flexible, but it can cause surprising results, e.g. this situation where the keylist is shorter than the valuelist:
assert [:].putEach(['key1'], ['value1', 'value2', 'value3']) == ['key1':'value1', (null):'value3']

I'm not sure which version you would consider to be more in the spirit of Groovy's JDK, but wanted to mention this second version.

Show
Jim LoVerde added a comment - Just a note, I've also written another version that doesn't require the lists to be the same size. Map.metaClass.putEach = { List keylist, List valuelist -> int count = Math.max(keylist.size, valuelist.size) for (int i=0; i < count; i++) { def key = (keylist.size > i) ? keylist[i] : null def value = (valuelist.size > i) ? valuelist[i] : null delegate.put(key, value) } delegate } This version is more flexible, but it can cause surprising results, e.g. this situation where the keylist is shorter than the valuelist: assert [:] .putEach( ['key1'] , ['value1', 'value2', 'value3'] ) == ['key1':'value1', (null):'value3'] I'm not sure which version you would consider to be more in the spirit of Groovy's JDK, but wanted to mention this second version.
Hide
Permalink
Paul King added a comment -

I am thinking a putAll method might work for your use case:

     /**
+     * Provides an easy way to append multiple Map.Entry values to a Map.
+     *
+     * @param self    a Map
+     * @param entries a List of Map.Entry items to be added to the Map.
+     * @return the same map, after the items have been added to it.
+     * @since 1.7.0
+     */
+    public static Map putAll(Map self, List<Map.Entry> entries) {
+        for (Map.Entry entry : entries) {
+            self.put(entry.getKey(), entry.getValue());
+        }
+        return self;
+    }

An example of usage would be:

def keys = ['key1', 'key2', 'key3']
def values = ['val1', 'val2', 'val3']
def pairs = [keys, values].transpose()

// current alternative 1
def map = [:]
pairs.each{ k, v -> map[k] = v }
println map

// current alternative 2
def map2 = [:]
pairs.each{ map2 << (it as MapEntry) }
println map2

// current alternative 3
def map3 = pairs.inject([:]){ items, next -> items << (next as MapEntry) }
println map3

// proposed method
def map4 = [:]
map4.putAll pairs.collect{ it as MapEntry }
println map4
Show
Paul King added a comment - I am thinking a putAll method might work for your use case: /** + * Provides an easy way to append multiple Map.Entry values to a Map. + * + * @param self a Map + * @param entries a List of Map.Entry items to be added to the Map. + * @ return the same map, after the items have been added to it. + * @since 1.7.0 + */ + public static Map putAll(Map self, List<Map.Entry> entries) { + for (Map.Entry entry : entries) { + self.put(entry.getKey(), entry.getValue()); + } + return self; + } An example of usage would be: def keys = ['key1', 'key2', 'key3'] def values = ['val1', 'val2', 'val3'] def pairs = [keys, values].transpose() // current alternative 1 def map = [:] pairs.each{ k, v -> map[k] = v } println map // current alternative 2 def map2 = [:] pairs.each{ map2 << (it as MapEntry) } println map2 // current alternative 3 def map3 = pairs.inject([:]){ items, next -> items << (next as MapEntry) } println map3 // proposed method def map4 = [:] map4.putAll pairs.collect{ it as MapEntry } println map4
Hide
Permalink
Paul King added a comment -

I ended adding two map DGM methods: a putAll method (the typical Java mutable style) and a plus method (to allow the typical functional style which doesn't modify original). Your example becomes something like:

def keys = ['key1', 'key2', 'key3']
def vals = ['val1', 'val2', 'val3']
def pairs = [keys, vals].transpose()
def entries = pairs.collect{ it as MapEntry }
// modify original and then return it
assert [:].putAll(entries) == ['key1':'val1', 'key2':'val2', 'key3':'val3']

// leave original but add new entries
assert [:] + entries == ['key1':'val1', 'key2':'val2', 'key3':'val3']

I think these methods represent good building blocks and combine well with existing methods to allow various kinds of map modifications.

I am closing the issue but please reopen if you think your use case isn't adequately catered for.

Show
Paul King added a comment - I ended adding two map DGM methods: a putAll method (the typical Java mutable style) and a plus method (to allow the typical functional style which doesn't modify original). Your example becomes something like: def keys = ['key1', 'key2', 'key3'] def vals = ['val1', 'val2', 'val3'] def pairs = [keys, vals].transpose() def entries = pairs.collect{ it as MapEntry } // modify original and then return it assert [:].putAll(entries) == ['key1':'val1', 'key2':'val2', 'key3':'val3'] // leave original but add new entries assert [:] + entries == ['key1':'val1', 'key2':'val2', 'key3':'val3'] I think these methods represent good building blocks and combine well with existing methods to allow various kinds of map modifications. I am closing the issue but please reopen if you think your use case isn't adequately catered for.

People

  • Assignee:
    Paul King
    Reporter:
    Jim LoVerde
Vote (0)
Watch (0)

Dates

  • Created:
    Updated:
    Resolved: