Groovy

Implementation of programming language Groovy

Standard implementation of Groovy programming language.

Examples:

Hello, World!:

Example for versions Groovy 1.7, Sun Java 6, gcj 3.4.5
public class HelloWorld {
    public static void main(String[] args)
    {
        System.out.println("Hello, World!");
    }
}

Fibonacci numbers:

Example for versions Groovy 1.7, Sun Java 6, gcj 3.4.5

This example uses recursive definition of Fibonacci numbers.

public class Fibonacci {
    static int fibonacci(int n)
    {
        return (n<=2 ? 1 : fibonacci(n-1) + fibonacci(n-2));
    }
    public static void main(String[] args)
    {
        for (int n=1; n<=16; n++)
            System.out.print(fibonacci(n)+", ");
        System.out.println("...");
    }
}

Factorial:

Example for versions Groovy 1.7, Sun Java 6, gcj 3.4.5

This example uses iterative calculation of factorial and illustrates the use of built-in class BigInteger which allows to handle arbitrarily large integer numbers.

import java.math.BigInteger;

public class Factorial {
    public static void main(String[] args)
    {
        BigInteger f = BigInteger.ONE;
        System.out.println("0! = " + f);
        for (int n=1; n<=16; n++)
        {   f = f.multiply(BigInteger.valueOf(n));
            System.out.println( n + "! = " + f);
        }
    }
}

Factorial:

Example for versions Groovy 1.7, Sun Java 6, gcj 3.4.5

This example uses recursive factorial definition.

public class Factorial {
    static long factorial(int n)
    {
        return ( n==0 ? 1 : n*factorial(n-1) );
    }
    public static void main(String[] args)
    {
        for (int n=0; n<=16; n++)
            System.out.println(n+"! = "+factorial(n));
    }
}

Quadratic equation:

Example for versions Groovy 1.7, Sun Java 6, gcj 3.4.5

Java doesn’t provide complex numbers, so the calculations are done in real numbers with separate check for discriminant sign. This implementation allows to solve quadratic equations not only with integer coefficients but also with floating-point ones.

The coefficients are read from stream System.in, which allows only individual bytes to be read directly, so two wrapper classes InputStreamReader and BufferedReader are used to make reading more comfortable. The strings read from System.in are converted into double values using parseDouble method of class Double. In Java all input operations must be wrapped in try ... catch blocks to handle IOException — class of exceptions which are thrown by reading routines.

import java.util.*;
import java.io.*;

public class Quadratic {
    static String print(double real, double imag)
    {   if (Math.abs(imag)<1E-6)
            return ""+real;
        else 
            return "("+real+","+imag+")";
    }
    public static void main(String[] args)
    {   double A,B,C,D;
      try {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("A = ");
        A = Double.parseDouble(br.readLine());
        if (Math.abs(A)<1E-3)
        {   System.out.println("Not a quadratic equation.");
            return;
        }
        System.out.print("B = ");
        B = Double.parseDouble(br.readLine());
        System.out.print("C = ");
        C = Double.parseDouble(br.readLine());
      }
      catch (Exception e) {
        System.err.println("An error occured while reading input parameters.");
        return;
      }
        A = 2*A;
        D = B*B-2*A*C;
        if (Math.abs(D)<1E-3)
        {   System.out.println("x = "+(-B/A));
            return;
        }
        if (D>0)
            System.out.println("x1 = "+print((-B+Math.sqrt(D))/A, 0)+"\nx2 = "+print((-B-Math.sqrt(D))/A, 0));
        else
            System.out.println("x1 = "+print(-B/A,Math.sqrt(-D)/A)+"\nx2 = "+print(-B/A,-Math.sqrt(-D)/A));
    }
}

CamelCase:

Example for versions Groovy 1.7, Sun Java 6

This example uses Java regular expressions. A regular expression [a-zA-Z]+ describes any contiguous sequence of letters (in any case), surrounded with non-letter characters or ends of string. Classes Pattern and Matcher allow to create this regular expression and extract from the string all fragments which match it. For each such fragment, its first letter is converted to upper case, and the rest of it — to lower case. Finally, the resulting word is appended to StringBuffer variable which accumulates the result.

import java.util.regex.*;
import java.io.*;

public class CamelCase {
    public static void main(String[] args) {
      try {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Pattern p = Pattern.compile("[a-zA-Z]+");
        Matcher m = p.matcher(br.readLine());
        StringBuffer result = new StringBuffer();
        String word;
        while (m.find()) {
            word = m.group();
            result.append(word.substring(0, 1).toUpperCase() + word.substring(1).toLowerCase());
        }
        System.out.println(result.toString());
      } catch (Exception e) {
        System.err.println("An error occured while reading input string.");
      }
    }
} 

Hello, World!:

Example for versions Groovy 1.7
println "Hello, World!"