# Groovy Common Syntax

Groovy is a flexible programming language based on the Java platform that combines many powerful features from Python, Ruby, and Smalltalk. Below are some common Groovy syntaxes to help you get started quickly.

# Variable Declaration

In Groovy, variable declarations can use the def keyword or explicitly specify a type.

// Using def keyword
def name = "Groovy"

// Explicitly specifying type
String greeting = "Hello, ${name}!"

# Data Types

Groovy supports various data types including integers, floating-point numbers, booleans, and strings.

def a = 10          // Integer
def b = 10.5        // Floating-point
def c = true        // Boolean
def d = "Groovy"    // String

# Logical Operations

Groovy supports logical operators such as && (logical AND), || (logical OR), and ! (logical NOT).

def a = 10
def b = 20

if (a > 0 && b > 0) {
    println "Both numbers are positive"
} else if (a > 0 || b > 0) {
    println "At least one number is positive"
} else {
    println "Both numbers are non-positive"
}

# Conditional Statements

Groovy supports if-else and switch conditional statements.

def number = 10
if (number > 0) {
    println "Number is positive"
} else {
    println "Number is non-positive"
}

switch (number) {
    case 0:
        println "Number is zero"
        break
    case { it > 0 }:
        println "Number is positive"
        break
    default:
        println "Number is negative"
}

# Loop Statements

Groovy supports for, while, and do-while loops.

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

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

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

# Strings

# String Concatenation

In Groovy, you can concatenate strings using the + operator or through ${} syntax.

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

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

# String Substring

You can use the substring method to extract part of a string.

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

# String Replacement

You can use the replace method to replace content in a string.

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

# String Splitting

You can use the split method to split a string into an array.

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

# String Tokenization and Value Extraction

You can use the tokenize method to split a string into a list and access specific parts by index.

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

# String Trimming

You can use the trim method to remove whitespace characters from both ends of a string.

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

# String Length

You can use the length property to get the length of a string.

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

# String Contains

You can use the contains method to check if a string contains a substring.

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

# String Search

You can use the indexOf method to find the position of a substring in a string.

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

# String Comparison

You can use operators like ==, !=, <, >, <=, >= to compare strings.

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

# String Escaping

You can use \ to escape special characters, such as \n for newline.

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

# String Templates

Groovy supports embedding variables in strings using ${} syntax.

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

# String Regular Expression Matching

You can use the ==~ operator for regular expression matching.

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

# Multi-line Strings

You can define multi-line strings using triple quotes """ or '''.

def multiLineStr = """
    This is a multi-line
    string in Groovy.
"""
println multiLineStr

# Lists

In Groovy, lists are a commonly used data structure that can contain elements of different types. Below are some common Groovy list operations.

# Defining Lists

You can define a list using square brackets [].

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

# Accessing List Elements

You can access elements in a list through indices, starting from 0.

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

# Modifying List Elements

You can modify elements in a list through indices.

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

# Adding Elements

You can use the add method or left shift operator << to add elements to a list.

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

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

# Removing Elements

You can use the remove method to remove elements from a list.

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

# List Length

You can use the size method to get the length of a list.

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

# Iterating Through Lists

You can use a for loop to iterate through elements in a list.

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

You can also use the each method to iterate through elements in a list.

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

# List Transformation

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

# List Filtering

find

Returns the first element that satisfies the condition.

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

findAll

Returns a new list with all elements that satisfy the condition.

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

# List Matching

any

Checks if at least one element satisfies the condition

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

every

Checks if all elements satisfy the condition

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

# List Slicing

You can use the subList method to get part of a list.

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

# List Sorting

You can use the sort method to sort a list.

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

# List Reversal

You can use the reverse method to reverse a list.

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

# List Contains

You can use the contains method to check if a list contains an element.

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

# List Concatenation

You can use the plus method or + operator to concatenate two lists.

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

# Clearing Lists

You can use the clear method to clear a list.

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

# Maps

In Groovy, maps are a commonly used data structure for storing key-value pairs. Below are some common Groovy map operations.

# Defining Maps

You can define a map using square brackets [:] or curly braces {}.

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

# Accessing Map Elements

You can access values in a map through keys.

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

# Modifying Map Elements

You can modify values in a map through keys.

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

# Adding Elements

You can use the put method or direct assignment to add elements to a map.

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

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

# Removing Elements

You can use the remove method to remove elements from a map.

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

# Map Size

You can use the size method to get the size of a map.

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

# Iterating Through Maps

You can use the each method to iterate through key-value pairs in a map.

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

# Checking Keys or Values

You can use the containsKey and containsValue methods to check if a map contains a specific key or value.

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

# Clearing Maps

You can use the clear method to clear a map.

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

# Merging Maps

You can use the putAll method to merge all elements from one map into another.

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

# Getting All Keys or Values

You can use the keySet and values methods to get all keys or values in a map.

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

# Functions

In Groovy, functions are called methods and can be defined within classes or as part of scripts. Below are some common Groovy function definition and calling syntaxes.

# Defining Functions

You can use the def keyword to define a function.

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

# Calling Functions

After defining a function, you can call it using the function name and parameters.

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

# Functions with Default Parameters

You can provide default values for parameters when defining a function.

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

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

# Functions with Multiple Parameters

You can define functions that accept multiple parameters.

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

println add(3, 5)  // Output 8

# Anonymous Functions

You can define anonymous functions and assign them to variables or pass them as parameters.

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

# Functions with Variable Arguments

You can define functions that accept a variable number of arguments.

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

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

# Functions with Closures

You can define functions that accept closures as parameters.

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

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

# Functions Returning Multiple Values

You can define functions that return multiple values, which will be returned as a list.

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

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

# Recursive Functions

You can define recursive functions that call themselves within the function.

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

println factorial(5)  // Output 120