Sintaxe Comum do Groovy

O Groovy é uma linguagem de programação flexível baseada na plataforma Java, que combina muitas características poderosas de Python, Ruby e Smalltalk. A seguir estão algumas sintaxes comuns do Groovy para ajudá-lo a começar rapidamente.

Declaração de Variáveis

No Groovy, a declaração de variáveis pode ser feita usando a palavra‑chave def ou especificando explicitamente o tipo.

// Usando a palavra‑chave def
def name = "Groovy"

// Especificando explicitamente o tipo
String greeting = "Hello, ${name}!"

Tipos de Dados

O Groovy suporta diversos tipos de dados, incluindo inteiros, ponto flutuante, booleanos e strings, entre outros.

def a = 10          // Inteiro
def b = 10.5        // Ponto flutuante
def c = true        // Booleano
def d = "Groovy"    // String

Operações Lógicas

O Groovy oferece operadores lógicos como && (e), || (ou) e ! (não).

def a = 10
def b = 20

if (a > 0 && b > 0) {
    println "Ambos os números são positivos"
} else if (a > 0 || b > 0) {
    println "Pelo menos um número é positivo"
} else {
    println "Ambos os números não são positivos"
}

Estruturas Condicionais

O Groovy suporta estruturas condicionais if-else e switch.

def number = 10
if (number > 0) {
    println "O número é positivo"
} else {
    println "O número não é positivo"
}

switch (number) {
    case 0:
        println "O número é zero"
        break
    case { it > 0 }:
        println "O número é positivo"
        break
    default:
        println "O número é negativo"
}

Estruturas de Repetição

O Groovy suporta loops for, while e do-while.

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

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

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

Strings

Concatenação de Strings

No Groovy, é possível concatenar strings utilizando o operador + ou a sintaxe ${}.

def name = "Groovy"
def greeting = "Hello, " + name + "!"
println greeting  // Saída: Hello, Groovy!

def greeting2 = "Hello, ${name}!"
println greeting2  // Saída: Hello, Groovy!

Corte de Strings

É possível utilizar o método substring para extrair partes de uma string.

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

Substituição de Strings

O método replace permite substituir parte de uma string por outra.

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

Divisão de Strings

O método split divide uma string em uma lista.

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

Divisão e Extração de Valores

O método tokenize divide uma string em uma lista e permite acessar elementos específicos via índice.

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

Remoção de Espaços em Branco

O método trim remove espaços em branco das extremidades de uma string.

def str = "  Hello, Groovy!  "
println str.trim()  // Saída: Hello, Groovy!

Comprimento de uma String

A propriedade length retorna o comprimento de uma string.

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

Verificação de Conteúdo

O método contains verifica se uma string contém determinado subtexto.

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

Busca em Strings

O método indexOf encontra a posição de um subtexto dentro de uma string.

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

Comparação de Strings

Operadores como ==, !=, <, >, <= e >= permitem comparar strings.

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

Escape de Caracteres

O caractere \ é utilizado para escapar caracteres especiais, como \n para nova linha.

def str = "Hello,\nGroovy!"
println str  // Saída: Hello,
             // Groovy!

Templates de Strings

O Groovy permite inserir variáveis em strings utilizando a sintaxe ${}.

def name = "Groovy"
def greeting = "Hello, ${name}!"
println greeting  // Saída: Hello, Groovy!

Expressões Regulares

O operador ==~ permite realizar correspondências regulares.

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

Strings Multilinha

Strings multilinha podem ser definidas utilizando três aspas """ ou '''.

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

Listas (List)

No Groovy, listas são estruturas de dados muito utilizadas, podendo conter elementos de diferentes tipos. Abaixo estão algumas operações comuns de listas no Groovy.

Definição de Listas

Uma lista pode ser definida utilizando colchetes [].

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

Acesso a Elementos de uma Lista

Os elementos de uma lista podem ser acessados por meio de índices, iniciando em 0.

def list = [1, 2, 3, 'Groovy', true]
println list[3]  // Saída: Groovy

Alteração de Elementos

É possível modificar elementos de uma lista através de seus índices.

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

Adição de Elementos

Elementos podem ser adicionados à lista utilizando o método add ou o operador de deslocamento à esquerda <<.

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

list << 5
println list  // Saída: [1, 2, 3, 4, 5]

Remoção de Elementos

Elementos podem ser removidos da lista utilizando o método remove.

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

Tamanho de uma Lista

O método size retorna o tamanho de uma lista.

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

Iteração sobre uma Lista

É possível percorrer os elementos de uma lista utilizando um loop for.

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

Também é possível usar o método each para iterar sobre os elementos.

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

Conversão de Listas

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

Filtragem de Listas

find

Retorna o primeiro elemento que atende a uma condição.

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

findAll

Retorna uma nova lista contendo todos os elementos que atendem à condição.

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

Verificação de Condições em Listas

any

Verifica se pelo menos um elemento atende à condição.

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

every

Verifica se todos os elementos atendem à condição.

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

Corte de Partes de uma Lista

É possível obter uma parte de uma lista utilizando o método subList.

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

Ordenação de Listas

A ordenação de listas pode ser realizada utilizando o método sort.

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

Reversão de Listas

A reversão de listas pode ser feita utilizando o método reverse.

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

Verificação de Existência de Elementos

O método contains verifica se uma lista contém determinado elemento.

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

Concatenação de Listas

É possível concatenar duas listas utilizando o método plus ou o operador +.

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

Limpeza de Listas

A limpeza de listas pode ser realizada utilizando o método clear.

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

Mapas (Map)

No Groovy, mapas são estruturas de dados amplamente utilizadas para armazenar pares chave‑valor. A seguir estão algumas operações comuns com mapas no Groovy.

Definição de Mapas

Um mapa pode ser definido utilizando colchetes [:] ou chaves {}.

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

Acesso a Elementos de um Mapa

Os valores de um mapa podem ser acessados por meio de suas chaves.

def map = ["name": "Groovy", "version": 2.5]
println map["name"]  // Saída: Groovy

Alteração de Elementos de um Mapa

É possível modificar os valores de um mapa diretamente por meio de suas chaves.

def map = ["name": "Groovy", "version": 2.5]
map["name"] = "Java"
println map  // Saída: [name:Java, version:2.5]

Adição de Elementos

Elementos podem ser adicionados a um mapa utilizando o método put ou atribuindo‑se diretamente um valor.

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

map["author"] = "James"
println map  // Saída: [name:Groovy, version:2.5, author:James]

Remoção de Elementos

Elementos podem ser removidos de um mapa utilizando o método remove.

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


println map  // Saída: [name:Groovy]

Tamanho do mapa

É possível usar o método size para obter o tamanho do mapa.

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

Iteração sobre o mapa

Pode-se utilizar o método each para percorrer os pares chave‑valor do mapa.

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

Verificação de chaves ou valores

Os métodos containsKey e containsValue permitem verificar se um determinado mapa contém uma chave ou valor específico.

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

Limpar o mapa

O método clear pode ser usado para limpar todo o conteúdo do mapa.

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

Mesclar mapas

O método putAll permite adicionar todos os elementos de um mapa a outro.

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

Obter todas as chaves ou valores

Os métodos keySet e values permitem recuperar todas as chaves ou valores presentes no mapa.

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

Funções

No Groovy, as funções são chamadas de métodos e podem ser definidas dentro de classes ou como parte de scripts. A seguir estão algumas sintaxes comuns para definir e chamar funções em Groovy.

Definindo funções

Uma função pode ser definida usando a palavra‑chave def.

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

Chamando funções

Após definir uma função, ela pode ser invocada pelo seu nome e parâmetros.

def result = greet("Groovy")
println result  // Saída: Hello, Groovy!

Funções com parâmetros padrão

É possível atribuir valores padrão aos parâmetros ao definir uma função.

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

println greet()        // Saída: Hello, World!
println greet("Groovy") // Saída: Hello, Groovy!

Funções com múltiplos parâmetros

É possível definir funções que aceitam vários parâmetros.

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

println add(3, 5)  // Saída: 8

Funções anônimas

Funções anônimas podem ser definidas e atribuídas a variáveis ou passadas como argumentos.

def multiply = { a, b -> a * b }
println multiply(3, 5)  // Saída: 15

Funções com parâmetros variáveis

É possível definir funções que aceitam um número variável de parâmetros.

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

println sum(1, 2, 3, 4)  // Saída: 10

Funções que recebem closures

É possível definir funções que aceitam closures como argumentos.

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

def add = { x, y -> x + y }
println operate(3, 5, add)  // Saída: 8

Funções que retornam múltiplos valores

É possível definir funções que retornam mais de um valor; esses valores serão agrupados em uma lista.

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

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

Funções recursivas

É possível definir funções recursivas, ou seja, funções que se chamam a si mesmas.

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

println factorial(5)  // Saída: 120