Collections no Groovy

Neste post vamos explorar as Groovy Collections. Primeiro, a definição: Uma coleção representa um grupo de objetos conhecidos como elementos. Em Java, a interface "pai de todas" para tratar collections é a

java.util.Collection

.
O Groovy prove uma sintaxe bem legal para definir listas.

def lista = [1,2,3]

Por padrão, o Groovy admite uma lista sem ordenação e caso deseje implementá-la utilize a classe

Set

.

Set lista = [1,2,3]

Agora vamos ao mais legal do Groovy. Os operadores aritmeticos e de comparação podem ser utilizados em Groovy.
Segue uma tabelinha com o que aconteçe por debaixo dos panos:

Operadores
Métodos da Collection


a + b
add/addAll


a - b
remove/removalAll


a * b
add/addAll


a == b
equals


a != b
equals


a in b
contains


a as b
Construtor Específico

Alguns exemplos:

def list = [1,2,3]
def list2 = list + [4,5,6]
def list3 = list << [4,5,6]
println "${list2}"
println "${list.is(list2)}"
println "${list3}"
println "${list.is(list3)}"

HashSet s1 = ["a", "b", "c", "e"]
HashSet s2 = ["a", "c", "d"]
def s3 = s1 - s2
println "Result is ${s3} of type ${s3.class}"

HashSet s1 = ["a","b","c"]
def s2 = s1*3
println "Result is ${s2} of type ${s2.class}"

Mais simples, impossível.
Em um próximo post, vou explorar os métodos comuns a coleções e exemplificá-los.

Expressões Regulares no Groovy

Bom dia a todos! Hoje venho postar um breve tutorial sobre mais este poderoso recurso do Groovy.
Como sabemos, não exite uma ferramenta mais poderosa para processar grandes arquivos de texto rapidamente e confiavelmente.
Em Java, as expressões regulares tem a reputação de serem complexas e difíceis de se manter. Até o Java 1.4, sequer tinhamos classes nas bibliotecas padrões do Java.
E, infelizmente os famosos Pattern e Matcher não fizeram muito para melhorar a situação.
O Groovy tem mais uma forma de se declarar Strings que se chama slashy string.

assert java.lang.String == /olá slashy string/.class

A única diferença entre este tipo de string e as de aspas duplas, é que estas não precisam ser escapadas por barras invertidas.

assert "Eu tenho \\d anos de idade." == /Eu tenho \d anos de idade./

Isso pode fazer com que suas expressões regulares fiquem muito mais fáceis de serem lidas.
Uma slash string é uma GString, portanto, todas as substituições de variáveis são executadas normalmente.

def time = "1:42 PM"
assert "A hora é 1:42 PM" -- /A hora é $time/ 

Exemplo de expressão regular usando Groovy.

def time = /([0-9]|10|11|12):([0-5][0-9]) (AM|PM)/

O Groovy utiliza as classes Pattern e Matcher como no Java, só que de forma mais transparente.
1. O operador ~ precedendo uma String, irá criar automaticamente um objeto do tipo Java Pattern.

assert java.util.regex.Pattern = (~/groovy/).getClass()

2. O operador =~ vai receber uma string e uma regexp e criar um objeto Matcher.

def myMatcher = ("54417" =~ /\d{5}) // Procura por exatos 5 digitos
assert myMatcher.matches()
assert java.util.regex.Matcher == myMatcher.getClass()

3. O operador ==~ é um operador boleano para testar se uma string segue um determinado padrão.

assert ("54418" ==~ /\d{5}/ == true

Construções básicas de expressões regulares em Groovy.

def regex = /foobar/
assert ("foobar" ==~ regex)

["a", "b", "c"].each { character ->
 assert( character ==~ /[abc]/
}

Como podemos ver, é muito mais simples escrever uma regex em Groovy.
O resto, é tudo igual a Java. O meu objetivo aqui não é ensinar tudo sobre regex, caso tenha alguma dúvida, de uma olhada no site da sun:
Tutorial Regex.
É isso ai galera, mais uma coisa aprendida!
Abraços

Trabalhando com Strings

Agora vamos falar sobre um tipo que é muito comum em Java, e frequentemente nos dá um pouco de trabalho.
Infelizmente, Java permite apenas uma maneira de especificar literais string ("") o texto entre aspas duplas. Logo, se uma string tem um monte de barras invertidas, já fica difícil de entender.
O Groovy, diferentemente de Java, reconhece que nem todo o uso de literais de string é o mesmo. Nele temos um leque de opções, e as maravilhosas GStrings.
No groovy temos os seguintes tipos de strings:

Caracteres	Exemplo	GString
Aspas Simples	'oi Groovy'	Não
Aspas Duplas	"oi Groovy"	Sim

Temos também as aspas triplas simples e as triplas duplas, que serão exemplificadas mais tarde.
Uma coisa importante é que, uma String Java é uma instância de java.lang.String e uma GString é uma instância de groovy.lang.GString. No Groovy, quando uma declaração de aspas simples é encontrada, é criada um tipo java.lang.String.
Se você é um cara esperto, ligado, deve ter pensado... se algo entre aspas simples, como um 'c' é um java.lang.String, como é uma representação de char no Groovy?
Para isso, precisamos informar o nosso amigo.

def comoUmChar = 'c' as char

Desta forma, a variável fará uma referência a java.lang.Character e não a java.lang.String. Simples né?
Agora chega de conversa e vamos a alguns exemplos de como trabalhar com Strings em Groovy.

// Duas java.lang.String e uma GString
def eu = 'Lucas'
def esposa = 'Cristiane'
// Note o $. Em muitas linguagens isso existe, copiaram mesmo!
def linha = "Eu $eu - Esposa $esposa"
assert linha == 'Eu Lucas - Esposa Cristiane'
assert linha instanceof GString

def data = new Date()
// Mais uma coisa de Groovy. Quando chamo obj.prop, seria como estar chamando obj.getProp().
// No Groovy Bean, isso é transparente, tanto para o get como para o set, ou seja, obj.prop = algo seria obj.setProp(algo)
def dataDetalhe = "Ano $data.year - Mês $data.month - Dia - $data.date"

// Alguns métodos comuns de String
def saudacao = "Hello Groovy"
assert saudacao.startsWith("Hello")
assert "H" == saudacao.getAt(0)
assert saudacao.count("G") == 1
assert saudacao[3..6] == "lo G" // Substring!!!!

É isso ai pessoal, agora já temos noção de como Groovy veio ajudar a nossa vida.
Em um próximo post vou falar sobre expressões regulares. Abraços!

Tipagem opcional

Depois de aprendermos que Groovy trata tudo como um objeto, vamos ver um pouco sobre a tipagem opcional (aquele estranho def para definir variáveis).
Groovy oferece a escolha de atribuir tipos explicitamente como você faz em Java ou não.
A palavra-chave para não definir uma tipagem ao criar uma variável é def.

// Exemplo super demonstrativo
def inteiro = 1
def stringzinha = "Oi Mundo"
def obj = new Carro()

O Groovy define o tipo de acordo com o conteúdo da variável, sem mistérios. Para os programadores Java, no início tendemos a utilizar a tipagem estática, e depois vamos nos acostumando com a palavrinha mágica def.
Este tipo de tipologia é extremamente útil para a reconfiguração de um objeto sem ter que analisá-lo.

Os tipos de dados simples - Tudo é um objeto

Primeiro, diferentemente de Java, para o Groovy tudo é objeto. O Groovy não tem tipos primitivos como o de Java, embora em alguns script você possa achar que eles exitem (...compliquei...rs.).
Vamos a um exemplo:

// Código Groovy
int numeroQueParecePrimitivo = 1
Integer numeroQueNaoParecePrimitivo = 2

Embora a declaração acima seja do tipo primitivo (int), o Groovy transforma isso por debaixo dos panos. No final, o Groovy vai considerar a variável numeroQueParecePrimitivo como do tipo Integer.
Segue uma explicação de como o Groovy trata os tipos que para Java são primitivos:

Tipo primitivo	Tipo Groovy
byte	java.lang.Byte
short	java.lang.Short
int	java.lang.Integer
long	java.lang.Long
float	java.lang.Float
double	java.lang.Double
char	java.lang.Character
boolean	java.lang.Boolean

Isso simplifica muito as coisas. Essa conversão de tipos, é comumente chamada de boxing e a ação reversa unboxing. O Groovy executa essas operações automaticamente, tudo de forma transparente - isso, você não precisa fazer nada (bye bye casting).

Uma coisa importante a se notar é que, por se tratar de objetos, o Groovy utiliza os métodos existentes na API Java para efetuar cálculos.

def a = 1
def b = 2
int soma = a + b

// O Groovy entende assim:
Integer soma = a.plus(b)

Isso é válido para todas as operações de tipos primitivos do Java e seus métodos como plus(), minus(), div(), mod(), next(), previous() etc.

O início da jornada Groovy

Ontem, com a criação do blog, quis dar uma idéia de como as coisas podem ser maravilhosas com o Groovy. Como o meu intuito para este blog é fazer com que as pessoas aprendam uma nova linguagem, preciso definir um ponto de partida. E este ponto deve ser o Groovy. Muita gente vai querer pular para o Grails, pois é fascinante mesmo ver o que ele pode fazer por nós na Web e no desenvolvimento desse tipo de aplicação.
O problema é que sem uma base de Groovy, muita gente vai perder muito tempo no Grails, sem entender bem o porque das coisas e de onde elas vieram.
Por isso hoje, inicio uma série de posts sobre a linguagem Groovy, e assim que passarmos por esta, iniciaremos nossa jornada em Grails e Griffon.
Confie em mim, tudo vai ficar mais fácil.

Classes e Groovy Beans

Bom, como hoje estou animado vou mandar mais um post.
Só para deixar claro, pretendo não me aprofundar muito nos primeiros posts, e ir fazendo isso conforme necessidade.

Declarando classes

class HelloController {
   def world = {
      render "Hello World it's " + new java.util.Date()
   }
}

Aqui definimos uma classe chamada HelloController que contém uma propriedade chamada world. Um valor foi atribuido a esta propriedade, no caso uma closure (não se preocupe com isso agora). Você como um programador Java deve estar confuso em como uma propriedade pode receber uma informação desta forma.

Uma outra diferença do Java é que o Groovy não tem o conceito de visibilidade padrão para classes (os package-levels da vida). Em vez disso, qualquer propriedade definida sem a visibilidade (private, public ou protected) é sub-entendida como uma propriedade de um JavaBean (ou seja, private) e os seus métodos set e get são automaticamente gerados.
No caso de métodos, na ausência de modificadores, eles serão sempre considerados como métodos públicos.

Um exemplo agora, para aprender sobre os Groovy Beans, que são como os famosos Java Beans, mas muito mais simplificados.

class Customer {
      Integer id
      String name
      Date dob

      static void main(args) {
         def customer = new Customer(id:1, name:"Gromit", dob:new Date())
         println("Hello ${customer.name}")
      }
   }

Em uma classe desse tamanhico, já da pra perceber o grande diferencial em relação a Java propriamente dito.
Nada de construtores, setters & getters, ponto e vírgula, e também podemos também omitir a palavra return dos métodos.
E isso é só o começo.
Abraços!