Bedingungen, Datenstrukturen

Bedingungen.md

@@ -0,0 +1,177 @@
+## Groovy-Truth
+Groovy entscheidet nach folgenden Regeln, ob ein Ausdruck true oder false ist:
+
+##### Boolean
+True wenn entsprechender boolean Wert true ist
+``assert true
+``assert !false
+
+##### Collections und Arrays
+Non-Empty Collections und arrays sind true
+``assert [1,2,3]
+``assert ![]
+
+##### Matchers
+True wenn mind. ein "match" 
+``assert = 'a' =~ /a/
+``assert = !('a' =~ /b/)
+
+##### Iterators und Enumerations
+Iteratoren und Enumerationen mit weiteren Elementen sind true
+```Groovy
+assert [0].iterator()
+assert ![].iterator()
+Vector v = [0] as Vector
+Enumeration enumeration = v.elements()
+assert enumeration
+enumeration.nextElement()
+assert !enumeration
+```
+
+##### Maps
+Non-Empty Maps sind true
+``assert ['one' : 1]
+``assert ![:]
+
+##### Strings
+Non-Empty Strings, GStrings, CharSequences sind true
+``assert 'a'
+``assert !''
+``def nonEmpty = a
+``assert "$nonEmpty"
+``def empty = ''
+``assert !"$empty"
+
+##### Numbers
+Non-zero Nummern sind true
+``assert 1
+``assert 3.5
+``assert !0
+
+##### Object References
+Non-null Objekt-Referenzen sind true
+``assert new Object()
+``assert !null
+
+##### Truth verändern mit asBoolean()-Methode
+Man kann das Verhalten von Groovy auf boolean verändern, indem man eine asBoolean()-Methode implementiert
+
+```Groovy
+class Color{
+
+	String name
+
+	boolean asBoolean(){
+		name == 'green' ? true : false
+	}
+}
+
+...
+
+assert new Color(name: 'green')
+assert !new Color(name: 'red')
+```
+
+
+
+
+## Bedingte Operatoren
+### Not Operator
+Der "Nicht"-Operator wird mit einem "!" dargestellt. 
+```Groovy
+def wasbinIch = true
+println !wasBinIch // Ausgabe "false"
+```
+
+### Ternärer Operator
+Der ternäre Operator ist ein Shortcut, der einem if/else Bedingung entspricht und einer Variablen einen Wert zuweist. 
+
+Statt:
+
+```Groovy 
+if(string!=null && string.length()>0){
+	result = 'Found'
+} else {
+	result = 'Not Found'
+}
+```
+
+Kann man:
+
+```Groovy
+
+result = (string!=null && string.length()>0) ? 'Found' : 'Not Found'
+```
+
+schreiben.
+
+Auch ist der ternäre Operator kompatibel mit dem "Groovy Truth", sodass man den Ausdruck noch kürzer Verfassen kann:
+```Groovy
+
+result = string ? 'Found' : 'Not Found'
+```
+
+### Elvis-Operator
+Der "Elvis-Operator" ist eine Kurzform des ternären Operators. Dieser wird verwendet, um einen Standardwert anzugeben, wenn eine Variable "null" oder leer ist. 
+
+```Groovy
+def result = ausdruck1 ?: ausdruck2
+```
+- ausdruck1: Dies ist der Ausdruck der ausgewertet wird, wenn dieser einen "truthy" Wert hat.
+- ausdruck2: Dies ist der Asudruck, wenn ausdruck1 "null" oder "falsly" ist
+
+
+### If-Else Bedingungen
+```Groovy
+def zahl = 8
+
+if(zahl > 10){
+	println "Zahl größer 10"
+}else if(zahl < 10){
+	println "Zahl ist kleiner 10"
+}else{
+	println "Zahl ist gleich 10"
+}
+```
+
+### Switch Case
+```Groovy
+def x = 3 
+switch (x) { 
+	case 1: 
+		println "x is one" 
+		break 
+	case 2: 
+		println "x is two" 
+		break 
+	case 3..5: // Bereich 
+		println "x is between 3 and 5" 
+		break 
+	case Integer: 
+		println "x is an integer" 
+		break 
+	case ~/^\\d+$/: // Regex als Case erlaubt
+		println "x is a number" 
+		break 
+	default: 
+		println "x is something else" 
+}
+```
+
+
+Switch Unterstützt folgende Arten des Vergleichs:
+- Case-Values stimmen überein, wenn Switch-Value ein Instanz der selben Klasse ist
+- "Regulärer Ausdruck Case" stimmt überein, wenn `toString()` Repräsentation vom Switch-Value dem Regex gleicht
+- Collection Case-Values matchen mit dem Switch-Value, wenn Switch-Value in der Collection vorkommt
+- Closure Case-Values matcht, wenn der Call auf dem Clojure ein Return basierend auf Groovy-Truth zurück gibt
+
+Groovy unterstützt auch folgende Schreibweise: 
+```Groovy
+def partner = switch(person){
+	case 'Romeo' -> 'Juliet'
+	case 'Adam' -> 'Eve'
+	case 'Eins' -> 'Zwei'
+}
+```
+
+

Datenstrukturen.md

@@ -0,0 +1,111 @@
+### 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]