language: Groovy

category: language

filename: learngroovy-pt.groovy

contributors:

- ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]

translators:

- ["João Farias", "https://github.com/JoaoGFarias"]

lang: pt-br

Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http://www.groovy-lang.org/)

```groovy

println "Olá mundo!"

def x = 1

println x

x = new java.util.Date()

println x

x = -3.1499392

println x

x = false

println x

x = "Groovy!"

println x

def tecnologias = []

tecnologias.add("Grails")

tecnologias << "Groovy"

tecnologias.addAll(["Gradle","Griffon"])

tecnologias.remove("Griffon")

tecnologias = technologies - 'Grails'

tecnologias.each { println "Tecnologias: $it"}

tecnologias.eachWithIndex { it, i -> println "$i: $it"}

contem = tecnologias.contains( 'Groovy' )

contem = 'Groovy' in tecnologias

tecnologias.containsAll(['Groovy','Grails'])

tecnologias.sort()

tecnologiasOrdenadas = tecnologias.sort( false )

Collections.replaceAll(tecnologias, 'Gradle', 'gradle')

Collections.shuffle(tecnologias, new Random())

technologies.clear()

def devMap = [:]

devMap = ['nome':'Roberto', 'framework':'Grails', 'linguagem':'Groovy']

devMap.put('ultimoNome','Perez')

devMap.each { println "$it.key: $it.value" }

devMap.eachWithIndex { it, i -> println "$i: $it"}

assert devMap.containsKey('nome')

assert devMap.containsValue('Roberto')

println devMap.keySet()

println devMap.values()

class Foo {

// propriedade de leitura, apenas

final String nome = "Roberto"

// propriedade de leitura, apenas, com getter e setter públicos

String linguagem

protected void setLinguagem(String linguagem) { this.linguagem = linguagem }

// propriedade tipada dinamicamente

def ultimoNome

}

def x = 3

if(x==1) {

println "Um"

} else if(x==2) {

println "Dois"

} else {

println "X é maior que Dois"

}

def y = 10

def x = (y > 1) ? "functionou" : "falhou"

assert x == "functionou"

def x = 0

for (i in 0 .. 30) {

x += i

}

x = 0

for( i in [5,3,2,1] ) {

x += i

}

array = (0..20).toArray()

x = 0

for (i in array) {

x += i

}

def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']

x = ""

for ( e in map ) {

x += e.value

x += " "

}

assert x.equals("Roberto Grails Groovy ")

def tecnologias = ['Groovy','Grails','Gradle']

tecnologias*.toUpperCase() // = to tecnologias.collect { it?.toUpperCase() }

def usuario = User.get(1)

def nomeUsuario = usuario?.nomeUsuario

def clos = { println "Hello World!" }

println "Executando o closure:"

clos()

def soma = { a, b -> println a+b }

soma(2,4)

def x = 5

def multiplicarPor = { num -> num * x }

println multiplicarPor(10)

def clos = { print it }

clos( "oi" )

def cl = {a, b ->

sleep(3000) // simula processamento

a + b

}

mem = cl.memoize()

def chamaClosure(a, b) {

def inicio = System.currentTimeMillis()

mem(a, b)

println "Os inputs(a = $a, b = $b) - tomam ${System.currentTimeMillis() - inicio} msecs."

}

chamaClosure(1, 2)

chamaClosure(1, 2)

chamaClosure(2, 3)

chamaClosure(2, 3)

chamaClosure(3, 4)

chamaClosure(3, 4)

chamaClosure(1, 2)

chamaClosure(2, 3)

chamaClosure(3, 4)

def usuario = new Expando(nome:"Roberto")

assert 'Roberto' == nome.name

nome.lastName = 'Pérez'

assert 'Pérez' == nome.lastName

nome.showInfo = { out ->

out << "Name: $name"

out << ", Last name: $lastName"

}

def sw = new StringWriter()

println nome.showInfo(sw)

String.metaClass.testAdd = {

println "adicionamos isto"

}

String x = "teste"

x?.testAdd()

class Test implements GroovyInterceptable {

def soma(Integer x, Integer y) { x + y }

def invocaMetodo(String name, args) {

System.out.println "Invoca método $name com argumentos: $args"

}

}

def teste = new Test()

teste?.soma(2,3)

teste?.multiplica(2,3)

class Foo {

def propertyMissing(String nome) { nome }

}

def f = new Foo()

assertEquals "boo", f.boo

import groovy.transform.TypeChecked

void testeMethod() {}

void test() {

testeMethod()

def nome = "Roberto"

println noomee

}

import groovy.transform.TypeChecked

Integer test() {

Integer num = "1"

Integer[] numeros = [1,2,3,4]

Date dia = numeros[1]

return "Teste"

}

import groovy.transform.CompileStatic

int soma(int x, int y) {

x + y

}

assert soma(2,5) == 7

```

## Referências

## Livro