Groovy Einführung

Groovy ist eine Programmiersprache für die Java-Plattform. Es handelt sich um eine dynamische Sprache mit ähnlichen Funktionen wie Python oder Ruby. Groovy-Quellcode kann zu Java-Bytecode kompiliert und nahtlos in Java-Code integriert werden. Sie wird häufig für Skripting und Build-Automatisierung sowie für die Erstellung domänenspezifischer Sprachen verwendet.

Groovy meets SAP

In der SAP BTP werden Sie Groovy auch begegnen. In der SAP Integration Suite, die auf der SAP BTP bereitgestellt wird, spielt Groovy eine wichtige Rolle. Sie können in einer Schnittstelle Funktionalität in Form von Groovy-Scripts abbilden. Vor allem das verarbeiten von XML und JSON ist in Groovy sehr einfach. Da SAP Entwickler typischerweise keine oder nur wenig Erfahrung mit Groovy haben, möchten wir diesen Artikel dazu nutzen, um Ihnen eine Einführung in die Groovy Programmiersprache zu geben.

Inhalt

  • Variablen
  • Schleifen
    • for-Schleife
    • while-Schleife
    • do-while-Schleife
    • each-Schleife
    • collect-Schleife
    • find-Schleife
    • Details
      • collect-Schleife
      • find-Schleife
  • Arbeiten mit Listen
    • Instanzieren von Listen
    • Hinzufügen von Elementen zu einer Liste
    • Elemente aus einer Liste auslesen
    • Ausgeben von Listen
    • Listen sortieren
  • Arbeiten mit Maps
    • Instanzieren von Maps
    • Hinzufügen von Elementen
    • Elemente aus einer Map auslesen
    • Iterieren über eine Map

Variablen

Wie in jeder Programmiersprache, gibt es auch in Groovy Variablen.

Eine Variable ist ein Container, der einen Wert enthält. Mit Variablen können Sie Daten in Ihrem Programm speichern und manipulieren. Jede Variable hat einen Namen, der verwendet wird, um auf den in der Variable gespeicherten Wert zu verweisen. Der in einer Variablen gespeicherte Wert kann von unterschiedlichem Typ sein, z. B. eine Zahl, eine Zeichenkette, ein boolescher Wert oder ein Objekt.

Eine Variable kann als ein Container betrachtet werden, der einen Wert enthält, und der Variablenname ist ein Verweis auf den Wert, der Variablenname wird auch Bezeichner genannt. Der Wert in der Variable kann während der Ausführung des Programms geändert werden, weshalb sie auch als Variable bezeichnet wird.

In Groovy werden Variablen mit dem Schlüsselwort def deklariert, gefolgt vom Namen der Variablen und einem optionalen Zuweisungsoperator = und einem Wert. Zum Beispiel:

def x = 34
def name = "Martin Koch"
def found = true

Sie können auch = oder := verwenden, um der Variablen einen Wert zuzuweisen, nachdem sie deklariert worden ist.

def i
i = 5 
def name
name := "Koch Martin"

In Groovy ist der Typ einer Variablen nicht explizit definiert. Der Typ der Variable wird durch den ihr zugewiesenen Wert bestimmt. Es ist auch möglich, den Typ einer Variablen durch Verwendung des def-Schlüsselworts mit einem Typ anzugeben.

def i : int = 5
Es ist auch möglich, das Schlüsselwort final zu verwenden, um eine Variable schreibgeschützt zu machen, so dass sie nicht neu zugewiesen werden kann.
final def i = 5

Schleifen

In Groovy gibt es mehrere Arten von Schleifen, die Sie verwenden können, um einen Codeblock wiederholt auszuführen:

  • for-Schleife
  • while-Schleife
  • do-while-Schleife
  • each-Schleife
  • collect-Schleife
  • find-Schleife

for-Schleife

Ermöglicht die Iteration über einen Zahlenbereich oder über Elemente in einer Sammlung. Zum Beispiel:

for (i in 1..10) {
 println i
}

while-Schleife

Ermöglicht es Ihnen, einen Codeblock wiederholt auszuführen, während eine bestimmte Bedingung erfüllt ist. Zum Beispiel:

while (x > 0) {
 println x
 x--
}

do-while-Schleife

Ähnlich wie eine while-Schleife, aber der Codeblock wird mindestens einmal ausgeführt, bevor die Bedingung überprüft wird.

def x = 10
do {
 println x
 x--
} while (x > 0)

each-Schleife

Ermöglicht die Iteration über Elemente eines Arrays, einer Liste, einer Karte und anderer Typen.

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

collect-Schleife

Ermöglicht die Iteration über Elemente eines Arrays, einer Liste, einer Map und anderer Typen und die Durchführung einer Transformation an jedem Element.

(1..10).collect{ it*it }

find-Schleife

Ermöglicht die Iteration über Elemente eines Arrays, einer Liste, einer Map und anderer Typen und die Suche nach dem Element, bei dem eine gegebene Closure als wahr ausgewertet wird

(1..20).find{ it%2 == 0 }

Details

Collect Schleife im Detail

In Groovy ermöglicht die collect-Methode die Iteration über Elemente eines Arrays, einer Liste, einer Map oder anderer Typen und die Durchführung einer Transformation an jedem Element. Die Methode gibt eine neue Sammlung zurück, die die transformierten Elemente enthält.

Die grundlegende Syntax der collect-Methode lautet wie folgt:

collection.collect { element -> // Code zur Umwandlung des Elements }

In diesem Fall ist collection die Ausgangs-Collection, über die Sie iterieren möchten, und der Code-Block zwischen den geschweiften Klammern wird verwendet, um jedes Element zu transformieren. Das umgewandelte Element wird von dem Codeblock zurückgegeben und der neuen Collection hinzugefügt.

Mit der collect-Methode können Sie zum Beispiel alle Elemente einer Liste von Zahlen quadrieren:

def numbers = [1, 2, 3, 4, 5, 6] 
def squares = numbers.collect { it * it } 
println squares // [1, 4, 9, 16, 25, 36]

Sie können die Methode collect auch mit einer Map verwenden:

def map = [a: 1, b: 2, c: 3, d: 4] 
def result = map.collect { k, v -> [k.toUpperCase(), v * v] }
println result // [[A, 1], [B, 4], [C, 9], [D, 16]]

it-Schlüsselwort kann als Kurzform für das zu verarbeitende Element verwendet werden. Dadurch wird die Closure besser lesbar und weniger langatmig.

Es ist auch möglich, die collect-Methode in Verbindung mit anderen Methoden zu verwenden, um sie zu verketten. Dadurch wird der Code lesbarer und weniger langatmig.

def numbers = [1, 2, 3, 4, 5, 6] 
def evenSquares = numbers.findAll { it % 2 == 0 }.collect { it * it }
println evenSquares // [4, 16, 36]

Wie Sie sehen, kann collect ein leistungsfähiges Werkzeug für die Transformation von Datensammlungen in Groovy sein, das die Durchführung komplexer Transformationen mit ein paar einfachen Codezeilen erleichtert.

Find Schleife im Detail

In Groovy können Sie mit der Find-Methode über Elemente eines Arrays, einer Liste, einer Map oder anderer Typen iterieren und das erste Element finden, bei dem eine gegebene Closure (ein Codeblock) als wahr ausgewertet wird.

Die grundlegende Syntax der find-Methode lautet wie folgt:

collection.find {  element -> // code to check if element is desired }

Hier ist collection die Ausgang-Collection, über die Sie iterieren möchten, und der Codeblock zwischen den geschweiften Klammern wird verwendet, um zu prüfen, ob das aktuelle Element die gewünschte Bedingung erfüllt. Das Element, für das die Closure den Wert true ergibt, wird zurückgegeben, und die Iteration wird beendet. Wenn kein passendes Element gefunden wird, wird null zurückgegeben.

Sie können zum Beispiel die Find-Methode verwenden, um die erste gerade Zahl in einer Liste von Zahlen zu finden:

def numbers = [1, 2, 3, 4, 5, 6] 
def firstEven = numbers.find { it % 2 == 0 }
println firstEven // 2

In ähnlicher Weise kann sie verwendet werden, um den Schlüssel eines bestimmten Wertes in einer Map zu finden:

def map = [a: 1, b: 2, c: 3] 
def result = map.find{ it.value == 2 }?.key 
println result // b

it-Schlüsselwort kann als Kurzform für das zu verarbeitende Element verwendet werden. Dadurch wird die Closure besser lesbar und weniger langatmig.

Es ist auch möglich, die find-Methode in Verbindung mit anderen Methoden zu verwenden, um sie zu verketten. Dadurch wird der Code lesbarer und weniger langatmig.

def numbers = [1, 2, 3, 4] 
def firstSquare = numbers.find { it % 2 == 0 }.collect { it * it }
println firstSquare // 4

In diesem Beispiel wird die Find-Methode verwendet, um die erste gerade Zahl in der Zahlenliste zu finden, dann wird die Collect-Methode verwendet, um sie zu quadrieren.

Arbeiten mit Listen

Der Umgang mit Listen und Arrays bleibt dir früher oder später in keiner Programmiersprache erspart. Eine List ist eine geordnete Sammlung von Elementen, wobei jedem Element ein Index zugewiesen wird, der auf seiner Position in der Liste basiert. Listen sind nützlich, wenn Sie die Elemente in einer bestimmten Reihenfolge halten müssen, z. B. eine Liste von Namen in alphabetischer Reihenfolge. Du kannst auf ein Element in einer Liste über seinen Index zugreifen, und du kannst Elemente an bestimmten Positionen in der Liste hinzufügen, entfernen und ändern.

 Instanziieren von Listen

In Groovy kannst du eine leere Liste mit der []-Notation oder der Klasse List erstellen.

1. Verwendung der []-Notation:

def emptyList = []

Dadurch wird eine leere Liste erstellt und der Variablen emptyList zugewiesen.

2. Verwendung der Klasse List:

def emptyList = new ArrayList()

Dadurch wird eine neue Instanz der Klasse ArrayList erstellt, die eine Implementierung des Interface List ist, und der Variablen emptyList zugewiesen.

3. Eine weitere Variante unter Verwendung der Klasse List mit Typecast:

def emptyList = [] as List

Dadurch wird eine leere Liste erstellt und an das Interface List übergeben.

4. Sie können auch eine Liste mit fester Größe erstellen, indem Sie die Klasse List verwenden und die Größe der Liste als Parameter an den Konstruktor übergeben, etwa so:

def emptyList = new ArrayList(10)

Dadurch wird eine neue ArrayList mit fester Größe und einer Kapazität von 10 erstellt und der Variablen emptyList zugewiesen.

Die Schnittstelle List und die Klasse ArrayList sind Teil der Standardbibliothek von Groovy, so dass Sie keine externen Bibliotheken importieren müssen, um sie zu verwenden.

Hinzufügen von Elementen zu einer Liste

Um in Groovy ein Element zu einer Liste hinzuzufügen, können Sie die Methode add(Object element) des Interface List verwenden.

Hier ein Beispiel dafür, wie man ein Element zu einer Liste hinzufügt:

def numbers = [1, 2, 3] 
numbers.add(4) 
println numbers // [1, 2, 3, 4]

In diesem Beispiel wird durch den Aufruf der Methode add(4) die Zahl 4 an das Ende der Liste angehängt.

Eine andere Möglichkeit, ein Element zu einer Liste hinzuzufügen, ist die Verwendung des Shift Operators <<

def numbers = [1, 2, 3] 
numbers << 4 
println numbers // [1, 2, 3, 4]

Du kannst auch ein Element an einer bestimmten Position in der Liste hinzufügen, indem du die Methode add(int index, Object element) verwendest, die einen Index und ein Element als Parameter benötigt.

def numbers = [1, 2, 3] 
numbers.add(1, 4) 
println numbers // [1, 4, 2, 3]

Dieser Methodenaufruf fügt die Zahl 4 an den Index 1 hinzu, so dass sie das zweite Element in der Liste ist.

Es ist erwähnenswert, dass die Add-Methode und der Linksverschiebungsoperator << beide Teil der List-Schnittstelle sind, die von der ArrayList-Klasse in der Groovy-Standardbibliothek implementiert wird.

 

Elemente aus ein Liste auslesen

Um Elemente aus einer Liste in Groovy zu lesen, kannst du den Index des Elements verwenden, um darauf zuzugreifen. Der Index eines Elements in einer Liste beginnt bei 0, d.h. das erste Objekt hat den Index 0.

Hier ein Beispiel dafür, wie man ein Element aus einer Liste liest:

def numbers = [1, 2, 3] 
println numbers[0] // ausgabe: 1 
println numbers[1] // asugabe: 2

In diesem Beispiel ist das Element mit Index 0 gleich 1 und das Element mit Index 1 gleich 2.

Du kannst auch die Methode get(int index) der Schnittstelle List verwenden, um auf ein Element über seinen Index zuzugreifen:

def numbers = [1, 2, 3] 
println numbers.get(0) // ausgabe: 1 
println numbers.get(1) // ausgabe: 2

Du kannst auch die each-Methode der Klasse List verwenden, um die Elemente der Liste zu durchlaufen und sie einzeln aufzurufen:

def numbers = [1, 2, 3] 
numbers.each { println it }

Wenn du versuchst, auf ein Element zuzugreifen, das außerhalb des Bereichs der Liste liegt, wird eine IndexOutOfBoundsException ausgelöst. Es ist also wichtig, die Größe der Liste oder den Index zu überprüfen, bevor du auf ein Element zugreifst.

Ausgeben von Listen

Um eine Liste in Groovy zu drucken, kannst du die println-Methode verwenden und die Liste als Argument übergeben. Die println-Methode ruft die toString()-Methode der Liste auf und druckt deren Inhalt.

Hier ein Beispiel für das Ausgeben einer Liste:

def numbers = [1, 2, 3] 
println numbers // ausgabe: [1, 2, 3]

Eine andere Möglichkeit, die Elemente einer Liste auszudrucken, besteht darin, die Liste zu durchlaufen und jedes Element einzeln auszudrucken, indem eine Schleife oder die Methode each verwendet wird:

def numbers = [1, 2, 3] 
numbers.each { 
 println it 
}

Dadurch wird jedes Element der Liste in eine neue Zeile gedruckt.

Du kannst auch eine Schleife verwenden, um über die Liste zu iterieren, etwa so:

def numbers = [1, 2, 3] 
for (i in numbers) {
 println i 
}

Es ist erwähnenswert, dass diese Methoden nicht nur spezifisch für die Liste sind, sondern auch für alle anderen Auflistungstypen in Groovy sowie für alle anderen Objekte funktionieren, die die toString()-Methode implementiert haben.

Listen sortieren

In Groovy gibt es mehrere Möglichkeiten, eine Liste zu sortieren.

Verwendung der Methode sort():

def numbers = [3, 1, 2] 
numbers.sort() 
println numbers // ausgabe: [1, 2, 3]

Diese Methode sortiert die Elemente der Liste in aufsteigender Reihenfolge entsprechend der natürlichen Reihenfolge der Elemente.

Verwendung der Methode sort(Closure c):

def numbers = [3, 1, 2]
numbers.sort { a, b -> a <=> b }
println numbers // ausgabe: [1, 2, 3]

Diese Methode sortiert die Elemente der Liste unter Verwendung der angegebenen Schließung als Vergleicher. Die Schließung sollte zwei Argumente annehmen und je nach Reihenfolge der Argumente einen negativen, null oder positiven Wert zurückgeben.

Verwendung der Methode sort(boolean descending = false):

def numbers = [3, 1, 2]
numbers.sort(true) 
println numbers // ausgabe: [3, 2, 1]

Diese Methode sortiert die Elemente der Liste in absteigender Reihenfolge, wenn der Parameter true ist, ansonsten in aufsteigender Reihenfolge.

Verwendung der Methode sort(Comparator c):

def numbers = [3, 1, 2]
numbers.sort(Comparator.reverseOrder())
println numbers // ausgabe: [3, 2, 1]

Diese Methode sortiert die Elemente der Liste nach dem angegebenen Komparator.

Alle diese Methoden verändern die ursprüngliche Liste und geben die sortierte Liste zurück. Es ist erwähnenswert, dass die Sortiermethoden in der Schnittstelle List verfügbar sind, die von der Klasse ArrayList in der Standardbibliothek von Groovy implementiert wird, so dass Sie diese Methoden für jedes Listenobjekt in Groovy verwenden können.

Arbeiten mit Maps

Eine Map ist eine ungeordnete Sammlung von Schlüssel-Wert-Paaren, wobei jeder Schlüssel mit einem Wert verknüpft ist. Maps sind nützlich, wenn du auf Elemente anhand eines bestimmten Schlüssels zugreifen musst. Wenn du zum Beispiel eine Sammlung von Benutzernamen und ihrem entsprechenden Alter speichern musst, kannst du eine Map verwenden, bei der der Benutzername der Schlüssel und das Alter der Wert ist. Um auf den Wert zuzugreifen, verwenden Sie den Schlüssel; die Schlüssel in einer Map müssen eindeutig sein.

Instanzieren von Maps

Es gibt mehrere Möglichkeiten, eine Map in Groovy zu instanziieren:

1. Durch die Verwendung der Map-Literal-Notation:

def map = [key1:value1, key2:value2, key3:value3]

Dadurch wird eine neue Map mit den angegebenen Schlüssel-Wert-Paaren erstellt und der Variablen map zugewiesen.

2. Verwendung des Map-Konstruktors:

def map = new HashMap()

Dadurch wird eine neue Instanz der HashMap-Klasse erstellt und der Variablen map zugewiesen.

3. Verwendung des Map-Konstruktors mit Initialwerten:

def map = new HashMap([key1:value1, key2:value2, key3:value3])

Dadurch wird eine neue Instanz der HashMap-Klasse mit den angegebenen Schlüssel-Wert-Paaren erstellt und der Variablen map zugewiesen.

4. Verwendung des Map-Konstruktors mit Initialwerten und Kapazität:

def map = new HashMap([key1:value1, key2:value2, key3:value3], 16)

Dadurch wird eine neue Instanz der HashMap-Klasse mit den angegebenen Schlüssel-Wert-Paaren und einer anfänglichen Kapazität von 16 erstellt und der Variablen map zugewiesen.

Es ist erwähnenswert, dass die HashMap-Klasse die Standardimplementierung der Map-Schnittstelle in Groovy ist und Teil der Standardbibliothek ist, so dass Sie keine externen Bibliotheken importieren müssen, um sie zu verwenden. Außerdem können Sie die Map-Literal-Notation verwenden, um eine typsichere Map zu erstellen, zum Beispiel [1:’eins‘, 2:’zwei‘] als Map<Integer, String>

Hinzufügen von Elementen

In Groovy gibt es mehrere Möglichkeiten, Elemente zu einer Map hinzuzufügen:

1. Mit dem Subscript-Operator (eckige Klammern):

def map = [:] map['key1'] = 'value1' map['key2'] = 'value2'

Dadurch werden die Schlüssel-Wert-Paare ‚key1′:’value1‘ und ‚key2′:’value2‘ zur Map hinzugefügt.

2. Verwendung der put-Methode:

def map = [:] map.put('key1', 'value1') map.put('key2', 'value2')

Dadurch werden die Schlüssel-Wert-Paare ‚key1′:’value1‘ und ‚key2′:’value2‘ zur Map hinzugefügt.

3. Verwendung des Shift-Operators <<:

def map = [:] map << ['key1':'value1'] map << ['key2':'value2']

Dadurch werden die Schlüssel-Wert-Paare ‚key1′:’value1‘ und ‚key2′:’value2‘ zur Map hinzugefügt.

4. Verwenden Sie den Plus-Operator +:

def map = [:] map += ['key1':'value1', 'key2':'value2']

Dadurch werden die Schlüssel-Wert-Paare ‚key1′:’value1‘ und ‚key2′:’value2‘ zur Map hinzugefügt.

Es ist zu beachten, dass die Schlüssel-Wert-Paare in einer Map eindeutig sein müssen. Wenn Sie also versuchen, einen Schlüssel hinzuzufügen, der bereits existiert, wird der vorherige Wert, der mit diesem Schlüssel verbunden ist, überschrieben. Auch die put-Methode, der Shift-Operator <<, der Plus-Operator + und der Subscript-Operator (eckige Klammern) sind Teil der Map-Schnittstelle, die von der HashMap-Klasse in der Groovy-Standardbibliothek implementiert wird.

Elemente aus einer Map auslesen

In Groovy gibt es mehrere Möglichkeiten, auf Elemente einer Map zuzugreifen oder sie zu lesen:

1. Mit dem Subscript-Operator (eckige Klammern):

def map = [key1:'value1', key2:'value2'] 
println map['key1'] // ausgabe: 'value1'

Diese Methode gibt den Wert zurück, der mit dem angegebenen Schlüssel in der Map verknüpft ist.

2. Verwendung der Methode get:

def map = [key1:'value1', key2:'value2'] 
println map.get('key1') // ausgabe: 'value1'

Dies gibt den Wert zurück, der mit dem angegebenen Schlüssel in der Map verbunden ist.

3. Verwendung der Methode each:

def map = [key1:'value1', key2:'value2'] 
map.each { key, value -> 
 println "$key -> $value" 
}

Dabei werden die Schlüssel-Wert-Paare der Map durchlaufen und ausgedruckt.

4. Verwenden Sie den in-Operator:

def map = [key1:'value1', key2:'value2'] 
if ('key1' in map) {
 println map['key1'] 
}

Dies gibt true zurück, wenn der Schlüssel in der Map vorhanden ist, andernfalls false.

Es ist erwähnenswert, dass alle diese Methoden Teil der Map-Schnittstelle sind, die von der HashMap-Klasse in der Groovy-Standardbibliothek implementiert wird. Darüber hinaus sind die get-Methode und der tiefgestellte Operator [] die gebräuchlichste Methode.

Iterieren über eine Map

Es gibt mehrere Möglichkeiten, über die Elemente einer Map zu iterieren

1. each-Schleife: Mit der each-Methode können Sie die Schlüssel-Wert-Paare einer Map durchlaufen. Die each-Methode nimmt eine Closure als Argument, die für jedes Schlüssel-Wert-Paar ausgeführt wird. Der Schlüssel und der Wert des aktuellen Paares werden als erstes bzw. zweites Argument an die Closure übergeben. Hier ist ein Beispiel:

def map = [a: 1, b: 2, c: 3] 
map.each { key, value -> 
 println "$key -> $value"
}

2. eachWithIndex : Wenn Sie auch den Index der einzelnen Elemente verfolgen möchten, können Sie die Methode eachWithIndex verwenden.

def map = [a: 1, b: 2, c: 3] 
map.eachWithIndex { key, value, index -> 
 println "$index: $key -> $value"
}

3. collect : Sie können auch die Methode collect verwenden, um die Map zu durchlaufen und eine neue Collection auf der Grundlage der Elemente der ursprünglichen Map zu erstellen. Zum Beispiel können Sie eine Liste der Schlüssel oder Werte erstellen:

def map = [a: 1, b: 2, c: 3] 
def keys = map.collect { it.key }
def values = map.collect { it.value }

4. eachEntry : Diese Methode durchläuft die Einträge der Map, die Map.Entry-Objekte sind und ein Schlüssel-Wert-Paar enthalten. Sie können die Eigenschaften key und value verwenden, um auf den Schlüssel und den Wert des aktuellen Eintrags zuzugreifen

def map = [a: 1, b: 2, c: 3] 
map.eachEntry { entry -> 
 println "${entry.key} -> ${entry.value}" 
}

5. Iteration im Groovy-Stil: Mit Groovy können Sie auch eine einfache for-Schleife verwenden, um die Einträge einer Map auf folgende Weise zu iterieren:

def map = [a: 1, b: 2, c: 3] 
for (entry in map) {
 println "$entry.key -> $entry.value"
}

Mit all diesen Methoden können Sie in Groovy über die Elemente einer Map iterieren und Operationen mit jedem Element durchführen. Sie können die Methode verwenden, die Ihren Bedürfnissen und dem spezifischen Problem, das Sie zu lösen versuchen, am besten entspricht.