Groovy Interview Questions with Answers

// Hello World in Groovy
println "Hello, World!"

// Data Types in Groovy
def age = 25
def salary = 50000.50
def pi = 3.14159265358979
def grade = 'A' as char
def isActive = true
def name = "Alice"
def price = 99.99

println "Age: $age"
println "Salary: $salary"
println "Pi: $pi"
println "Grade: $grade"
println "Active: $isActive"
println "Name: $name"
println "Price: $price"

// Variables and Constants in Groovy
def x = 10
final double PI = 3.14159
def val = 3.14
def str = "Hello"
def counter = 0

println "x = $x"
println "PI = $PI"
println "val = $val"
println "str = $str"
println "counter = $counter"

// Lists and Ranges in Groovy
def list = [1, 2, 3, 4, 5]
println list[0]
println list[2]

def range = 1..10
println range.toList()

// List operations
list << 6
list += [7, 8]
println list

// 2D list
def matrix = [[1,2,3], [4,5,6], [7,8,9]]
println matrix[1][1]

// Maps in Groovy
def scores = [
    Alice: 95,
    Bob: 87,
    Carol: 92
]

println "Alice: ${scores.Alice}"
println "Bob: ${scores['Bob']}"

scores.Dave = 88

if (scores.containsKey('Eve')) {
    println "Eve: ${scores.Eve}"
} else {
    println "Eve not found"
}

scores.each { key, value ->
    println "$key: $value"
}

scores.remove('Bob')
println scores

// Closures in Groovy
def square = { x -> x * x }
println square(5)

def multiply = { x, y -> x * y }
println multiply(3, 4)

def applyToEach = { list, closure ->
    list.collect(closure)
}
def result = applyToEach([1,2,3,4], square)
println result

// Currying
def add = { a, b -> a + b }
def addFive = add.curry(5)
println addFive(10)

// Classes and Objects in Groovy
class Person {
    String name
    int age
    String email
}

def p1 = new Person(name: "Alice", age: 25, email: "alice@email.com")
println p1.name
println p1.age

class Rectangle {
    double width
    double height
    
    double area() { width * height }
    double perimeter() { 2 * (width + height) }
}

def rect = new Rectangle(width: 4.0, height: 6.0)
println "Area: ${rect.area()}"
println "Perimeter: ${rect.perimeter()}"

// Traits in Groovy
trait Logger {
    void log(String msg) {
        println "[LOG] $msg"
    }
}

class UserService implements Logger {
    void createUser(String name) {
        log "Creating user: $name"
        println "User created: $name"
    }
}

def service = new UserService()
service.createUser("Alice")

// Inheritance in Groovy
class Animal {
    String name
    void speak() { println "Animal speaks" }
}

class Dog extends Animal {
    @Override
    void speak() { println "Woof!" }
}

class Cat extends Animal {
    @Override
    void speak() { println "Meow!" }
}

def animals = [new Dog(name: "Rex"), new Cat(name: "Whiskers")]
animals.each { it.speak() }

// Abstract Classes and Interfaces
interface Flyable {
    void fly()
}

abstract class Vehicle {
    abstract void start()
}

class Car extends Vehicle implements Flyable {
    @Override
    void start() { println "Car engine starts" }
    @Override
    void fly() { println "Car cannot fly" }
}

def car = new Car()
car.start()
car.fly()

// String and GString
def name = "Alice"
def greeting = "Hello, $name"
println greeting

// Triple-quoted strings
def multiline = """This is
a multi-line
string"""
println multiline

// Slashy string (regex friendly)
def regex = /\d+/
println regex

// String methods
def str = "Groovy"
println str.toUpperCase()
println str.reverse()
println str.padLeft(10, '*')

// Operators: Elvis, Safe Navigation, Spread
def user = null
def name = user?.name ?: "Guest"
println name

def list = [1, 2, 3]
def sum = list*.toInteger().sum()
println sum

// Spread operator
def nums = [1,2,3,4]
def newList = [0, *nums, 5]
println newList

// Regular Expressions
def text = "The quick brown fox"
def pattern = ~/\b\w{3}\b/
def matches = (text =~ pattern).collect()
println matches

// Find and replace
def replaced = text.replaceAll(/quick/, "slow")
println replaced

// Matcher
def matcher = (text =~ /(\w+)/)
while (matcher.find()) {
    println matcher.group(1)
}

// Exception Handling
try {
    def result = 10 / 0
} catch (ArithmeticException e) {
    println "Division by zero: ${e.message}"
} finally {
    println "Finally block"
}

// Custom exception
class ValidationException extends Exception {
    ValidationException(String msg) { super(msg) }
}

try {
    throw new ValidationException("Invalid data")
} catch (ValidationException e) {
    println e.message
}

// File I/O
def file = new File("example.txt")

// Write
file.withWriter { writer ->
    writer.writeLine "Hello, World!"
}

// Read
file.withReader { reader ->
    reader.eachLine { line ->
        println "Read: $line"
    }
}

// Using text property
def content = file.text
println content

// Delete
file.delete()

// JSON in Groovy
import groovy.json.JsonOutput
import groovy.json.JsonSlurper

def data = [
    name: "Alice",
    age: 25,
    email: "alice@email.com"
]

def json = JsonOutput.toJson(data)
println json

def pretty = JsonOutput.prettyPrint(json)
println pretty

// Parse JSON
def slurper = new JsonSlurper()
def parsed = slurper.parseText(json)
println parsed.name

// XML with Groovy
import groovy.xml.MarkupBuilder
import groovy.xml.XmlSlurper

def writer = new StringWriter()
def builder = new MarkupBuilder(writer)

builder.person(id: 1) {
    name "Alice"
    age 25
    email "alice@email.com"
}

def xml = writer.toString()
println xml

// Parse XML
def root = new XmlSlurper().parseText(xml)
println root.name.text()
println root.@id

// Builders in Groovy (MarkupBuilder, JsonOutput)
import groovy.json.JsonBuilder
import groovy.xml.MarkupBuilder

// JSON builder
def jsonBuilder = new JsonBuilder()
jsonBuilder {
    person {
        name "Bob"
        age 30
        email "bob@email.com"
    }
}
println jsonBuilder.toPrettyString()

// MarkupBuilder (XML)
def sw = new StringWriter()
def xmlBuilder = new MarkupBuilder(sw)
xmlBuilder.books {
    book(id: 1) {
        title "Groovy in Action"
        author "Dierk König"
    }
}
println sw.toString()

// Groovy SQL (simplified)
import groovy.sql.Sql

def url = "jdbc:h2:mem:test"
def sql = Sql.newInstance(url, "org.h2.Driver")

sql.execute "CREATE TABLE users (id INT, name VARCHAR)"
sql.execute "INSERT INTO users VALUES (1, 'Alice')"

def rows = sql.rows("SELECT * FROM users")
rows.each { println "$it.id: $it.name" }

// Using withTransaction
sql.withTransaction {
    sql.execute "INSERT INTO users VALUES (2, 'Bob')"
}

sql.close()

// HTTP Client with Groovy (using HttpURLConnection)
def url = new URL("https://jsonplaceholder.typicode.com/posts/1")
def conn = url.openConnection()
conn.requestMethod = "GET"

if (conn.responseCode == 200) {
    def content = conn.content.text
    println content
} else {
    println "Error: ${conn.responseCode}"
}

// POST request
def postUrl = new URL("https://jsonplaceholder.typicode.com/posts")
def postConn = postUrl.openConnection()
postConn.requestMethod = "POST"
postConn.doOutput = true
postConn.setRequestProperty("Content-Type", "application/json")

def payload = '{"title":"Groovy","body":"Hello","userId":1}'
postConn.outputStream.withWriter { writer ->
    writer.write(payload)
}

if (postConn.responseCode == 201) {
    def response = postConn.content.text
    println response
}

// Metaprogramming with ExpandoMetaClass
String.metaClass.reverseWords = { ->
    delegate.split(' ').reverse().join(' ')
}

def msg = "Hello World"
println msg.reverseWords()

// Add property
Integer.metaClass.doubleValue = { -> delegate * 2 }
println 5.doubleValue()

// methodMissing and propertyMissing
class Dynamic {
    def propertyMissing(String name) { "Property $name not found" }
    def methodMissing(String name, args) { "Method $name called with $args" }
}

def d = new Dynamic()
println d.someProp
println d.someMethod(1,2,3)

// Groovy JDK enhancements
def list = [1, 2, 3, 4]
println list.sum()
println list.average()
println list.max()
println list.min()

def text = "Groovy"
println text.center(10)
println text.truncate(3)

def map = [a:1, b:2]
println map.subMap(['a'])

// Ranges and Switch
def range = 1..10
range.each { println it }

// Switch with ranges
def age = 25
switch (age) {
    case 0..17: println "Minor"; break
    case 18..64: println "Adult"; break
    default: println "Senior"
}

// Groovy Truth (coercion to boolean)
def list = []
if (list) println "Non-empty" else println "Empty"

def map = [:]
if (map) println "Non-empty" else println "Empty"

def num = 0
if (num) println "Non-zero" else println "Zero"

def str = ""
if (str) println "Non-empty" else println "Empty"

// Groovy Interpolation with Strings
def x = 10
def y = 20
def sum = "Sum: ${x + y}"
println sum

// Triple single quotes (no interpolation)
def raw = '''This is a raw string: $x'''
println raw

// Interpolation in GString
def groovy = "Groovy"
def result = "I love $groovy"
println result

// Working with Dates and Times
import java.time.*

def now = LocalDateTime.now()
println now

def future = now.plusDays(5)
println future

def formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")
println now.format(formatter)

// Groovy Date enhancements (legacy)
def date = new Date()
println date[Calendar.YEAR]

// Collect, Find, Each
def nums = [1,2,3,4,5]
def doubled = nums.collect { it * 2 }
println doubled

def even = nums.findAll { it % 2 == 0 }
println even

def firstEven = nums.find { it % 2 == 0 }
println firstEven

nums.each { println "Number: $it" }

// GroupBy and CountBy
def people = [
    [name:"Alice", age:25, city:"NYC"],
    [name:"Bob", age:30, city:"LA"],
    [name:"Carol", age:25, city:"NYC"]
]

def byCity = people.groupBy { it.city }
byCity.each { city, list -> println "$city: $list" }

def byAge = people.countBy { it.age }
println byAge

// Inject (reduce)
def numbers = 1..5
def product = numbers.inject(1) { acc, val -> acc * val }
println product

def sum = numbers.inject(0) { acc, val -> acc + val }
println sum

// Custom Annotations and AST Transformations
import groovy.transform.*

@ToString
class Product {
    String name
    double price
}

@Canonical
class User {
    String name
    int age
}

def p = new Product(name: "Laptop", price: 999.99)
println p

def u = new User("Alice", 25)
println u

// Groovy Console and Script
// Evaluate dynamic script
def script = "return 3 + 4"
def result = new GroovyShell().evaluate(script)
println result

// Binding
def binding = new Binding()
binding.setVariable("x", 10)
def shell = new GroovyShell(binding)
println shell.evaluate("x * 2")

// Groovy Categories
class StringExtensions {
    static String reverse(String self) { self.reverse() }
}

use (StringExtensions) {
    def msg = "Hello"
    println msg.reverse()
}

// Groovy XML Slurper with Namespace
def xml = '''
<ns:book xmlns:ns="http://example.org">
    <ns:title>Groovy</ns:title>
</ns:book>
'''

def books = new XmlSlurper().parseText(xml)
println books.'ns:title'.text()

// Groovy Grape (Dependency Management)
@Grab('org.apache.commons:commons-lang3:3.12.0')
import org.apache.commons.lang3.StringUtils

println StringUtils.capitalize("groovy")

// Groovy Observable List
import groovy.util.ObservableList

def list = new ObservableList([1,2,3])
list.addPropertyChangeListener { evt ->
    println "Change: ${evt.propertyName} old=${evt.oldValue} new=${evt.newValue}"
}
list << 4

// Groovy BeanBuilder
import groovy.util.BeanBuilder

def builder = new BeanBuilder()
def bean = builder.beans {
    person(Person) {
        name = "Alice"
        age = 25
    }
}
def context = builder.createApplicationContext()
def p = context.getBean("person")
println p.name

// Groovy with Java Interop
import java.util.ArrayList

def list = new ArrayList()
list.add(1)
list.add(2)
println list

// Using Java libraries seamlessly
import java.util.concurrent.Executors
def executor = Executors.newFixedThreadPool(2)
executor.submit { println "Thread" }
executor.shutdown()

// Groovy Power Assert
def list = [1,2,3]
assert list.size() == 3
assert list.contains(2)

// Power assert shows detailed info on failure
try {
    assert list.size() == 2
} catch (AssertionError e) {
    println e.message
}

// Groovy GDK File Enhancements
import groovy.io.FileType

def dir = new File(".")
dir.eachFileRecurse(FileType.FILES) { file ->
    println "File: $file.name"
}

// Copy
new File("source.txt").withReader { r ->
    new File("dest.txt").withWriter { w ->
        w << r
    }
}

// Groovy ConfigSlurper
import groovy.util.ConfigSlurper

def configText = '''
app {
    name = "MyApp"
    version = "1.0"
}
'''
def config = new ConfigSlurper().parse(configText)
println config.app.name

// Groovy Eval with variables
def binding = new Binding()
binding.setVariable("a", 5)
binding.setVariable("b", 3)
def shell = new GroovyShell(binding)
println shell.evaluate("a + b")

// Groovy AST Transforms (Singleton)
import groovy.transform.Singleton

@Singleton
class Config {
    String env = "production"
}

def c1 = Config.instance
def c2 = Config.instance
println c1.is(c2) // true

// Groovy Tuple
def t = new Tuple(1, "Hello", 3.14)
println t[0]
println t[1]
println t.size

// Groovy Named Arguments and Map Coercion
class Person {
    String name
    int age
}

def p = new Person(name: "Alice", age: 25)
println p

def map = [name: "Bob", age: 30]
def p2 = map as Person
println p2

// Groovy Default Parameter Values
def greet(String name = "Guest") {
    println "Hello, $name"
}

greet()
greet("Alice")

// Groovy Mixed-in Types (using @Mixin) – deprecated but still
class MyMixin {
    def extraMethod() { "extra" }
}

@Mixin(MyMixin)
class MyClass { }

def obj = new MyClass()
println obj.extraMethod()

// Groovy with Automatic Resource Management (ARM)
new File("test.txt").withWriter { writer ->
    writer.writeLine "Hello"
}

// Or using withCloseable for any AutoCloseable
def reader = new StringReader("sample")
reader.withReader { r ->
    println r.text
}

// Groovy Enumeration
enum Color {
    RED, GREEN, BLUE
}

def c = Color.GREEN
println c
switch (c) {
    case Color.RED: println "red"; break
    case Color.GREEN: println "green"; break
    default: println "other"
}

// Groovy Thread.start
Thread.start {
    println "Thread running"
}
sleep 1000

// Groovy with GPars (concurrency)
@Grab('org.codehaus.gpars:gpars:1.2.1')
import groovyx.gpars.GParsPool

def list = [1,2,3,4,5]
GParsPool.withPool {
    def result = list.collectParallel { it * it }
    println result
}

// Groovy TimedCache
import groovy.util.Timeout

def cache = new Timeout(1000) // 1 second
cache.put("key", "value")
println cache.get("key")
sleep 1500
println cache.get("key") // null

// Groovy Observe pattern
import groovy.util.ObservableList
import groovy.util.ObservableMap

def list = new ObservableList([1,2])
list.addPropertyChangeListener { e ->
    println "Change: $e"
}
list << 3

// Groovy StringEscapeUtils
@Grab('org.apache.commons:commons-text:1.9')
import org.apache.commons.text.StringEscapeUtils

def html = "<div>Hello</div>"
def escaped = StringEscapeUtils.escapeHtml4(html)
println escaped

// Groovy Bean Property access via metaClass
class User {
    String name
}

def u = new User()
u.metaClass.email = "alice@email.com"
println u.email

// Groovy Interceptable (AOP)
import groovy.lang.Interceptable

class MyInterceptor implements Interceptable {
    def beforeInvoke(String name, Object[] args) {
        println "Before $name"
    }
}

class Test {
    def method() { "test" }
}

def t = new Test()
t.metaClass.invokeMethod = { String name, args ->
    println "Intercepting $name"
    def original = delegate.metaClass.getMetaMethod(name, args)
    original?.invoke(delegate, args)
}
println t.method()

// Groovy with JMX
import javax.management.*

def server = ManagementFactory.platformMBeanServer
def name = ObjectName.getInstance("com.example:type=Hello")
server.registerMBean(new Object() { def sayHi() { "Hi" } }, name)
println server.getAttribute(name, "SayHi")

// Groovy Data Types: BigInteger, BigDecimal
def bigInt = new BigInteger("12345678901234567890")
def bigDec = new BigDecimal("12345.6789")
println bigInt + 100
println bigDec + 0.001

// Groovy Char and Boolean handling
def flag = true
def ch = 'A'
if (flag) println "Yes"
println ch.toLowerCase()

// Groovy using @ToString and @EqualsAndHashCode
import groovy.transform.*

@ToString(includeNames=true)
@EqualsAndHashCode
class Product {
    String name
    double price
}

def p1 = new Product(name: "Apple", price: 1.2)
def p2 = new Product(name: "Apple", price: 1.2)
println p1
println p1 == p2

// Groovy with @Immutable
@Immutable
class Point {
    int x, y
}

def p = new Point(1, 2)
// p.x = 3 // immutable
println p

// Groovy with @Builder
import groovy.transform.builder.Builder

@Builder
class Person {
    String name
    int age
}

def p = Person.builder().name("Alice").age(25).build()
println p

// Groovy with @Delegate
class Worker {
    def doWork() { "working" }
}

class Employee {
    @Delegate Worker worker = new Worker()
}

def e = new Employee()
println e.doWork()

// Groovy with @Lazy
class Heavy {
    def heavy = { println "created"; "heavy" }()
}

def h = new Heavy()
println h.heavy // created only once

// Groovy @AutoExternalize
import groovy.transform.AutoExternalize

@AutoExternalize
class Data {
    String name
    int age
}

def d = new Data(name: "Alice", age: 25)
def bytes = d.bytes
def d2 = new Data(bytes)
println d2

// Groovy with @CompileStatic
import groovy.transform.CompileStatic

@CompileStatic
def add(int a, int b) { a + b }
println add(3, 4)

// Groovy with @TypeChecked
import groovy.transform.TypeChecked

@TypeChecked
def multiply(int a, int b) { a * b }
println multiply(3, 4)

// Groovy with @Memoized
import groovy.transform.Memoized

@Memoized
def fib(n) {
    if (n <= 1) return n
    fib(n-1) + fib(n-2)
}
println fib(40)

// Groovy with Newify
import groovy.transform.Newify

@Newify([Person, Address])
class Test {
    def p = Person(name: "Alice")
    def a = Address(city: "NYC")
}

class Person { String name }
class Address { String city }

def t = new Test()
println t.p.name

// Groovy with Sort
def list = [4,2,5,1,3]
list.sort()
println list

def strings = ["apple", "Banana", "cherry"]
strings.sort { a, b -> a.toLowerCase() <=> b.toLowerCase() }
println strings

// Groovy Unique and Duplicates
def list = [1,2,2,3,4,4,5]
def unique = list.unique()
println unique

def duplicates = list.findAll { list.count(it) > 1 }.unique()
println duplicates

// Groovy Transpose
def matrix = [[1,2], [3,4], [5,6]]
def transposed = matrix.transpose()
println transposed

// Groovy Collate (chunk)
def list = 1..10
def chunks = list.collate(3)
println chunks

// Groovy InFlatten (deep flatten)
def nested = [1, [2,3], [4, [5,6]]]
def flat = nested.flatten()
println flat

// Groovy with EnumSet
import java.util.EnumSet

enum Size { SMALL, MEDIUM, LARGE }

def set = EnumSet.of(Size.SMALL, Size.MEDIUM)
println set

// Groovy with PriorityQueue
import java.util.PriorityQueue

def pq = new PriorityQueue()
pq.add(5)
pq.add(1)
pq.add(3)
while (!pq.isEmpty()) {
    println pq.poll()
}

// Groovy with Stack
def stack = []
stack.push(1)
stack.push(2)
println stack.pop()
println stack

// Groovy with Bitwise operators
def a = 5 // 101
def b = 3 // 011
println a & b // 1
println a | b // 7
println a ^ b // 6
println ~a

// Groovy with Range and for each
for (i in 0..<5) {
    println i
}

// Step
(0..10).step(2) { println it }

// Groovy with any and every
def list = [1,2,3]
println list.any { it > 2 } // true
println list.every { it > 0 } // true

// Groovy with findIndexOf
def list = [1,2,3,4]
def idx = list.findIndexOf { it == 3 }
println idx

// Groovy with split and tokenize
def str = "a,b,c"
def parts = str.split(',')
println parts

def tokens = str.tokenize(',')
println tokens

// Groovy with Regex Find
def text = "abc123def"
def matcher = (text =~ /\d+/)
if (matcher.find()) {
    println matcher.group()
}

// Groovy with replaceAll using closure
def str = "Hello World"
def replaced = str.replaceAll(/o/) { it.toUpperCase() }
println replaced

// Groovy with @BaseScript (script base class)
abstract class ScriptBase extends Script {
    def log(msg) { println "[LOG] $msg" }
}

// In script file:
// @BaseScript ScriptBase base
// log "Hello"

// Groovy with @Field (for class fields in scripts)
import groovy.transform.Field

@Field int counter = 0
def increment() { counter++ }
increment()
println counter

// Groovy with CliBuilder (command-line parsing)
import groovy.util.CliBuilder

def cli = new CliBuilder(usage: 'app [options]')
cli.h( longOpt: 'help', 'Show usage' )
cli.n( longOpt: 'name', args: 1, 'Name' )

def options = cli.parse(args)
if (options.h) cli.usage()
if (options.n) println "Hello, ${options.n}"

// Groovy with CompilerConfiguration (custom AST)
import org.codehaus.groovy.control.CompilerConfiguration

def config = new CompilerConfiguration()
config.setTargetDirectory('target')
def shell = new GroovyShell(config)
shell.evaluate("println 'Hello'")

// Groovy with ObjectGraphBuilder
import groovy.util.ObjectGraphBuilder

def builder = new ObjectGraphBuilder()
def root = builder.root {
    person(id:1, name:"Alice")
    person(id:2, name:"Bob")
}
root.children.each { println it.name }

// Groovy with AntBuilder
import groovy.util.AntBuilder

def ant = new AntBuilder()
ant.echo(message: "Hello from Ant")

// Groovy with SwingBuilder (UI)
import groovy.swing.SwingBuilder
import javax.swing.*

def swing = new SwingBuilder()
def frame = swing.frame(title:'Test', size:[200,200], visible:true) {
    label(text:'Hello')
}
sleep 2000
frame.dispose()

// Groovy with CliBuilder and Option Accessors
// Same as above but using @Option
import groovy.util.Option

class App {
    @Option(shortName='n', longName='name')
    String name
}

def cli = new CliBuilder()
cli.with {
    n longOpt:'name', args:1, 'Name'
}
// ...

// Groovy with ResourceBundle
import java.util.ResourceBundle

def bundle = ResourceBundle.getBundle("messages")
println bundle.getString("greeting")

// Groovy with SimpleDateFormat
import java.text.SimpleDateFormat

def sdf = new SimpleDateFormat("yyyy-MM-dd")
def date = sdf.parse("2023-01-01")
println date

// Groovy with URL Connection and file download
def url = new URL("https://example.com/file.txt")
def file = new File("downloaded.txt")
file << url.text
println "Downloaded"

// Groovy with Zip file handling
import java.util.zip.*

def zipFile = new File("archive.zip")
zipFile.withZipOutputStream { zos ->
    zos.putNextEntry(new ZipEntry("file.txt"))
    zos << "Hello"
}

// Groovy with temp files
File temp = File.createTempFile("tmp", ".txt")
temp << "Temporary"
println temp.text
temp.deleteOnExit()

// Groovy with Base64 encoding
import java.util.Base64

def text = "Hello"
def encoded = Base64.encoder.encodeToString(text.bytes)
println encoded
def decoded = new String(Base64.decoder.decode(encoded))
println decoded

// Groovy with UUID
import java.util.UUID

def uuid = UUID.randomUUID()
println uuid

// Groovy with System Properties
System.properties.each { k, v ->
    println "$k = $v"
}