EMZETT.
Login

Emzett Wiki

Groovy: Collections: Listen, Maps und Ranges

Properties1
tagsprogrammiersprachen, groovy

5 Min. Lesezeit

Kurz: def s = [3, 1, 2, 3, 1] as Set println s println s.size() println (s + [9]) println s.intersect([1, 9]) println(([1, 2] as Set) == ([2, 1] as Set)) def sortiert = new TreeSet([5, 2, 8]) println sortiert println sortiert.first()

Teil des Kurses Groovy

Kapitel 3 von 8 im Kurs Groovy. Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Listen

def l = [5, 3, 9, 1, 7]
println l
println "${l.size()} ${l[0]} ${l[-1]} ${l.first()} ${l.last()}"
println l[1..3]
println l.sort(false)
println l.reverse()
println l.collect { it * 2 }
println l.findAll { it > 4 }
println l.find { it > 4 }
println "${l.sum()} ${l.min()} ${l.max()} ${l.count { it > 3 }}"
println l.inject(0) { acc, x -> acc + x }
println "${l.any { it > 8 }} ${l.every { it > 0 }}"
println l.take(2)
println l.drop(3)
println l.join("-")
println (l + [8, 9])
println (l - [3, 9])
println l.indexOf(9)
println l.contains(7)
l << 11
l.add(0, 100)
l.remove(0)
println l
println l.groupBy { it % 2 == 0 ? "gerade" : "ungerade" }
println l.collate(2)
println([[1, 2], [3]].flatten())
println([1, 2, 2, 3, 3, 3].unique())
println ([1, 2, 3].withIndex().collect { v, i -> v * i })
println l.sort().toUnique()
def kopf = l.head()
println kopf
println([3, 1, 2].sort { a, b -> b <=> a })
println(["bb", "a", "ccc"].sort { it.length() })
println ([1, 2, 3, 4].split { it % 2 == 0 })

Ausgabe:

[5, 3, 9, 1, 7]
5 5 7 5 7
[3, 9, 1]
[1, 3, 5, 7, 9]
[7, 1, 9, 3, 5]
[10, 6, 18, 2, 14]
[5, 9, 7]
5
25 1 9 3
25
true true
[5, 3]
[1, 7]
5-3-9-1-7
[5, 3, 9, 1, 7, 8, 9]
[5, 1, 7]
2
true
[5, 3, 9, 1, 7, 11]
[ungerade:[5, 3, 9, 1, 7, 11]]
[[5, 3], [9, 1], [7, 11]]
[1, 2, 3]
[1, 2, 3]
[0, 2, 6]
[1, 3, 5, 7, 9, 11]
1
[3, 2, 1]
[a, bb, ccc]
[[2, 4], [1, 3]]

Maps

def alter = [Mia: 17, Tom: 25, Zoe: 31]
println alter
println alter.Mia
println alter["Tom"]
println alter.get("Ben", 0)
alter.Ben = 12
alter["Max"] = 40
println alter.size()
println alter.keySet().sort()
println alter.values().sort()
println alter.containsKey("Zoe")
alter.each { name, a -> print "$name=$a " }
println()
println alter.findAll { k, v -> v > 20 }.keySet().sort()
println alter.collect { k, v -> "$k:$v" }.sort()
println alter.sort { it.value }.keySet()
println alter.max { it.value }.key
println alter.values().sum()
def zaehler = [:].withDefault { 0 }
"mississippi".each { zaehler[it]++ }
println zaehler.sort { a, b -> b.value <=> a.value ?: a.key <=> b.key }
println "mississippi".toList().countBy { it }.sort { it.key }
alter.remove("Max")
println alter.size()
println alter.subMap(["Mia", "Tom"])
println ([a: 1] + [b: 2])

Ausgabe:

[Mia:17, Tom:25, Zoe:31]
17
25
0
5
[Ben, Max, Mia, Tom, Zoe]
[12, 17, 25, 31, 40]
true
Mia=17 Tom=25 Zoe=31 Ben=12 Max=40
[Max, Tom, Zoe]
[Ben:12, Max:40, Mia:17, Tom:25, Zoe:31]
[Ben, Mia, Tom, Zoe, Max]
Max
125
[i:4, s:4, p:2, m:1]
[i:4, m:1, p:2, s:4]
4
[Mia:17, Tom:25]
[a:1, b:2]

Ranges und Sets

def r = 1..10
println r
println r.contains(5)
println r.size()
println (r.step(3))
println r.collect { it * it }
println(('a'..'e').toList())
println r.sum()
println((1..<5).toList())
println((10..1).toList())
 
def s = [3, 1, 2, 3, 1] as Set
println s
println s.size()
println (s + [9])
println s.intersect([1, 9])
println(([1, 2] as Set) == ([2, 1] as Set))
def sortiert = new TreeSet([5, 2, 8])
println sortiert
println sortiert.first()
 
def spread = [[a: 1], [a: 2]]*.a
println spread
println(["x", "yy"]*.length())

Ausgabe:

1..10
true
10
[1, 4, 7, 10]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[a, b, c, d, e]
55
[1, 2, 3, 4]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[3, 1, 2]
3
[3, 1, 2, 9]
[1]
true
[2, 5, 8]
2
[1, 2]
[1, 2]

Operator-Überladung und Spread

println ([1, 2, 3] * 2)
println ("ab" * 3)
println((1..3).collect { [it, it * it] }.collectEntries { [(it[0]): it[1]] })
def (a, b, c) = [1, 2]
println "$a $b $c"
def (x, y) = [10, 20]
(x, y) = [y, x]
println "$x $y"
def args = [1, 2, 3]
def summe3(p, q, r) { p + q + r }
println summe3(*args)
def m = [a: 1, b: 2]
println "${m.a} ${m.'b'}"
def teile = "a,b,c".split(",")
println teile.getClass().simpleName
println ("a b c".tokenize())
println "x".padLeft(4, '*') + "|" + "y".padRight(3) + "|"

Ausgabe:

[1, 2, 3, 1, 2, 3]
ababab
[1:1, 2:4, 3:9]
1 2 null
20 10
6
1 2
String[]
[a, b, c]
***x|y  |

Merke

  • Listen [...], Maps [key: value], Ranges 1..5 und Sets bieten viele Komfortmethoden
  • collect, findAll, inject, groupBy, countBy, sum, sort { } ersetzen Schleifen
  • *. (Spread) ruft eine Methode für jedes Element auf; *liste verteilt Argumente
  • withDefault macht Zählermaps einfach

Übungsaufgabe

Zähle mit countBy die Wortlängen in einem Satz.

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Kontrollfluss, Methoden und Closures

Weiter: Klassen, Traits und AST-Transformationen

Alle Kapitel: Groovy im Überblick

Graphansicht

Backlinks