DBAPI

# Groovy 常用语法

Groovy 是一种基于 Java 平台的灵活编程语言，它结合了 Python、Ruby 和 Smalltalk 的许多强大特性。以下是一些 Groovy 的常用语法，帮助你快速上手。

# 变量声明

在 Groovy 中，变量声明可以使用 def 关键字，也可以显式指定类型。

// 使用 def 关键字
def name = "Groovy"

// 显式指定类型
String greeting = "Hello, ${name}!"

# 数据类型

Groovy 支持多种数据类型，包括整型、浮点型、布尔型和字符串等。

def a = 10          // 整型
def b = 10.5        // 浮点型
def c = true        // 布尔型
def d = "Groovy"    // 字符串

# 逻辑运算

Groovy 支持 &&（逻辑与）、||（逻辑或）、!（逻辑非）等逻辑运算符。

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"
}

# 条件语句

Groovy 支持 if-else 和 switch 条件语句。

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"
}

# 循环语句

Groovy 支持 for、while 和 do-while 循环。

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

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

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

# 字符串

# 字符串拼接

在 Groovy 中，可以使用 + 运算符或者通过 ${} 语法进行字符串拼接。

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

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

# 字符串截取

可以使用 substring 方法来截取字符串的一部分。

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

# 字符串替换

可以使用 replace 方法来替换字符串中的内容。

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

# 字符串分割

可以使用 split 方法将字符串分割成数组。

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

# 字符串分割与取值

可以使用 tokenize 方法将字符串分割成列表，并通过索引访问特定部分。

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

# 字符串修剪

可以使用 trim 方法去除字符串两端的空白字符。

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

# 字符串长度

可以使用 length 属性获取字符串的长度。

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

# 字符串包含

可以使用 contains 方法判断字符串是否包含某个子字符串。

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

# 字符串查找

可以使用 indexOf 方法查找子字符串在字符串中的位置。

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

# 字符串比较

可以使用 ==、!=、<、>、<=、>= 等运算符进行字符串比较。

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

# 字符串转义

可以使用 \ 来转义特殊字符，如 \n 表示换行符。

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

# 字符串模板

Groovy 支持使用 ${} 语法在字符串中嵌入变量。

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

# 字符串正则匹配

可以使用 ==~ 运算符进行正则匹配。

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

# 多行字符串

可以使用三个引号 """ 或 ''' 定义多行字符串。

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

# 列表（List）

在 Groovy 中，列表（List）是一种常用的数据结构，可以包含不同类型的元素。以下是一些 Groovy 列表操作的常用语法。

# 定义列表

可以使用方括号 [] 定义一个列表。

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

# 访问列表元素

可以通过索引访问列表中的元素，索引从 0 开始。

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

# 修改列表元素

可以通过索引修改列表中的元素。

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

# 添加元素

可以使用 add 方法或左移运算符 << 向列表中添加元素。

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

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

# 删除元素

可以使用 remove 方法从列表中删除元素。

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

# 列表长度

可以使用 size 方法获取列表的长度。

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

# 遍历列表

可以使用 for 循环遍历列表中的元素。

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

# 列表切片

可以使用 subList 方法获取列表的一部分。

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

# 列表排序

可以使用 sort 方法对列表进行排序。

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

# 列表反转

可以使用 reverse 方法对列表进行反转。

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

# 列表包含

可以使用 contains 方法检查列表是否包含某个元素。

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

# 列表连接

可以使用 plus 方法或 + 运算符连接两个列表。

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

# 列表清空

可以使用 clear 方法清空列表。

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

# 映射（Map）

在 Groovy 中，映射（Map）是一种常用的数据结构，用于存储键值对。以下是一些 Groovy 映射操作的常用语法。

# 定义映射

可以使用方括号 [:] 或花括号 {} 定义一个映射。

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

# 访问映射元素

可以通过键访问映射中的值。

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

# 修改映射元素

可以通过键修改映射中的值。

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

# 添加元素

可以使用 put 方法或直接赋值向映射中添加元素。

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

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

# 删除元素

可以使用 remove 方法从映射中删除元素。

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

# 映射大小

可以使用 size 方法获取映射的大小。

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

# 遍历映射

可以使用 each 方法遍历映射中的键值对。

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

# 检查键或值

可以使用 containsKey 和 containsValue 方法检查映射中是否包含某个键或值。

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

# 清空映射

可以使用 clear 方法清空映射。

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

# 合并映射

可以使用 putAll 方法将一个映射中的所有元素合并到另一个映射中。

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

# 获取所有键或值

可以使用 keySet 和 values 方法获取映射中的所有键或值。

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

# 函数

在 Groovy 中，函数被称为方法（Method），可以定义在类中或作为脚本的一部分。以下是一些 Groovy 函数定义和调用的常用语法。

# 定义函数

可以使用 def 关键字定义一个函数。

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

# 调用函数

定义函数后，可以通过函数名和参数调用它。

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

# 带默认参数的函数

可以在定义函数时为参数提供默认值。

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

println greet()        // 输出 Hello, World!
println greet("Groovy") // 输出 Hello, Groovy!

# 多个参数的函数

可以定义接受多个参数的函数。

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

println add(3, 5)  // 输出 8

# 匿名函数

可以定义匿名函数，并将其赋值给变量或作为参数传递。

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

# 带可变参数的函数

可以定义接受可变数量参数的函数。

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

println sum(1, 2, 3, 4)  // 输出 10

# 带闭包的函数

可以定义接受闭包（Closure）作为参数的函数。

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

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

# 返回多个值的函数

可以定义返回多个值的函数，返回值将作为一个列表。

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

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

# 递归函数

可以定义递归函数，即在函数内部调用自身。

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

println factorial(5)  // 输出 120