groovy-lecture/skript/datenstrukturen.md

### Enums
Enums sind gleich wie in Java

```Groovy
enum Day{
	MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

Day today = Day.MONDAY
```

Man kann in Enums zusätzlich noch Eigenschaften und Methoden einbauen

```Groovy
enum Day{
	MONDAY("First Day of the Week"),
	TUESDAY("Second Day of the Week),
	//...

	final String description

	Day(String description){
		this.description = description
	}

	String getDescription(){
		return description
	}
}

	Day today = Day.FRIDAY
	def description = today.getDescription
	println("Today is $today: $description")

```

Zusätzlich dazu kann man auch Methoden überschreiben (z.B. toString()-Methode)

### Ranges
Ähnlich wie in Ruby, jedoch nicht gleich
```Groovy
1..10 // Inklusive 10
1..<10 // Exklusive 10
'a'..'x' // Kann auch aus Character bestehen
10..1 // Kann auch absteigende Reihenfolge haben
'x'..'a' // Character können auch absteigende Reihenfolge haben
```

Nützliche Methoden auf Ranges: 
- contains()
- get()
- getFrom() 
- getTo()
- isReverse()
- size()
- subList()

### Arrays
- von allen Typen können Arrays erstellt werden
- Größe muss angegeben werden, sind nicht dynamisch

```Groovy
int[] intArray = new int[4];
intArray[2] = 2
println intArray // [0,0,2,0]
```



### Lists
Listen sind geordnete Sammlungen von Elementen.

```Groovy 
def list = [0,1,2,3]
println list // [0,1,2,3]
println list[0] // [0]

list << 4 // Hinzufügen eins Elements am Ende der Liste
println list // [0,1,2,3,4]

list.add(0,20) // [Index, Wert]
println list // [20,0,1,2,3,4]
```


### Maps
Eine Map ist eine ungeordnete Collection von Objekt-Referenzen.

```Groovy
def map = [name: "Peter", alter: 81]
```

Zugriff auf Map:

```Groovy
println map.name // "Peter"
println map["alter"] // 81
```

Hinzufügen von Schlüssel-Wert

```Groovy
map["Auto"] = "Bugatti"
println map["Auto"] // "Bugatti"
```

Entfernen von Elementen

```Groovy
def map [hello: "World", erde: "Rund", eins: "Zwei"]
println map // [hello: "World", erde: "Rund", eins: "Zwei"]
def newMap = map.minus([hello: "World"])
println newMap // [erde: "Rund", eins: "Zwei"]
```
Die `minus()`Methode nimmt eine Map als Argument und gibt eine neue Map, mit den entfernten Schlüssel-Wert Paaren zurück

-----Man kann auch Closure* benutzen----


Eine leere Map wird wie folgt definiert:
```Groovy
def emptyMap = [:]
```


\* Clojure ist ein Codeblock, der lokal erstellt wird und Zugriff auf umgebende Variablen hat


### Sets
Ungeordnete Sammlung von eindeutigen Elementen.
(Keine Dubletten)

```Groovy
def mySet = [1,1,1,2,3,3,4,5,5,5,5] as Set 
println mySet //[1,2,3,4,5]
```
Hinzufügen eines Elements:
```Groovy
mySet << 6
println mySet // [1,2,3,4,5,6]
// oder
mySet.add(7)
println mySet // [1,2,3,4,5,6,7]
```

Entfernen eines Elements:
```Groovy
mySet.remove(1)
println mySet // [2,3,4,5,6,7]
```