{"id":976,"date":"2011-09-08T20:16:14","date_gmt":"2011-09-08T23:16:14","guid":{"rendered":"https:\/\/devkico.itexto.com.br\/?p=976"},"modified":"2011-09-08T20:16:14","modified_gmt":"2011-09-08T23:16:14","slug":"groovy-vs-java-listas","status":"publish","type":"post","link":"https:\/\/devkico.itexto.com.br\/?p=976","title":{"rendered":"Groovy vs Java: listas"},"content":{"rendered":"

\"\"<\/a>O erro mais comum de quem est\u00e1 aprendendo Grails \u00e9 programar em Groovy exatamente como seria feito em Java. \u00c9 um comportamento comum, visto que aparentemente<\/strong> n\u00e3o h\u00e1 tantas diferen\u00e7as sint\u00e1ticas assim entre as duas linguagens. Reparou que coloquei “aparentemente” em negrito?<\/p>\n

Este post \u00e9 o primeiro de uma s\u00e9rie na qual pretendo comparar as duas linguagens e tentando convenc\u00ea-los a n\u00e3o cometer o pecado de se programar em Groovy como se fosse Java.<\/p>\n

Primeira diferen\u00e7a: as listas est\u00e3o presentes na sintaxe do Groovy<\/h3>\n

Em Java\u00a0 para criar uma lista\u00a0 o caminho padr\u00e3o \u00e9 instanciar alguma classe que implemente a interface java.util.List, gerando c\u00f3digo como o abaixo:<\/p>\n

\r\n\r\nList<Tipo> lista = new ArrayList<Tipo>();\r\n\r\n<\/pre>\n
Em Groovy temos um elemento sint\u00e1tico s\u00f3 para lidar com listas que s\u00e3o os colchetes. O mesmo c\u00f3digo que escrevi em Java, eu reescreveria em Groovy assim:<\/p>\n
\r\n\r\ndef lista = []\r\n\r\n<\/pre>\n
A vari\u00e1vel lista armazena agora uma inst\u00e2ncia de java.util.ArrayList. Repare: eu n\u00e3o preciso definir (e nem tenho como usando esta sintaxe) o tipo que esta lista ir\u00e1 armazenar, porque Groovy possui tipagem din\u00e2mica.<\/p>\n
E sabe o que \u00e9 mais legal? Eu tamb\u00e9m posso j\u00e1 instanciar minha lista preenchida, tal como nos exemplos abaixo:<\/p>\n
\r\n\r\ndef lista_de_strings = ["Uma bonita lista", "com muitas", "strings"]\r\n\r\ndef lista_ecletica = ["Uma string", 23, true, false, ["uma", "lista", "interna"]]\r\n\r\n<\/pre>\n
Em Java \u00e9 poss\u00edvel instanciar uma lista e ao mesmo tempo j\u00e1 definir o seu conte\u00fado. H\u00e1 duas maneiras de se fazer isto: voc\u00ea pode usar um construtor que receba como par\u00e2metro um objeto que implemente a interface java.util.Collection OU pode usar um c\u00f3digo bem feio usando inner classes. Quer ver? Bem, aqui vai:<\/p>\n
\r\n\r\nList<String> lista_strings = new ArrayList<String>() {{\r\nadd("Uma lista");\r\nadd("Com c\u00f3digo muito");\r\nadd("Feio");\r\n\r\n}};\r\n\r\n<\/pre>\n
ALERTA:<\/span><\/strong> se estiver programando em Groovy exatamente como faz em Java, \u00e9 certo que ao topar com uma lista como as que expus acima voc\u00ea ir\u00e1 acreditar se tratar de um array.<\/p>\n
Acessando elementos<\/h3>\n
Como em Java as listas s\u00e3o implementa\u00e7\u00f5es da interface java.util.List, acessar os elementos sempre \u00e9 feito pelo m\u00e9todo get, como no exemplo abaixo:<\/p>\n
\r\n\r\nString valor = lista.get(1); \/\/ pego o segundo elemento\r\n\r\n<\/pre>\n
Sabe, em Groovy eu posso fazer exatamente como em Java, j\u00e1 que \u00e9 uma inst\u00e2ncia de java.util.ArrayList. E tamb\u00e9m de uma forma mais bacaninha. :)<\/p>\n
\r\n\r\ndef valor = lista[1] \/\/ pego o segundo elemento\r\n\r\ndef valor2 = lista.get(1) \/\/ a la Java\r\n\r\n<\/pre>\n
Inserindo e removendo elementos<\/h3>\n
Em Java, quando queremos adicionar um elemento em uma lista, usamos o m\u00e9todo add, como no c\u00f3digo abaixo:<\/p>\n
\r\n\r\nlista.add("String quente");\r\n\r\n<\/pre>\n
Em Groovy podemos usar um recurso poderoso que \u00e9 a sobrescrita de operadores. Quer ver como funciona?<\/p>\n
\r\n\r\ndef lista = []\r\n\r\nlista += "Uma string" \/\/ O operador += serve para inserir um elemento na lista\r\n\r\nlista.add("Uma outra string") \/\/ a la Java\r\n\r\ndef nova_lista = lista + "Adendo" \/\/ crio uma nova lista, chamada nova_lista, que cont\u00e9m o conteudo de lista + uma String\r\n\r\n<\/pre>\n
Resumindo: o operador += inclui elementos na lista, enquanto o operador + cria uma nova lista.<\/p>\n
E pra remover voc\u00ea prov\u00e1velmente j\u00e1 sabe tamb\u00e9m:<\/p>\n
\r\n\r\ndef lista = ["um", "Monte", "de", "strings"]\r\n\r\nlista -= "Monte" \/\/ removo o elemento "Monte"\r\n\r\ndef nova_lista = lista - "de" \/\/ crio uma nova lista que n\u00e3o cont\u00e9m o elemento "de"\r\n\r\n<\/pre>\n
Outro resumo: o operador – remove um elemento, enquanto o operador -= cria uma nova lista que n\u00e3o cont\u00e9m o elemento passado como par\u00e2metro.<\/p>\n
Buscando elementos<\/h3>\n
Se em Java voc\u00ea quer retornar todos os elementos de uma lista que satisfa\u00e7am a um crit\u00e9rio, o c\u00f3digo a ser escrito vai ser parecido com isto:<\/p>\n
\r\n\r\nList<Pessoa> pessoas = new ArrayList<Pessoa>() {{\r\n\r\nadd(new Pessoa("Kico", 32);\r\nadd(new Pessoa("Lol\u00f3", 29);\r\nadd(new Pessoa("Theo", 0);\r\n\r\n}};\r\n\r\nList<Pessoa> pessoas_com_mais_de_um_ano = new ArrayList<Pessoa>();\r\n\r\nfor (Pessoa pessoa : pessoas) {\r\n\r\nif (pessoa.getIdade() > 1) pessoas_com_mais_de_um_ano.add(pessoa);\r\n\r\n}\r\n\r\n<\/pre>\n
E em Groovy, como fa\u00e7o hein? Assim:<\/p>\n
\r\n\r\ndef pessoas = [new Pessoa([nome:"Kico", idade:32]), new Pessoa([nome:"Lol\u00f3", idade:29]),\r\nnew Pessoa([nome:"Theo", idade:0])]\r\n\r\ndef resultado = pessoas.findAll { it.idade > 1 }\r\n\r\n<\/pre>\n
Eu uso a fun\u00e7\u00e3o findAll, que recebe como par\u00e2metro uma closure<\/a>. O papel desta \u00e9 simples: retornou true? Adicione na lista de retorno.<\/p>\n
E se eu quiser s\u00f3 o primeiro resultado?<\/p>\n
\r\n\r\ndef resultado = pessoas.find {it.idade > 1}\r\n\r\n<\/pre>\n
Vou retornar n\u00e3o uma lista, mas a primeira inst\u00e2ncia que satisfa\u00e7a ao resultado.<\/p>\n
Outro problema: como voc\u00ea verifica se pelo menos um objeto em uma lista satisfa\u00e7a a uma condi\u00e7\u00e3o? Em Java, escrevemos um monstrinho como o c\u00f3digo abaixo:<\/p>\n
\r\n\r\npublic boolean existeUmBebe(List<Pessoa> lista) {\r\n\r\nfor (Pessoa pessoa : lista) {\r\n\r\nif (pessoa.getIdade() < 1) return true;\r\n\r\n}\r\n\r\nreturn false;\r\n\r\n}\r\n\r\n<\/pre>\n
Wow! E como eu fa\u00e7o em Groovy hein? Eu uso a fun\u00e7\u00e3o any<\/p>\n
\r\n\r\npessoas.any { it.idade < 1 }\r\n\r\n<\/pre>\n
A fun\u00e7\u00e3o any, assim como find e findAll s\u00e3o injetadas em todas as listas pelo Groovy, e todas recebem como par\u00e2metro a closure que verifica a condi\u00e7\u00e3o.<\/p>\n
Iterando sobre o conte\u00fado<\/h3>\n
Em ambas as linguagens, iteramos sobre o conte\u00fado usando o loop for. At\u00e9 ai, nada demais. A diferen\u00e7a \u00e9 que Groovy injeta em nossas classes um m\u00e9todo chamado each, que recebe como par\u00e2metro uma closure. Ent\u00e3o \u00e9 poss\u00edvel iterar em cima do resultado de uma consulta de forma bastante simples, tal como no exemplo abaixo:<\/p>\n
\r\n\r\ndef lista = [new Pessoa([nome:"Kico", idade:32]), new Pessoa([nome:"Lol\u00f3", idade:29]),\r\nnew Pessoa([nome:"Theo", idade:0])]\r\n\r\nlista.findAll { it.idade > 0 }.each {\r\nprintln it.nome\r\n}\r\n\r\n<\/pre>\n
O par\u00e2metro que a closure recebe \u00e9 o elemento corrente da itera\u00e7\u00e3o.\u00a0 E sabe o que \u00e9 mais legal? A closure n\u00e3o precisa ser passada na hora.<\/p>\n
\r\n\r\ndef trabalhe = {pessoa ->\r\n\r\nif (pessoa.idade > 0) { println "T\u00e1 velho!"} else {println "Ta quase velho!"}\r\n\r\n}\r\n\r\npessoas.each trabalhe\r\n\r\n<\/pre>\n
Coletando valores de atributos<\/h3>\n
Imagine que no nosso exemplo, precisemos coletar todos os nomes das pessoas presentes em nossa lista. Em Java, escrever\u00edamos algo como o c\u00f3digo abaixo:<\/p>\n
\r\n\r\nList<String> nomes = new ArrayList<String>();\r\n\r\nfor (Pessoa pessoa : pessoas) { nomes.add(pessoa.getNome()); }\r\n\r\n<\/pre>\n
Em Groovy, usamos a fun\u00e7\u00e3o collect que \u00e9 injetada nas cole\u00e7\u00f5es. Esta recebe como par\u00e2metro uma closure que ser\u00e1 iterada em cima de todos os elementos da lista. O valor de retorno de cada itera\u00e7\u00e3o \u00e9 adicionado a uma lista que \u00e9 o resutlado da fun\u00e7\u00e3o. \u00c9 complicado de descrever, mas vendo o c\u00f3digo fica mais f\u00e1cil. :)<\/p>\n
\r\n\r\ndef nomes = pessoas.collect { it.nome }\r\n\r\n<\/pre>\n
Concluindo<\/h3>\n
Eu s\u00f3 arranhei a superf\u00edcie do assunto. O que fica claro \u00e9: com Groovy voc\u00ea escreve muito menos c\u00f3digo.\u00a0 Um ponto importante a ser salientado \u00e9: quando escrevemos c\u00f3digo em Groovy usando a sintaxe do Java estamos dificultando a vida do compilador, que sofrer\u00e1 horrores tentando otimizar o seu c\u00f3digo. H\u00e1 portanto duas consequ\u00eancias neste pecado:<\/p>\n