Häufig verwendete Syntax von Groovy

Groovy ist eine flexible Programmiersprache, die auf der Java-Plattform basiert und viele leistungsstarke Eigenschaften von Python, Ruby und Smalltalk vereint. Im Folgenden finden Sie einige häufig verwendete Syntaxelemente von Groovy, die Ihnen den Einstieg erleichtern.

Variablendeklaration

In Groovy können Variablen mit dem Schlüsselwort def deklariert werden, oder es kann explizit ein Typ angegeben werden.

// Verwendung des Schlüsselworts def
def name = "Groovy"

// Explizite Angabe eines Typs
String greeting = "Hello, ${name}!"

Datentypen

Groovy unterstützt verschiedene Datentypen, darunter Ganzzahlen, Fließkommazahlen, Booleans und Zeichenketten.

def a = 10          // Ganzzahl
def b = 10.5        // Fließkommazahl
def c = true        // Boolean
def d = "Groovy"    // Zeichenkette

Logische Operationen

Groovy unterstützt logische Operatoren wie && (logisches UND), || (logisches ODER) und ! (logisches NICHT).

def a = 10
def b = 20

if (a > 0 && b > 0) {
    println "Beide Zahlen sind positiv"
} else if (a > 0 || b > 0) {
    println "Mindestens eine Zahl ist positiv"
} else {
    println "Beide Zahlen sind nicht positiv"
}

Bedingungsanweisungen

Groovy unterstützt if-else- sowie switch-Bedingungsanweisungen.

def number = 10
if (number > 0) {
    println "Die Zahl ist positiv"
} else {
    println "Die Zahl ist nicht positiv"
}

switch (number) {
    case 0:
        println "Die Zahl ist null"
        break
    case { it > 0 }:
        println "Die Zahl ist positiv"
        break
    default:
        println "Die Zahl ist negativ"
}

Schleifen

Groovy unterstützt for-, while- und do-while-Schleifen.

// for-Schleife
for (i in 0..9) {
    println i
}

// while-Schleife
def i = 0
while (i < 10) {
    println i++
}

// do-while-Schleife
def j = 0
do {
    println j++
} while (j < 10)

Zeichenketten

Zeichenkettenverkettung

In Groovy können Zeichenketten mit dem Operator + oder mittels der ${}-Syntax verkettet werden.

def name = "Groovy"
def greeting = "Hello, " + name + "!"
println greeting  // Ausgabe: Hello, Groovy!

def greeting2 = "Hello, ${name}!"
println greeting2  // Ausgabe: Hello, Groovy!

Zeichenkettenkürzung

Mit der Methode substring lässt sich ein Teil einer Zeichenkette extrahieren.

def str = "Hello, Groovy!"
println str.substring(7)  // Ausgabe: Groovy!
println str.substring(0, 5)  // Ausgabe: Hello

Zeichenkettenersetzung

Die Methode replace ermöglicht das Ersetzen bestimmter Teile einer Zeichenkette.

def str = "Hello, Groovy!"
println str.replace("Groovy", "Java")  // Ausgabe: Hello, Java!

Zeichenkettenzerlegung

Mit der Methode split kann eine Zeichenkette in ein Array zerlegt werden.

def str = "Hello, Groovy!"
def parts = str.split(", ")
println parts[0]  // Ausgabe: Hello
println parts[1]  // Ausgabe: Groovy!

Zeichenkettenzerlegung und -auswertung

Die Methode tokenize teilt eine Zeichenkette in eine Liste auf, wobei über den Index auf bestimmte Teile zugegriffen werden kann.

def str = "Hello, Groovy!"
println str.tokenize(",")[1]  // Ausgabe: Groovy!

Zeichenkettentrimmen

Mit der Methode trim lassen sich Leerzeichen am Anfang und Ende einer Zeichenkette entfernen.

def str = "  Hello, Groovy!  "
println str.trim()  // Ausgabe: Hello, Groovy!

Zeichenkettenlänge

Die Länge einer Zeichenkette lässt sich über die Eigenschaft length ermitteln.

def str = "Hello, Groovy!"
println str.length()  // Ausgabe: 14

Zeichenketteninhalt prüfen

Mit der Methode contains lässt sich feststellen, ob eine Zeichenkette einen bestimmten Unterstring enthält.

def str = "Hello, Groovy!"
println str.contains("Groovy")  // Ausgabe: true

Zeichenkettensuche

Die Methode indexOf gibt die Position eines Unterstrings innerhalb einer Zeichenkette zurück.

def str = "Hello, Groovy!"
println str.indexOf("Groovy")  // Ausgabe: 7

Zeichenkettenvergleich

Mit Operatoren wie ==, !=, <, >, <= und >= können Zeichenketten verglichen werden.

def str1 = "Hello, Groovy!"
def str2 = "Hello, Java!"
println str1 == str2  // Ausgabe: false
println str1 != str2  // Ausgabe: true
println str1 < str2  // Ausgabe: true
println str1 > str2  // Ausgabe: false
println str1 <= str2  // Ausgabe: true
println str1 >= str2  // Ausgabe: false

Zeichenkettenescape

Spezielle Zeichen wie \n für Zeilenumbruch können mit einem Backslash (\) maskiert werden.

def str = "Hello,\nGroovy!"
println str  // Ausgabe: Hello,
             // Groovy!

Zeichenketten-Templates

Groovy unterstützt die Verwendung der ${}-Syntax, um Variablen in Zeichenketten einzubetten.

def name = "Groovy"
def greeting = "Hello, ${name}!"
println greeting  // Ausgabe: Hello, Groovy!

Zeichenketten-Regelmäßiger Ausdruck

Mit dem Operator ==~ können reguläre Ausdrücke verwendet werden.

def emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
def str = "google@163.com"
println str ==~ emailPattern  // Ausgabe: true

Mehrzeilige Zeichenketten

Mehrzeilige Zeichenketten können mit drei Anführungszeichen """ oder ''' definiert werden.

def multiLineStr = """
    Dies ist eine mehrzeilige
    Zeichenkette in Groovy.
"""
println multiLineStr

Listen (List)

Listen sind in Groovy eine häufig genutzte Datenstruktur, die Elemente unterschiedlicher Typen enthalten kann. Nachfolgend finden Sie einige gängige Syntaxelemente zur Arbeit mit Listen in Groovy.

Liste definieren

Eine Liste lässt sich mit eckigen Klammern [] definieren.

def list = [1, 2, 3, 'Groovy', true]

Auf Elemente zugreifen

Elemente einer Liste können über ihren Index abgerufen werden; der Index beginnt bei 0.

def list = [1, 2, 3, 'Groovy', true]
println list[3]  // Ausgabe: Groovy

Liste ändern

Einzelne Elemente einer Liste lassen sich über den Index bearbeiten.

def list = [1, 2, 3, 'Groovy', true]
list[3] = 'Java'
println list  // Ausgabe: [1, 2, 3, 'Java', true]

Elemente hinzufügen

Mit der Methode add oder dem Linksverschiebeoperator << können neue Elemente zu einer Liste hinzugefügt werden.

def list = [1, 2, 3]
list.add(4)
println list  // Ausgabe: [1, 2, 3, 4]

list << 5
println list  // Ausgabe: [1, 2, 3, 4, 5]

Elemente entfernen

Mit der Methode remove können Elemente aus einer Liste gelöscht werden.

def list = [1, 2, 3, 4, 5]
list.remove(0)
println list  // Ausgabe: [2, 3, 4, 5]

Liste-Länge ermitteln

Die Länge einer Liste lässt sich mit der Methode size bestimmen.

def list = [1, 2, 3, 4, 5]
println list.size()   // Ausgabe: 5

Liste durchlaufen

Mit einer for-Schleife können alle Elemente einer Liste nacheinander verarbeitet werden.

def list = [1, 2, 3, 4, 5]
for (item in list) {
    println item
}

Alternativ kann auch die Methode each verwendet werden.

def list = [1, 2, 3, 4, 5]
list.each { println it }

Liste transformieren

Mit der Methode collect können alle Elemente einer Liste entsprechend einer Funktion transformiert werden.

def list = [1, 2, 3, 4, 5]
def newList = list.collect { it * 2 }
println newList  // Ausgabe: [2, 4, 6, 8, 10]

Liste filtern

find

Gibt das erste Element zurück, das eine bestimmte Bedingung erfüllt.

def list = [1, 2, 3, 4, 5]
println list.find { it % 2 == 0 }  // Ausgabe: 2

findAll

Gibt eine neue Liste aller Elemente zurück, die eine bestimmte Bedingung erfüllen.

def list = [1, 2, 3, 4, 5]
def newList = list.findAll { it % 2 == 0 }
println newList  // Ausgabe: [2, 4]

Liste abgleichen

any

Prüft, ob mindestens ein Element eine bestimmte Bedingung erfüllt.

def list = [1, 2, 3, 4, 5]
println list.any { it % 2 == 0 }  // Ausgabe: true

every

Prüft, ob alle Elemente eine bestimmte Bedingung erfüllen.

def list = [1, 2, 3, 4, 5]
println list.every { it % 2 == 0 }  // Ausgabe: false

Liste schneiden

Mit der Methode subList kann ein Teil einer Liste extrahiert werden.

def list = [1, 2, 3, 4, 5]
println list.subList(1, 4)  // Ausgabe: [2, 3, 4]

Liste sortieren

Mit der Methode sort kann eine Liste nach einem bestimmten Kriterium sortiert werden.

def list = [3, 1, 4, 2, 5]
println list.sort()  // Ausgabe: [1, 2, 3, 4, 5]

Liste umkehren

Mit der Methode reverse kann eine Liste umgekehrt werden.

def list = [1, 2, 3, 4, 5]
println list.reverse()  // Ausgabe: [5, 4, 3, 2, 1]

Liste prüfen

Mit der Methode contains lässt sich feststellen, ob eine Liste ein bestimmtes Element enthält.

def list = [1, 2, 3, 4, 5]
println list.contains(3)  // Ausgabe: true
println list.contains(6)  // Ausgabe: false

Liste verbinden

Mit der Methode plus oder dem Operator + können zwei Listen miteinander verbunden werden.

def list1 = [1, 2, 3]
def list2 = [4, 5, 6]
println list1.plus(list2)  // Ausgabe: [1, 2, 3, 4, 5, 6]
println list1 + list2      // Ausgabe: [1, 2, 3, 4, 5, 6]

Liste leeren

Mit der Methode clear kann eine Liste geleert werden.

def list = [1, 2, 3, 4, 5]
list.clear()
println list  // Ausgabe: []

Maps

Maps sind in Groovy eine häufig genutzte Datenstruktur, die Schlüssel-Wert-Paare speichert. Nachfolgend finden Sie einige gängige Syntaxelemente zur Arbeit mit Maps in Groovy.

Map definieren

Eine Map lässt sich mit eckigen Klammern [:] oder geschweiften Klammern {} definieren.

def map = [:]
map = ["name": "Groovy", "version": 2.5]

Auf Map-Elemente zugreifen

Werte in einer Map können über ihren Schlüssel abgerufen werden.

def map = ["name": "Groovy", "version": 2.5]
println map["name"]  // Ausgabe: Groovy

Map-Elemente ändern

Werte in einer Map können über ihren Schlüssel geändert werden.

def map = ["name": "Groovy", "version": 2.5]
map["name"] = "Java"
println map  // Ausgabe: [name:Java, version:2.5]

Elemente hinzufügen

Mit der Methode put oder durch direkte Zuweisung können neue Elemente zu einer Map hinzugefügt werden.

def map = ["name": "Groovy"]
map.put("version", 2.5)
println map  // Ausgabe: [name:Groovy, version:2.5]

map["author"] = "James"
println map  // Ausgabe: [name:Groovy, version:2.5, author:James]

Elemente entfernen

Mit der Methode remove können Elemente aus einer Map gelöscht werden.

def map = ["name": "Groovy", "version": 2.5]
map.remove("version")


println map  // Ausgabe [name:Groovy]

Größe der Map

Mit der Methode size kann die Größe einer Map ermittelt werden.

def map = ["name": "Groovy", "version": 2.5]
println map.size()  // Ausgabe 2

Durchlaufen der Map

Die Schlüssel-Wert-Paare einer Map können mit der Methode each durchlaufen werden.

def map = ["name": "Groovy", "version": 2.5]
map.each { key, value ->
    println "${key}: ${value}"
}

Prüfen von Schlüsseln oder Werten

Mit den Methoden containsKey und containsValue lässt sich prüfen, ob eine Map einen bestimmten Schlüssel oder Wert enthält.

def map = ["name": "Groovy", "version": 2.5]
println map.containsKey("name")  // Ausgabe true
println map.containsValue(2.5)  // Ausgabe true

Leeren einer Map

Die Methode clear dient zum leeren einer Map.

def map = ["name": "Groovy", "version": 2.5]
map.clear()
println map  // Ausgabe [:]

Zusammenführen von Maps

Mit der Methode putAll können alle Elemente einer Map in eine andere Map übernommen werden.

def map1 = ["name": "Groovy"]
def map2 = ["version": 2.5]
map1.putAll(map2)
println map1  // Ausgabe [name:Groovy, version:2.5]

Abrufen aller Schlüssel oder Werte

Mit den Methoden keySet und values lassen sich alle Schlüssel bzw. Werte einer Map abrufen.

def map = ["name": "Groovy", "version": 2.5]
println map.keySet()  // Ausgabe [name, version]
println map.values()  // Ausgabe [Groovy, 2.5]

Funktionen

In Groovy werden Funktionen als Methoden bezeichnet und können innerhalb von Klassen oder als Teil eines Skripts definiert werden. Nachfolgend einige gängige Syntaxregeln zur Definition und zum Aufruf von Funktionen in Groovy.

Definieren einer Funktion

Eine Funktion lässt sich mit dem Schlüsselwort def definieren.

def greet(name) {
    return "Hello, ${name}!"
}

Aufrufen einer Funktion

Nach der Definition einer Funktion kann sie über ihren Namen und die entsprechenden Parameter aufgerufen werden.

def result = greet("Groovy")
println result  // Ausgabe Hello, Groovy!

Funktionen mit Standardparametern

Bei der Definition einer Funktion können für Parameter Standardwerte festgelegt werden.

def greet(name = "World") {
    return "Hello, ${name}!"
}

println greet()        // Ausgabe Hello, World!
println greet("Groovy") // Ausgabe Hello, Groovy!

Funktionen mit mehreren Parametern

Es ist möglich, Funktionen zu definieren, die mehrere Parameter entgegennehmen.

def add(a, b) {
    return a + b
}

println add(3, 5)  // Ausgabe 8

Anonyme Funktionen

Anonyme Funktionen können definiert und einer Variablen zugewiesen oder als Parameter übergeben werden.

def multiply = { a, b -> a * b }
println multiply(3, 5)  // Ausgabe 15

Funktionen mit variabler Anzahl an Parametern

Funktionen können so definiert werden, dass sie eine variable Anzahl von Parametern akzeptieren.

def sum(... numbers) {
    def total = 0
    for (number in numbers) {
        total += number
    }
    return total
}

println sum(1, 2, 3, 4)  // Ausgabe 10

Funktionen mit Closures

Funktionen können auch Closures als Parameter entgegennehmen.

def operate(a, b, closure) {
    return closure(a, b)
}

def add = { x, y -> x + y }
println operate(3, 5, add)  // Ausgabe 8

Funktionen, die mehrere Werte zurückgeben

Funktionen können mehrere Werte zurückgeben; diese werden dann als Liste ausgegeben.

def getCoordinates() {
    return [10, 20]
}

def (x, y) = getCoordinates()
println "x: ${x}, y: ${y}"  // Ausgabe x: 10, y: 20

Rekursive Funktionen

Rekursive Funktionen rufen sich selbst innerhalb der eigenen Definition auf.

def factorial(n) {
    if (n <= 1) {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

println factorial(5)  // Ausgabe 120