Discuss Groovy ”; Previous Next Groovy is an object oriented language which is based on Java platform. Groovy 1.0 was released in January 2, 2007 with Groovy 2.4 as the current major release. Groovy is distributed via the Apache License v 2.0. In this tutorial, we would explain all the fundamentals of Groovy and how to put it into practice. Print Page Previous Next Advertisements ”;
Groovy – Exception Handling ”; Previous Next Exception handling is required in any programming language to handle the runtime errors so that normal flow of the application can be maintained. Exception normally disrupts the normal flow of the application, which is the reason why we need to use Exception handling in our application. Exceptions are broadly classified into the following categories − Checked Exception − The classes that extend Throwable class except RuntimeException and Error are known as checked exceptions e.g.IOException, SQLException etc. Checked exceptions are checked at compile-time. One classical case is the FileNotFoundException. Suppose you had the following codein your application which reads from a file in E drive. class Example { static void main(String[] args) { File file = new File(“E://file.txt”); FileReader fr = new FileReader(file); } } if the File (file.txt) is not there in the E drive then the following exception will be raised. Caught: java.io.FileNotFoundException: E:file.txt (The system cannot find the file specified). java.io.FileNotFoundException: E:file.txt (The system cannot find the file specified). Unchecked Exception − The classes that extend RuntimeException are known as unchecked exceptions, e.g., ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc. Unchecked exceptions are not checked at compile-time rather they are checked at runtime. One classical case is the ArrayIndexOutOfBoundsException which happens when you try to access an index of an array which is greater than the length of the array. Following is a typical example of this sort of mistake. class Example { static void main(String[] args) { def arr = new int[3]; arr[5] = 5; } } When the above code is executed the following exception will be raised. Caught: java.lang.ArrayIndexOutOfBoundsException: 5 java.lang.ArrayIndexOutOfBoundsException: 5 Error − Error is irrecoverable e.g. OutOfMemoryError, VirtualMachineError, AssertionError etc. These are errors which the program can never recover from and will cause the program to crash. The following diagram shows how the hierarchy of exceptions in Groovy is organized. It’s all based on the hierarchy defined in Java. Catching Exceptions A method catches an exception using a combination of the try and catch keywords. A try/catch block is placed around the code that might generate an exception. try { //Protected code } catch(ExceptionName e1) { //Catch block } All of your code which could raise an exception is placed in the Protected code block. In the catch block, you can write custom code to handle your exception so that the application can recover from the exception. Let’s look at an example of the similar code we saw above for accessing an array with an index value which is greater than the size of the array. But this time let’s wrap our code in a try/catch block. Live Demo class Example { static void main(String[] args) { try { def arr = new int[3]; arr[5] = 5; } catch(Exception ex) { println(“Catching the exception”); } println(“Let”s move on after the exception”); } } When we run the above program, we will get the following result − Catching the exception Let”s move on after the exception From the above code, we wrap out faulty code in the try block. In the catch block we are just catching our exception and outputting a message that an exception has occurred. Multiple Catch Blocks One can have multiple catch blocks to handle multiple types of exceptions. For each catch block, depending on the type of exception raised you would write code to handle it accordingly. Let’s modify our above code to catch the ArrayIndexOutOfBoundsException specifically. Following is the code snippet. Live Demo class Example { static void main(String[] args) { try { def arr = new int[3]; arr[5] = 5; }catch(ArrayIndexOutOfBoundsException ex) { println(“Catching the Array out of Bounds exception”); }catch(Exception ex) { println(“Catching the exception”); } println(“Let”s move on after the exception”); } } When we run the above program, we will get the following result − Catching the Aray out of Bounds exception Let”s move on after the exception From the above code you can see that the ArrayIndexOutOfBoundsException catch block is caught first because it means the criteria of the exception. Finally Block The finally block follows a try block or a catch block. A finally block of code always executes, irrespective of occurrence of an Exception. Using a finally block allows you to run any cleanup-type statements that you want to execute, no matter what happens in the protected code. The syntax for this block is given below. try { //Protected code } catch(ExceptionType1 e1) { //Catch block } catch(ExceptionType2 e2) { //Catch block } catch(ExceptionType3 e3) { //Catch block } finally { //The finally block always executes. } Let’s modify our above code and add the finally block of code. Following is the code snippet. class Example { static void main(String[] args) { try { def arr = new int[3]; arr[5] = 5; } catch(ArrayIndexOutOfBoundsException ex) { println(“Catching the Array out of Bounds exception”); }catch(Exception ex) { println(“Catching the exception”); } finally { println(“The final block”); } println(“Let”s move on after the exception”); } } When we run the above program, we will get the following result − Catching the Array out of Bounds exception The final block Let”s move on after the exception Following are the Exception methods available in Groovy − public String getMessage() Returns a detailed message about the exception that has occurred. This message is initialized in the Throwable constructor. public Throwable getCause() Returns the cause of the exception as represented by a Throwable object. public String toString() Returns the name of the class concatenated with the result of getMessage() public void printStackTrace() Prints the result of toString() along with the stack trace to System.err, the error output stream. public StackTraceElement [] getStackTrace() Returns an array containing each element on the stack trace. The element at index 0 represents the top of the call stack, and the last element in the array represents the method at the bottom of the call stack. public Throwable fillInStackTrace() Fills the stack trace of this Throwable object with the current stack trace, adding to
Groovy – Decision Making ”; Previous Next Decision-making structures require that the programmer specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false. Sr.No. Statements & Description 1 if Statement The general working of this statement is that first a condition is evaluated in the if statement. If the condition is true, it then executes the statements. 2 if/else Statement The general working of this statement is that first a condition is evaluated in the if statement. If the condition is true it then executes the statements thereafter and stops before the else condition and exits out of the loop. If the condition is false it then executes the statements in the else statement block and then exits the loop. 3 Nested If Statement Sometimes there is a requirement to have multiple if statement embedded inside of each other. 4 Switch Statement Sometimes the nested if-else statement is so common and is used so often that an easier statement was designed called the switch statement. 5 Nested Switch Statement It is also possible to have a nested set of switch statements. Print Page Previous Next Advertisements ”;
Groovy – Dates & Times ”; Previous Next The class Date represents a specific instant in time, with millisecond precision. The Date class has two constructors as shown below. Date() Syntax public Date() Parameters − None. Return Value Allocates a Date object and initializes it so that it represents the time at which it was allocated, measured to the nearest millisecond. Example Following is an example of the usage of this method − Live Demo class Example { static void main(String[] args) { Date date = new Date(); // display time and date using toString() System.out.println(date.toString()); } } When we run the above program, we will get the following result. The following output will give you the current date and time − Thu Dec 10 21:31:15 GST 2015 Date (long millisec) Syntax public Date(long millisec) Parameters Millisec – The number of millisecconds to specify since the standard base time. Return Value − Allocates a Date object and initializes it to represent the specified number of milliseconds since the standard base time known as “the epoch”, namely January 1, 1970, 00:00:00 GMT. Example Following is an example of the usage of this method − Live Demo class Example { static void main(String[] args) { Date date = new Date(100); // display time and date using toString() System.out.println(date.toString()); } } When we run the above program, we will get the following result − Thu Jan 01 04:00:00 GST 1970 Following are the given methods of the Date class. In all methods of class Date that accept or return year, month, date, hours, minutes, and seconds values, the following representations are used − A year y is represented by the integer y – 1900. A month is represented by an integer from 0 to 11; 0 is January, 1 is February, and so forth; thus 11 is December. A date (day of month) is represented by an integer from 1 to 31 in the usual manner. An hour is represented by an integer from 0 to 23. Thus, the hour from midnight to 1 a.m. is hour 0, and the hour from noon to 1 p.m. is hour 12. A minute is represented by an integer from 0 to 59 in the usual manner. A second is represented by an integer from 0 to 61. Sr.No. Methods & Description 1 after() Tests if this date is after the specified date. 2 equals() Compares two dates for equality. The result is true if and only if the argument is not null and is a Date object that represents the same point in time, to the millisecond, as this object. 3 compareTo() Compares two Dates for ordering. 4 toString() Converts this Date object to a String 5 before() Tests if this date is before the specified date. 6 getTime() Returns the number of milliseconds since January 1, 1970, 00:00:00 GMT represented by this Date object. 7 setTime() Sets this Date object to represent a point in time that is time milliseconds after January 1, 1970 00:00:00 GMT. Print Page Previous Next Advertisements ”;
Groovy – Meta Object Programming ”; Previous Next Meta object programming or MOP can be used to invoke methods dynamically and also create classes and methods on the fly. So what does this mean? Let’s consider a class called Student, which is kind of an empty class with no member variables or methods. Suppose if you had to invoke the following statements on this class. Def myStudent = new Student() myStudent.Name = ”Joe”; myStudent.Display() Now in meta object programming, even though the class does not have the member variable Name or the method Display(), the above code will still work. How can this work? Well, for this to work out, one has to implement the GroovyInterceptable interface to hook into the execution process of Groovy. Following are the methods available for this interface. Public interface GroovyInterceptable { Public object invokeMethod(String methodName, Object args) Public object getproperty(String propertyName) Public object setProperty(String propertyName, Object newValue) Public MetaClass getMetaClass() Public void setMetaClass(MetaClass metaClass) } So in the above interface description, suppose if you had to implement the invokeMethod(), it would be called for every method which either exists or does not exist. Missing Properties So let’s look an example of how we can implement Meta Object Programming for missing Properties. The following keys things should be noted about the following code. The class Student has no member variable called Name or ID defined. The class Student implements the GroovyInterceptable interface. There is a parameter called dynamicProps which will be used to hold the value of the member variables which are created on the fly. The methods getproperty and setproperty have been implemented to get and set the values of the property’s of the class at runtime. Live Demo class Example { static void main(String[] args) { Student mst = new Student(); mst.Name = “Joe”; mst.ID = 1; println(mst.Name); println(mst.ID); } } class Student implements GroovyInterceptable { protected dynamicProps=[:] void setProperty(String pName,val) { dynamicProps[pName] = val } def getProperty(String pName) { dynamicProps[pName] } } The output of the following code would be − Joe 1 Missing methods So let’s look an example of how we can implement Meta Object Programming for missing Properties. The following keys things should be noted about the following code − The class Student now implememts the invokeMethod method which gets called irrespective of whether the method exists or not. Live Demo class Example { static void main(String[] args) { Student mst = new Student(); mst.Name = “Joe”; mst.ID = 1; println(mst.Name); println(mst.ID); mst.AddMarks(); } } class Student implements GroovyInterceptable { protected dynamicProps = [:] void setProperty(String pName, val) { dynamicProps[pName] = val } def getProperty(String pName) { dynamicProps[pName] } def invokeMethod(String name, Object args) { return “called invokeMethod $name $args” } } The output of the following codewould be shown below. Note that there is no error of missing Method Exception even though the method Display does not exist. Joe 1 Metaclass This functionality is related to the MetaClass implementation. In the default implementation you can access fields without invoking their getters and setters. The following example shows how by using the metaClass function we are able to change the value of the private variables in the class. Live Demo class Example { static void main(String[] args) { Student mst = new Student(); println mst.getName() mst.metaClass.setAttribute(mst, ”name”, ”Mark”) println mst.getName() } } class Student { private String name = “Joe”; public String getName() { return this.name; } } The output of the following code would be − Joe Mark Method Missing Groovy supports the concept of methodMissing. This method differs from invokeMethod in that it is only invoked in case of a failed method dispatch, when no method can be found for the given name and/or the given arguments. The following example shows how the methodMissing can be used. Live Demo class Example { static void main(String[] args) { Student mst = new Student(); mst.Name = “Joe”; mst.ID = 1; println(mst.Name); println(mst.ID); mst.AddMarks(); } } class Student implements GroovyInterceptable { protected dynamicProps = [:] void setProperty(String pName, val) { dynamicProps[pName] = val } def getProperty(String pName) { dynamicProps[pName] } def methodMissing(String name, def args) { println “Missing method” } } The output of the following code would be − Joe 1 Missing method Print Page Previous Next Advertisements ”;
Groovy – Closures ”; Previous Next A closure is a short anonymous block of code. It just normally spans a few lines of code. A method can even take the block of code as a parameter. They are anonymous in nature. Following is an example of a simple closure and what it looks like. Live Demo class Example { static void main(String[] args) { def clos = {println “Hello World”}; clos.call(); } } In the above example, the code line – {println “Hello World”} is known as a closure. The code block referenced by this identifier can be executed with the call statement. When we run the above program, we will get the following result − Hello World Formal parameters in closures Closures can also contain formal parameters to make them more useful just like methods in Groovy. Live Demo class Example { static void main(String[] args) { def clos = {param->println “Hello ${param}”}; clos.call(“World”); } } In the above code example, notice the use of the ${param } which causes the closure to take a parameter. When calling the closure via the clos.call statement we now have the option to pass a parameter to the closure. When we run the above program, we will get the following result − Hello World The next illustration repeats the previous example and produces the same result, but shows that an implicit single parameter referred to as it can be used. Here ‘it’ is a keyword in Groovy. class Example { static void main(String[] args) { def clos = {println “Hello ${it}”}; clos.call(“World”); } } When we run the above program, we will get the following result − Hello World Closures and Variables More formally, closures can refer to variables at the time the closure is defined. Following is an example of how this can be achieved. Live Demo class Example { static void main(String[] args) { def str1 = “Hello”; def clos = {param -> println “${str1} ${param}”} clos.call(“World”); // We are now changing the value of the String str1 which is referenced in the closure str1 = “Welcome”; clos.call(“World”); } } In the above example, in addition to passing a parameter to the closure, we are also defining a variable called str1. The closure also takes on the variable along with the parameter. When we run the above program, we will get the following result − Hello World Welcome World Using Closures in Methods Closures can also be used as parameters to methods. In Groovy, a lot of the inbuilt methods for data types such as Lists and collections have closures as a parameter type. The following example shows how a closure can be sent to a method as a parameter. Live Demo class Example { def static Display(clo) { // This time the $param parameter gets replaced by the string “Inner” clo.call(“Inner”); } static void main(String[] args) { def str1 = “Hello”; def clos = { param -> println “${str1} ${param}” } clos.call(“World”); // We are now changing the value of the String str1 which is referenced in the closure str1 = “Welcome”; clos.call(“World”); // Passing our closure to a method Example.Display(clos); } } In the above example, We are defining a static method called Display which takes a closure as an argument. We are then defining a closure in our main method and passing it to our Display method as a parameter. When we run the above program, we will get the following result − Hello World Welcome World Welcome Inner Closures in Collections and String Several List, Map, and String methods accept a closure as an argument. Let’s look at example of how closures can be used in these data types. Using Closures with Lists The following example shows how closures can be used with Lists. In the following example we are first defining a simple list of values. The list collection type then defines a function called .each. This function takes on a closure as a parameter and applies the closure to each element of the list. Live Demo class Example { static void main(String[] args) { def lst = [11, 12, 13, 14]; lst.each {println it} } } When we run the above program, we will get the following result − 11 12 13 14 Using Closures with Maps The following example shows how closures can be used with Maps. In the following example we are first defining a simple Map of key value items. The map collection type then defines a function called .each. This function takes on a closure as a parameter and applies the closure to each key-value pair of the map. Live Demo class Example { static void main(String[] args) { def mp = [“TopicName” : “Maps”, “TopicDescription” : “Methods in Maps”] mp.each {println it} mp.each {println “${it.key} maps to: ${it.value}”} } } When we run the above program, we will get the following result − TopicName = Maps TopicDescription = Methods in Maps TopicName maps to: Maps TopicDescription maps to: Methods in Maps Often, we may wish to iterate across the members of a collection and apply some logic only when the element meets some criterion. This is readily handled with a conditional statement in the closure. Live Demo class Example { static void main(String[] args) { def lst = [1,2,3,4]; lst.each {println it} println(“The list will only display those numbers which are divisible by 2”) lst.each{num -> if(num % 2 == 0) println num} } } The above example shows the conditional if(num % 2 == 0) expression being used in the closure which is used to check if each item in the list is divisible by 2. When we run the above program, we will get the following result − 1 2 3 4 The list will only display those numbers which are divisible by 2. 2 4 Methods used with Closures The closures themselves provide some methods. Sr.No. Methods & Description 1 find() The find method finds the first value in a collection that
Groovy – Generics ”; Previous Next Generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods. Much like the more familiar formal parameters used in method declarations, type parameters provide a way for you to re-use the same code with different inputs. The difference is that the inputs to formal parameters are values, while the inputs to type parameters are types. Generic for Collections The collections classes such as the List class can be generalized so that only collections of that type are accepted in the application. An example of the generalized ArrayList is shown below. What the following statement does is that it only accepts list items which are of the type string − List<String> list = new ArrayList<String>(); In the following code example, we are doing the following − Creating a Generalized ArrayList collection which will hold only Strings. Add 3 strings to the list. For each item in the list, printing the value of the strings. Live Demo class Example { static void main(String[] args) { // Creating a generic List collection List<String> list = new ArrayList<String>(); list.add(“First String”); list.add(“Second String”); list.add(“Third String”); for(String str : list) { println(str); } } } The output of the above program would be − First String Second String Third String Generalized Classes The entire class can also be generalized. This makes the class more flexible in accepting any types and working accordingly with those types. Let’s look at an example of how we can accomplish this. In the following program, we are carrying out the following steps − We are creating a class called ListType. Note the <T> keywords placed in front of the class definition. This tells the compiler that this class can accept any type. So when we declare an object of this class, we can specify a type during the the declaration and that type would be replaced in the placeholder <T> The generic class has simple getter and setter methods to work with the member variable defined in the class. In the main program, notice that we are able to declare objects of the ListType class, but of different types. The first one is of the type Integer and the second one is of the type String. Live Demo class Example { static void main(String[] args) { // Creating a generic List collection ListType<String> lststr = new ListType<>(); lststr.set(“First String”); println(lststr.get()); ListType<Integer> lstint = new ListType<>(); lstint.set(1); println(lstint.get()); } } public class ListType<T> { private T localt; public T get() { return this.localt; } public void set(T plocal) { this.localt = plocal; } } The output of the above program would be − First String 1 Print Page Previous Next Advertisements ”;
Groovy – Useful Resources ”; Previous Next The following resources contain additional information on Groovy. Please use them to get more in-depth knowledge on this topic. Useful Video Courses Groovy Fundamentals Course For Testers Most Popular 53 Lectures 8 hours Krishna Sakinala More Detail Practical Guide to Jenkins 42 Lectures 2 hours Chaitanya Allidona More Detail Groovy Programming Fundamentals for Java Developers 49 Lectures 2.5 hours Packt Publishing More Detail Complete JanusGraph Course For Beginners 21 Lectures 2 hours Sanil Bagzai More Detail Print Page Previous Next Advertisements ”;
Groovy – Quick Guide ”; Previous Next Groovy – Overview Groovy is an object oriented language which is based on Java platform. Groovy 1.0 was released in January 2, 2007 with Groovy 2.4 as the current major release. Groovy is distributed via the Apache License v 2.0. Features of Groovy Groovy has the following features − Support for both static and dynamic typing. Support for operator overloading. Native syntax for lists and associative arrays. Native support for regular expressions. Native support for various markup languages such as XML and HTML. Groovy is simple for Java developers since the syntax for Java and Groovy are very similar. You can use existing Java libraries. Groovy extends the java.lang.Object. The official website for Groovy is http://www.groovy-lang.org/ Groovy – Environment There are a variety of ways to get the Groovy environment setup. Binary download and installation − Go to the link www.groovy-lang.org/download.html to get the Windows Installer section. Click on this option to start the download of the Groovy installer. Once you launch the installer, follow the steps given below to complete the installation. Step 1 − Select the language installer. Step 2 − Click the Next button in the next screen. Step 3 − Click the ‘I Agree’ button. Step 4 − Accept the default components and click the Next button. Step 5 − Choose the appropriate destination folder and then click the Next button. Step 6 − Click the Install button to start the installation. Step 7 − Once the installation is complete, click the Next button to start the configuration. Step 8 − Choose the default options and click the Next button. Step 9 − Accept the default file associations and click the Next button. Step 10 − Click the Finish button to complete the installation. Once the above steps are followed, you can then start the groovy shell which is part of the Groovy installation that helps in testing our different aspects of the Groovy language without the need of having a full-fledged integrated development environment for Groovy. This can be done by running the command groovysh from the command prompt. If you want to include the groovy binaries as part of you maven or gradle build, you can add the following lines Gradle ”org.codehaus.groovy:groovy:2.4.5” Maven <groupId>org.codehaus.groovy</groupId> <artifactId>groovy</artifactId> <version>2.4.5</version> Groovy – Basic Syntax In order to understand the basic syntax of Groovy, let’s first look at a simple Hello World program. Creating Your First Hello World Program Creating your first hello world program is as simple as just entering the following code line − Live Demo class Example { static void main(String[] args) { // Using a simple println statement to print output to the console println(”Hello World”); } } When we run the above program, we will get the following result − Hello World Import Statement in Groovy The import statement can be used to import the functionality of other libraries which can be used in your code. This is done by using the import keyword. The following example shows how to use a simple import of the MarkupBuilder class which is probably one of the most used classes for creating HTML or XML markup. import groovy.xml.MarkupBuilder def xml = new MarkupBuilder() By default, Groovy includes the following libraries in your code, so you don’t need to explicitly import them. import java.lang.* import java.util.* import java.io.* import java.net.* import groovy.lang.* import groovy.util.* import java.math.BigInteger import java.math.BigDecimal Tokens in Groovy A token is either a keyword, an identifier, a constant, a string literal, or a symbol. println(“Hello World”); In the above code line, there are two tokens, the first is the keyword println and the next is the string literal of “Hello World”. Comments in Groovy Comments are used to document your code. Comments in Groovy can be single line or multiline. Single line comments are identified by using the // at any position in the line. An example is shown below − class Example { static void main(String[] args) { // Using a simple println statement to print output to the console println(”Hello World”); } } Multiline comments are identified with /* in the beginning and */ to identify the end of the multiline comment. class Example { static void main(String[] args) { /* This program is the first program This program shows how to display hello world */ println(”Hello World”); } } Semicolons Unlike in the Java programming language, it is not mandatory to have semicolons after the end of every statement, It is optional. Live Demo class Example { static void main(String[] args) { def x = 5 println(”Hello World”); } } If you execute the above program, both statements in the main method don”t generate any error. Identifiers Identifiers are used to define variables, functions or other user defined variables. Identifiers start with a letter, a dollar or an underscore. They cannot start with a number. Here are some examples of valid identifiers − def employeename def student1 def student_name where def is a keyword used in Groovy to define an identifier. Here is a code example of how an identifier can be used in our Hello World program. class Example { static void main(String[] args) { // One can see the use of a semi-colon after each statement def x = 5; println(”Hello World”); } } In the above example, the variable x is used as an identifier. Keywords Keywords as the name suggest are special words which are reserved in the Groovy Programming language. The following table lists the keywords which are defined in Groovy. as assert break case catch class const continue def default do else enum extends false Finally for goto if implements import in instanceof interface new pull package return super switch this throw throws trait true try while Whitespaces Whitespace is the term used in a programming language such as Java and Groovy to describe blanks, tabs, newline characters and comments. Whitespace separates one part of a statement from another and enables the compiler to identify
Groovy – Regular Expressions ”; Previous Next A regular expression is a pattern that is used to find substrings in text. Groovy supports regular expressions natively using the ~”regex” expression. The text enclosed within the quotations represent the expression for comparison. For example we can create a regular expression object as shown below − def regex = ~”Groovy” When the Groovy operator =~ appears as a predicate (expression returning a Boolean) in if and while statements (see Chapter 8), the String operand on the left is matched against the regular expression operand on the right. Hence, each of the following delivers the value true. When defining regular expression, the following special characters can be used − There are two special positional characters that are used to denote the beginning and end of a line: caret (∧) and dollar sign ($). Regular expressions can also include quantifiers. The plus sign (+) represents one or more times, applied to the preceding element of the expression. The asterisk (*) is used to represent zero or more occurrences. The question mark (?) denotes zero or once. The metacharacter { and } is used to match a specific number of instances of the preceding character. In a regular expression, the period symbol (.) can represent any character. This is described as the wildcard character. A regular expression may include character classes. A set of characters can be given as a simple sequence of characters enclosed in the metacharacters [and] as in [aeiou]. For letter or number ranges, you can use a dash separator as in [a–z] or [a–mA–M]. The complement of a character class is denoted by a leading caret within the square rackets as in [∧a–z] and represents all characters other than those specified. Some examples of Regular expressions are given below ”Groovy” =~ ”Groovy” ”Groovy” =~ ”oo” ”Groovy” ==~ ”Groovy” ”Groovy” ==~ ”oo” ”Groovy” =~ ”∧G” ‘Groovy” =~ ”G$” ‘Groovy” =~ ”Gro*vy” ”Groovy” =~ ”Gro{2}vy” Print Page Previous Next Advertisements ”;