Turn this Java into Groovy!

[Matthew Taylor]

If you have some Java code, and you are interested in seeing what it would look like as Groovy code, post it here! If you think want to take a shot at translating it yourself, fire up your groovy console and go for it!

I'll start off with a simple example of reading a file into a String and printing it to stdout.

JAVA:

import java.io.*;
 
public final class MainClass {
    
    public void printFileText() {
        File file = new File("books.xml");
        try {
            BufferedReader br = new BufferedReader(new FileReader(file));
            while (br.ready()) {
                System.out.println(br.readLine());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }
    
    public static void main(String[] args) {
        MainClass mainClass = new MainClass();
        mainClass.printFileText();
    }
}

GROOVY:

println new File('books.xml').text

[ August 31, 2008: Message edited by: Matthew Taylor ]

[Marc Peabody]

This is a great idea. I'd set up an example myself, but that means having to write messy Java code.

[Matthew Taylor]

Here is a regular expression example that matches a zip code.

JAVA (from java2s.com):

public class MatchZipCodes {
  public static void main(String args[]) {
    isZipValid("45643-4443");
    isZipValid("45643");
    isZipValid("443");
    isZipValid("45643-44435");
    isZipValid("45643 44435");
  }
 
  public static boolean isZipValid(String zip) {
    boolean retval = false;
    String zipCodePattern = "\\d{5}(-\\d{4})?";
    retval = zip.matches(zipCodePattern);
 
    String msg = "NO MATCH: pattern:" + zip + "\r\n             regex: "
        + zipCodePattern;
 
    if (retval) {
      msg = "MATCH   : pattern:" + zip + "\r\n             regex: "
          + zipCodePattern;
    }
 
    System.out.println(msg + "\r\n");
    return retval;
  }
}

GROOVY:

def pattern = /\d{5}(-\d{4})?/
 
["45643-4443","45643","443","45643-44435","45643 44435"].each { zip ->
    if (zip.matches(pattern)) {
        println "MATCH: pattern:${zip}\r\n             regex: ${pattern}"
    } else {
        println "NO MATCH   : pattern:${zip}\r\n             regex: ${pattern}"
    }
}

Both print this:

MATCH: pattern:45643-4443
             regex: \d{5}(-\d{4})?
MATCH: pattern:45643
             regex: \d{5}(-\d{4})?
NO MATCH   : pattern:443
             regex: \d{5}(-\d{4})?
NO MATCH   : pattern:45643-44435
             regex: \d{5}(-\d{4})?
NO MATCH   : pattern:45643 44435
             regex: \d{5}(-\d{4})?

Aside from the obvious regex pattern matching simplicity in the Groovy code, you might also notice that you can call collection methods directly on a collection declaration:

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

This prints each number in the array without even instantiating a variable.

And here is another piece of syntactic sugar:

10.times {
    println it
}

This will print the numbers 1 through 10 out to the screen, because 'times()' is a method on the Groovy Integer class that takes a Closure as an argument. Pretty awesome stuff.

[ September 16, 2008: Message edited by: Matthew Taylor ]
[ September 16, 2008: Message edited by: Matthew Taylor ]

[Marc Peabody]

Here's a couple more variations.

You could collect all the messages and then print them each.

def pattern = /\d{5}(-\d{4})?/ 
def all = ["45643-4443","45643","443","45643-44435","45643 44435"]
 
def isZipValid = {
   "${!it.matches(pattern)?'NO':''} MATCH: pattern:${it}\r\n             regex: ${pattern}"
}
all.collect{ isZipValid it }.each{ println it }    

Or what I like better, split our collection up and then print each group separately.

def pattern = /\d{5}(-\d{4})?/ 
def all = ["45643-4443","45643","443","45643-44435","45643 44435"]
 
def valid = all.findAll{ it.matches(pattern) }
def notvalid = all - valid
 
println "The valid zips:"; valid.each{ println it }
println "All the rest:"; notvalid.each{ println it }    

[Matthew Taylor]

I like your second variation. Those collection operators like "-" are sweet.

[Matthew Taylor]

I've been wanting to do an XML example, but all the Java code that deals with XML is so horrible that I've been putting it off. So I finally decided to omit the Java example, in the hopes that you've probably got some experience with Java XML parsing, and you know just how tedious and nasty it can be.

JAVA: See various nasty examples here

GROOVY:

def rawText = new File('books.xml').text
def catalog = new XmlParser().parseText(rawText)
 
println catalog.getClass()
 
println "Total books: ${catalog.book.size()}"
println "Total XML elements: ${catalog.depthFirst().size()}"
 
println "5th book's author is \"${catalog.book[4].author.text()}\""
 
def aboutEngland = catalog.book.findAll { 
    it.description.text().contains('England') 
}.collect { 
    "${it.title.text()} (id: ${it.'@id'})"
}
 
println "Books about England:"
aboutEngland.each {
    println "\t$it"
}

Resulting in this printout:

class groovy.util.Node
Total books: 12
Total XML elements: 85
5th book's author is "Corets, Eva"
Books about England:
Maeve Ascendant (id: bk103)
Oberon's Legacy (id: bk104)
The Sundered Grail (id: bk105)

I'm using the same xml file as my first post's example, and as you can see there is not much involved with the parsing. You just create a new parser and send it the text. Very easy.

And you can see how efficient it is to access the parsed data. The resulting 'catalog' object is a groovy.util.Node. Each node is a collection of Nodes with some nice convenience methods. You can access attributes by using the '@' symbol (the book ids in the printout are from attributes).

Another useful thing I've done is chained a couple of collection methods together to help me format my "England" search results. I first did a 'findAll' with a closure that returns true only if the book description text contains 'England', then I'm calling 'collect' on the results to convert each found Node into a String. This is the same thing as doing this:

def aboutEnglandNodes = catalog.book.findAll {
    it.description.text().contains('England')
}
def aboutEnglandData = aboutEnglandNodes.collect {
    "${it.title.text()} (id: ${it.'@id'})"
}

Maybe next example will be an XML writer, which is also surprisingly easy.
[ September 18, 2008: Message edited by: Matthew Taylor ]

[Marc Peabody]

Originally posted by Matthew Taylor:
Maybe next example will be an XML writer, which is also surprisingly easy.

Repackaging the xml file using only the found books:

def cat = new groovy.util.XmlSlurper().parseText(rawText)
 
def aboutEngland = cat.book.findAll { 
    it.description.text().contains('England') 
}
 
println(new groovy.xml.StreamingMarkupBuilder().bind{
 catalog{ mkp.yield aboutEngland }
})    

Creates:

<catalog><book id='bk103'><author>Corets, Eva</author><title>Maeve Ascendant</title><genre>Fantasy</genre><price>5.95</price><publish_date>2000-11-17</publish_date><description>After the collapse of a nanotechnology 
      society in England, the young survivors lay the 
      foundation for a new society.</description></book><book id='bk104'><author>Corets, Eva</author><title>Oberon's Legacy</title><genre>Fantasy</genre><price>5.95</price><publish_date>2001-03-10</publish_date><description>In post-apocalypse England, the mysterious 
      agent known only as Oberon helps to create a new life 
      for the inhabitants of London. Sequel to Maeve 
      Ascendant.</description></book><book id='bk105'><author>Corets, Eva</author><title>The Sundered Grail</title><genre>Fantasy</genre><price>5.95</price><publish_date>2001-09-10</publish_date><description>The two daughters of Maeve, half-sisters, 
      battle one another for control of England. Sequel to 
      Oberon's Legacy.</description></book></catalog>
    

[adwin wijaya]

groovy is great ..

thanks for the tutorial .. i am learning groovy at the moment .. preparing for using it together with grails.