5 Handy Groovy Shortcuts

Groovy's main advantage over Java programming is the ability for a developer to implement a solution in fewer lines of code. Groovy's idioms produce concise, short, and clean code. Of course, on first look the code may look strange to a Java developer. But once you learn Groovy's shortcuts you realize the value of consciseness and how less noise produces easier maintenance of code. To me, this is simple: "Since there is less code to look at, there is less code to understand. Learn the shortcuts and idioms and produce less code to do more."

Over the last year, I adopted Groovy as an enterprise implementation language. Here are 5 Groovy programming shortcuts that I found to be very handy. They are listed as tests, in the model of TDD.

Spread Dot Operator

The spread dot operator calls a method on every item in a collection. Upon the invocations, it creates a new list from the return items.  So instead of looping through a collection to make a call on each object, use the spread dot operator.

Let's say we want to get the first 3 letters of each username:

    void testSpreadDot() {
      def emails = ["nirav@yahoo.com", "bob@gmail.com", "jacob@msn.com"]
      def firstThreeLetters = emails*.getAt(0..2)
      assertEquals(firstThreeLetters, ["nir", "bob", "jac"])
    } 

This is very useful when utilizing several common design patterns or just plan old polymorphism. You are able to call an interface many times with minimal code.

'as' Operator for BigDecimal conversion

The 'as' keyword in Groovy acts as Cast does in regular Java. A fantastic application of this is for converting strings into BigDecimals. Any application that deals with money inevitably has to read a string such as "54.99" and convert it into a BigDecimal. These strings could come from the UI screen, an Excel spreadsheet, or an external database. With Java, you have to create a new instance, set the scale, do ROUND_UP, ROUND_DOWN. This all becomes non-sense once you use 'as BigDecimal'.

    void testAsBigDecimal() {
      def shirtPriceString = "19.99"
      def shirtPrice = shirtPriceString as BigDecimal
      assertEquals(BigDecimal.class, shirtPrice.class)
      assertEquals(19.99, shirtPrice)
      assertEquals(2, shirtPrice.scale)

      def piString = "3.14159265"
      def pi = piString as BigDecimal
      assertEquals(BigDecimal.class, pi.class)
      assertEquals(3.14159265, pi)
      assertEquals(8, pi.scale)      
    } 

Null and Empty Collection Check

Groovy  has a nifty feature that checks a collection for null or an empty in one shot. So imagine you are checking the database for some trades. If they are present then do some processing. In Java, you would have check two things in the resulting collection: if its not null, and if its not empty. In Groovy, you just check the collection as in an if statement.

    void testNullOrEmptyCollection() {
      def tradeList = ["trade1", "trade2", "trade3"]
      def emptyTradeList = []
      def nullTradeList = null

      if (tradeList) {
        assertTrue(true)
      } else {
        fail("tradeList should return bool true")
      }

      if (emptyTradeList) {
        fail("emptyTradeList should return bool false")
      } else {
        assertTrue(true)
      }

      if (nullTradeList) {
        fail("nullTradeList should return bool false")
      } else {
        assertTrue(true)
      }
    } 

Identity Closure

Groovy is known for its expressive language and concise code. This essentially means that you can express more with less code. When setting attributes in Java, the language forces the developer to restate the variable context in order to access attributes. In groovy, the identity closure retains the object context and relieves you from restating the object again and again. In result, this gives slightly clearer code.

    class Person {
      String firstName
      int age
      String occupation
      String hometown
    }

    void testIdentityClosure() {
      def personMapAttributes = ["firstName": "Nirav", "age":33,
"occupation": "developer", "hometown":"Pittsburgh"]
      Person person = new Person()
      person.identity {
        firstName = personMapAttributes.name
        age = personMapAttributes.age
        occupation = personMapAttributes.occupation
        hometown = personMapAttributes.hometown
      }
      println person.dump()
    } 

Groovy Switch

In Java, switch statements can branch on primitive types. For anything complicated, you have to resort to ugly if/else statements or perhaps polymorphism.  In Groovy, you can switch on any type using the switch closure. The main switch item does not have to be one consistent type either, since Groovy is dynamic.

    void testGroovySwitch() {
      def hello = "hello"
      assertEquals("hello passed in", switchMethod(hello))

      def six = 6
      assertEquals("you passed in something between 5..8", switchMethod(six))

      def person = new Person()
      assertEquals("type person was passed in", switchMethod(person))
    }

    def switchMethod(item) {
      def result = ""
      switch ( item ) {
        case "hello":
          result = "hello passed in"
          break
        case 5..8:
          result = "you passed in something between 5..8"
          break
        case Person:
          result = "type person was passed in"
          break
        default:
          result = "No Matching Case"
      }
    } 

Conclusion

These shortcuts have come in handy for me. Hopefully they will for you as well.