refenrece:

change Map in condition

[ 'a': 1, 'b': 2, 'c': 3 ].collectEntries { ( it.value > 1 ) ? [ "${it.key}" : 4 ] : it }
===> [a:1, b:4, c:4]
  • or [ it.key, 4 ]
    [ 'a': 1, 'b': 2, 'c': 3 ].collectEntries { ( it.value > 1 ) ? [ it.key, 4 ] : it }
  • or [ (it.key) : 4 ]
    [ 'a': 1, 'b': 2, 'c': 3 ].collectEntries { ( it.value > 1 ) ? [ (it.key) : 4 ] : it }

filter

filter via condition

[ 'a': 1, 'b': 2, 'c': 3 ].findAll{ it.value > 1 }.collectEntries { [ it.key, 4 ] }
===> [b:4, c:4]

find a string in a nested Map by using recursive function

def hasValue( Map m, String value ) {
  m.containsValue(value) || m.values().find { v -> v instanceof Map && hasValue(v, value) }
}

def hasValue( Map m, String value ) {
  if ( m.containsValue(value) ) return m.containsValue(value)
  m.findResult { k, v -> v instanceof Map ? hasValue(v, value) : null }
}

find a string exists in a list of Map

def isTargetExists( Map m, String subKey, String value ) {
  def map = m.findAll { it.value instanceof Map }.collect { it.key }
  return m.subMap(map).any { k, v -> v.get(subKey, []).contains(value) }
}

Map<String, Map<String, String>> matrix = [
  dev : [
    user: ['dev1', 'dev2', 'dev3'] ,
    passwd: '123456',
    customer: ['yahoo', 'bing']
  ] ,
  staging : [
    user: ['stg1', 'stg2', 'stg3'] ,
    passwd: 'abcdefg' ,
    customer: ['google', 'huawei']
  ] ,
  prod : [
    user: ['prod1', 'prod2', 'prod3'] ,
    passwd: 'a1b2c3d4'
  ]
]

assert isTargetExists( matrix, 'user', 'dev4' ) == false
assert isTargetExists( matrix, 'customer', 'huawei' ) == true

merge two maps

for <String, List<String>>

Closure merger = { Map newMap, Map currentMap ->
  currentMap.inject(newMap.clone()) { merged, entry ->
    merged[entry.key] = merged.getOrDefault( entry.key, [] ) + entry.value
    merged
  }
}

for <String, Map<String, List<String>>>

def m1 = [ k1: [ l1: ['s1', 's2']]]
def m2 = [ k1: [ l1: ['s3', 's4']], k2: [ l2: ['x1', 'x2']] ]
def accumulator = [:].withDefault{ [:].withDefault{ [] } }
Closure merger

merger = { Map trg, Map m ->
  m.each{ k, v ->
    switch( v instanceof java.util.LinkedHashMap ){
      case true  : merger trg[ k ], v ; break ;
      case false : trg[ k ].addAll v  ; break ;
    }
  }
}
[ m1, m2 ].each merger.curry( accumulator )
assert accumulator == [k1:[l1:['s1', 's2', 's3', 's4']], k2:[l2:['x1', 'x2']]]

merge and sum

preconditions:

Map<String, Integer> m1 = [ a : 10, b : 2, c : 3 ]
Map<String, Integer> m2 = [ b : 3,  c : 2, d : 5 ]
List<Map<String, Integer>> maps = [ m1, m2 ]

  • merge values into list

    maps.sum { it.keySet() }.collectEntries { key ->
  [key, maps.findResults { it[key] } ]
}

// result
// [a:[10], b:[2, 3], c:[3, 2], d:[5]]

  • sum lists

    def process( List maps ) {
  maps.sum { it.keySet() }.collectEntries { key ->
    [ key, maps.findResults { it[key] }.sum() ]
  }
}

    • or more elegant way via Clousre:

      > ```groovy
> Closure getSum = { x -> x.sum() }
> getSum( [1,2,3,4] ) == 10
> ```


      def process( List maps ) {
  Closure getSum = { x -> x.sum() }
  maps.sum { it.keySet() }.collectEntries { key ->
    [ key, getSum(maps.findResults { it[key] }) ]
  }
}

    • which can be extended to:

      def process( List maps, Closure closure ) {
  maps.sum { it.keySet() }.collectEntries { key ->
    [ key, closure(maps.findResults { it[key] }) ]
  }
}

// merge maps and get sum
process(maps){ x -> x.sum() }                           // [a:10, b:5, c:5, d:5]
// merge maps and get product
process(maps){ x -> x.inject(1) { sum, n -> sum * n }   // [a:10, b:6, c:6, d:5]
// merge maps and get the biggest item
process(maps){ x -> x.inject(x[0]) { biggest, n -> biggest > n ? biggest : n } } // [a:10, b:3, c:3, d:5]

map withDefault

def newMap = [:].withDefault { [] }
[ a:1, b:2, c:2 ].each { key, val ->
                         newMap[val] << key
                       }
assert newMap == [1:['a'], 2:['b','c']]

  • alternative

    [ a:1, b:2, c:2 ].inject([:].withDefault{[]}) { map, k, v ->
  map[v] << k
  map
}
    • result:
      [ 1:['a'], 2:['b', 'c'] ]

  • alternatives

    [ a:1, b:2, c:2 ].groupBy{ it.value }
                 .collectEntries{ k, v -> [ (k): v.collect{ it.key } ] }
    • result:
      [ 1:['a'], 2:['b', 'c'] ]

merge maps

Map map1 = [x: 1, y: 2]
Map map2 = [z: 3]
Map merged = map1.withDefault(map2.&get)
assert map1 == merged                    // quit interesting
assert 3 == merged.get('z')
  • result
    [ 'x':1, 'y':2 ]

get key or value from nested Map

insprired from :

  • objective:

    Map<String, Map<String, String>> map = [
  k1 : [ k11 : 'v11' ] ,
  k2 : [ k11 : 'v21' ] ,
  k3 : [ k11 : 'v31' ]
]

   ⇣⇣

findKeyBelongsTo( 'k11' )    »  'k1'
findValueBelongsTo( 'v31' )  »  'k3'

find parent key via sub-key:

try online

def findKeyBelongsTo( Map map, String keyword ) {
  map.find { keyword in it.value.keySet() }?.key
}
  • find in nested map recursively :
    def findKeyBelongsTo( Map map, String keyword ) {
  map.findResult { k, v ->
    v instanceof Map
      ? v.containsKey(keyword) ? k : findKeyBelongsTo( v, keyword )
      : null
  }
}

find value belongs to which key

find parent key via sub-value: try online

def findValueBelongsTo( Map map, String keyword ) {
  map.find { keyword in it.value.values() }?.key
}

  • find in nested map recursively (according to value):

    def findValueBelongsTo( Map map, String keyword ) {
  map.findResult { k, v ->
    v instanceof Map
      ? v.containsValue(keyword) ? k : findValueBelongsTo( v, keyword )
      : null
  }
}

  • find in mixed map & list object recursively :

    [!TIP]

    Map<String, String> LOGGER = [
       info : [ 'info', 'i' ],
   warnning : [ 'warning' , 'warn', [ 'key' : 'value' ] , 'w' ] ,
      error : [ 'error', 'err', 'e']
]
⇣⇣
assert 'info'    == findValueBelongsTo( LOGGER , 'i'     )
assert 'warning' == findValueBelongsTo( LOGGER , 'value' )
assert 'error'   == findValueBelongsTo( LOGGER , 'err'   )

    def findValueBelongsTo = { Map map, String keyword ->
  map.find { k, v ->
    v instanceof Map
      ? v.containsKey( keyword ) ? k : findValueBelongsTo(v, keyword)
      : v.contains( keyword ) ?: v.any{ it instanceof Map }
                                 ? findValueBelongsTo( v.findAll{ it instanceof Map }.inject([:]) { i, m ->  m << i; m }, keyword)
                                 : [:]

  }?.key ?: null
}

  • find in mixed map & list object recursively with Closure:

    [!TIP] call() will be abnormal in recursive calls in Closure

    Closure findValueBelongsTo
findValueBelongsTo = { Map map, String keyword ->
  map.find { k, v ->
    v instanceof Map
      ? v.containsKey( keyword ) ? k : findValueBelongsTo( v, keyword )
      : v.contains( keyword ) ?: v.any{ it instanceof Map }
                                  ? findValueBelongsTo( v.findAll{ it instanceof Map }.inject([:]) { i, m ->  m << i; m }, keyword)
                                  : [:]

  }?.key ?: null
}

findResult & findResults

reference:

  • collect: return all result (with null)
    groovy:000> [a: 1, b: 2, c: 3, d: 4].collect{ k, v -> v>2 ? (k + '->' + v) : null }
===> [null, null, c->3, d->4]

  • findResult: return the first eligible value (first non-null element)

    groovy:000> [a: 1, b: 2, c: 3, d: 4].findResult{ k, v -> v>2 ? (k + '->' + v) : null }
===> c->3

  • findResults: find all eligible values (all non-null elements)

    groovy:000> [a: 1, b: 2, c: 3, d: 4].findResults{ k, v -> v>2 ? (k + '->' + v) : null }
===> [c->3, d->4]

find deep in nested map

Example Map structure:

Map map = [
  'a': [
    'b': [
      'c': [
        'd' : '1',
        'e' : '2',
        'f' : '3'
      ], // c
      'g': '4',
      'h': [
        'i': '5',
        'j': '6',
        'k': '7'
      ] // h
    ], // b
    'l': [
      'm': '8',
      'n': '9'
    ], // l
    'o': '10'
  ] // a
]

find value via key name recursively

try online

def findValues( Map map, String keyword ) {
  map.findResult { k, v ->
    v instanceof Map
      ? v.containsKey(keyword) ? v.getOrDefault(keyword, null) : findValues( v, keyword )
      : null
  }
}

alternatives

def findValues( Map map, String keyword ) {
  if( map.containsKey(keyword) ) return map.getOrDefault( keyword, null )
  map.findResult { k, v -> v instanceof Map ? findValues(v, keyword) : null }
}

  • result

    println "~~> findValues( map, 'f' )    : ${findValues( map, 'f' )} "
println "~~> findValues( map, 'o' )    : ${findValues( map, 'o' )} "
println "~~> findValues( map, 'aaaa' ) : ${findValues( map, 'aaaa' )} "

/**
 * console output
 * ~~> findValues( m, 'f' )    : 3
 * ~~> findValues( m, 'o' )    : 10
 * ~~> findValues( m, 'aaaa' ) : null
**/

  • alternatives

    try online

    def hasValues(Map m, String key) {
  m.containsKey(key) || m.find { k, v -> v instanceof Map && hasValues(v, key) }
}

    • result

      println "~~> hasValues( map, 'f' )    : ${hasValues( map, 'f' )} "
println "~~> hasValues( map, 'o' )    : ${hasValues( map, 'o' )} "
println "~~> hasValues( map, 'aaaa' ) : ${hasValues( map, 'aaaa' )} "

/**
 * console output
 * ~~> hasValues( m, 'f' )    : true
 * ~~> hasValues( m, 'o' )    : true
 * ~~> hasValues( m, 'aaaa' ) : false
**/

inject

  • Join Elements to a String
    def map = [q: 'groovy', maxResult: 10, start: 0, format: 'xml']
def params = map.inject([]) { result, entry ->
  result << "${entry.key}=${URLEncoder.encode(entry.value.toString())}"
}.join('&')
assert 'q=groovy&maxResult=10&start=0&format=xml' == params

collect & collectMany

collectEntries

  • List<Map<String, String>> to Map<String, String>

    [!NOTE|label:references:]

    [
  [ name:'John'  , age:35   ] ,
  [ name:'Jim'   , age:54   ] ,
  [ name:'Smith' , age:'53' ]
].collectEntries {[ it.name, it.age ]}
    • result
      [ 'John':35, 'Jim':54, 'Smith':'53' ]

  • merge two List<String> to single Map<String, List<String>>

    List<String> value =['a','b','c' ]
List<String> recId =['R1','R2'   ]

Map<String, List<String>> map = recId.collectEntries{[ it, value ]}
// or
Map<String, List<String>> map = recId.collectEntries{[ it, value.clone() ]}
    • result
      [
  'R1':['a', 'b', 'c'] ,
  'R2':['a', 'b', 'c']
]

collect

  • similar feature for to_entries[] in jq

    [!NOTE|label:to_entries[] in jq]

    $ echo '{ "a" : "1" }' | jq -r 'to_entries[]'
{
  "key": "a",
  "value": "1"
}

    [ 'a' : '1', 'b' : '2', 'c' : '3' ].collect {[
    'key' : it.key ,
  'value' : it.value
]}
    • result
      [
  [ 'key':'a', 'value':'1' ] ,
  [ 'key':'b', 'value':'2' ] ,
  [ 'key':'c', 'value':'3' ]
]

grep

references:

['test', 12, 20, true].grep(String)

  • alternatives

    ['test', 12, 20, true].findAll { it.class.simpleName == 'String' }

// or
['test', 12, 20, true].findAll { it instanceof String }

with

[!NOTE|label:references:]

Map map = [a: 1, b:2]

map.with {
  (a, b) = [3, 4]
}

assert map.a == 3
assert map.b == 4

sort

  • descending

    assert ['h3':'bb', 'h2':'cc', 'h1':'aa'] == [ 'h1' : 'aa', 'h3' : 'bb', 'h2' : 'cc' ].sort{ - it.key.split('h').last().toInteger() }

# or
assert ['h3':'bb', 'h2':'cc', 'h1':'aa'] == [ 'h1' : 'aa', 'h3' : 'bb', 'h2' : 'cc' ].sort{ it.key }.reversed()

traverse

references:

  • iterateMap && recursion

    def iterateMap(Map map, String prefix = "") {
    map.each { key, value ->
        if (value instanceof Map) {
            iterateMap(value, "$prefix$key:")
        } else {
            println "a:$prefix$key=$value"
        }
    }
}

def a = [
    b: [
        c: 1,
        d: 2,
        e: 3
    ],
    r: [
        p: 4
    ],
    q: 5
]

iterateMap(a)
    • results:
      a:b:c=1
a:b:d=2
a:b:e=3
a:r:p=4
a:q=5
Copyright © marslo 2020-2023 all right reserved，powered by GitbookLast Modified: 2024-03-12 15:01:28

results matching ""

    No results matching ""