Groovy

def add = {a, b -> a + b}

def sub = {a, b -> a - b}

def map = ["a": "0", "b": "1", "c": "2"]


println("add(1, 2): ${add(1, 2)}")
println("sub(1, 2): ${sub(1, 2)}")


map.keySet().forEach {println map[it]}
map.values().forEach {println it}

def map2 = [
    Bob  : 42,
    Alice: 54,
    Max  : 33
]

// `entry` is a map entry
map2.each { entry ->     println "Name: $entry.key Age: $entry.value" }
map2.each { key, value ->     println "Name: $key Age: $value" }

class Punkt {
    
    def setX() { x = 123 }
    def setX(x) { if (x < 200)  this.x = 1234567 else this.x = x }
    def getX() { x }
    
    def setY(y) { _y = y }
    def getY() { _y }
    
    def x = 12
    def _y = 14
}

def punkt = new Punkt()
punkt.x = 111
println("punkt.x: ${punkt.x}") // {} could be omited... 

punkt.x = 222
println("punkt.x: ${punkt.x}") // {} could be omited... 

// punkt.x is rather equal to punkt.getX() than to punkt.setX()
// because there is no assigning operator
punkt.x 
println("punkt.x: ${punkt.x}") // {} could be omited... 

punkt.setX() 
println("punkt.x after punkt.setX() call: ${punkt.x}") // {} could be omited... 

punkt.y = 555
println("punkt.y: ${punkt.y}") // {} could be omited... 

def punktList = []
(0..9).each {
    punktList.add new Punkt()
    punktList[it].x = it 
    //tmp.x = it
    //(punktList[it]).x = it
    println "it: $it, punktList[$it].x: ${punktList[it].x}"
}

punkt.x: 1234567
punkt.x: 222
punkt.x: 222
punkt.x after punkt.setX() call: 123
punkt.y: 555
it: 0, punktList[0].x: 1234567
it: 1, punktList[1].x: 1234567
it: 2, punktList[2].x: 1234567
it: 3, punktList[3].x: 1234567
it: 4, punktList[4].x: 1234567
it: 5, punktList[5].x: 1234567
it: 6, punktList[6].x: 1234567
it: 7, punktList[7].x: 1234567
it: 8, punktList[8].x: 1234567
it: 9, punktList[9].x: 1234567

def an_obj = [
    x: [a:1],
    y: [a:2],
    z: [a:3]
]
def an_arr = [
    [a:1],
    [b:2],
    [c:3]
]

def an_other_obj = [
    x: [a:1],
    y: [b:2],
    z: [c:3],
    c: 3
]


an_arr.each { println " - it.a: $it.a" }
println("<<< " + an_arr.collect { elem -> elem.a })

//das geht bei array von objekten, da kann man direkt auf die keys der objekte zugreifen,
//so ne art automatishe loop wie das vorherige Bsp. ...
println ">>> ${an_arr["a"]}"


an_arr = [[a:"vier eins"], "vier zwei", "vier drei"]

def key = "k41"
//println "${an_obj[key]}"
//println "${an_obj.k41}"

// the zero elem of the array is the object with the key "a" and value "vier eins"
println "${an_arr[0].a}" // or an_arr[0].a
println "${an_arr[3]?.a}" // or an_arr[3].a 3 not there -> returns null also ?
println "${an_arr[1]}"
println "${an_arr.getAt(2)}"


println "${an_arr}"

 - it.a: 1
 - it.a: null
 - it.a: null
<<< [1, null, null]
>>> [1, null, null]
vier eins
null
vier zwei
vier drei
[[a:vier eins], vier zwei, vier drei]