Groovy Conditionals
last modified April 5, 2025
Conditionals allow programs to make decisions based on boolean expressions. Groovy provides several conditional structures including if/else, switch, and the ternary operator. These control program flow based on conditions.
Basic Definition
Conditionals evaluate boolean expressions to determine code execution paths. Groovy supports standard Java conditionals with additional enhancements. The main conditional structures are if/else, switch/case, and ?: operator.
Groovy conditionals work with truthy values where non-null/non-zero values evaluate to true. This differs from Java's strict boolean requirements.
Simple if Statement
The if statement executes code when a condition is true.
def age = 18
if (age >= 18) {
println "You are an adult"
}
This checks if age is 18 or more. If true, it prints the message. The condition must evaluate to a boolean value. Groovy allows truthy evaluation.
Curly braces are optional for single statements but recommended for clarity. The condition must be in parentheses.
$ groovy IfExample.groovy You are an adult
if-else Statement
The if-else statement provides an alternative execution path when the condition is false.
def temperature = 25
if (temperature > 30) {
println "It's hot outside"
} else {
println "It's not too hot"
}
This checks temperature and prints different messages based on the value. The else block executes when the if condition is false.
The else statement must appear immediately after the if block. Multiple conditions can be chained with else-if.
$ groovy IfElseExample.groovy It's not too hot
if-else-if Ladder
Multiple conditions can be checked using else-if statements.
def score = 85
if (score >= 90) {
println "Grade A"
} else if (score >= 80) {
println "Grade B"
} else if (score >= 70) {
println "Grade C"
} else {
println "Grade D"
}
This evaluates score against multiple grade thresholds. The first true condition executes its block, skipping others.
Conditions are evaluated top to bottom. Only one block executes even if multiple conditions are true.
$ groovy IfElseIfExample.groovy Grade B
Ternary Operator
The ternary operator provides a concise way to write simple if-else statements.
def age = 20 def status = age >= 18 ? "Adult" : "Minor" println status
This assigns "Adult" if age is 18+, otherwise "Minor". The syntax is condition ? trueValue : falseValue.
Ternary expressions return a value and can be used in assignments or method arguments. They're ideal for simple conditions.
$ groovy TernaryExample.groovy Adult
Switch Statement
The switch statement compares a value against multiple cases.
def day = "Wednesday"
switch(day) {
case "Monday":
println "Start of work week"
break
case "Friday":
println "Almost weekend"
break
default:
println "Midweek day"
}
This checks the day variable against different cases. The matching case executes its code block. Default runs if no cases match.
Groovy's switch is more powerful than Java's, supporting various matching strategies. Break statements prevent fall-through to next cases.
$ groovy SwitchExample.groovy Midweek day
Switch with Ranges
Groovy switch supports range matching in case statements.
def score = 75
switch(score) {
case 90..100:
println "Excellent"
break
case 75..<90:
println "Good"
break
case 60..<75:
println "Average"
break
default:
println "Needs improvement"
}
This uses range operators to match score ranges. The .. creates an inclusive range, while ..< is exclusive on the upper bound.
Range matching simplifies numeric comparisons that would require multiple conditions with if statements.
$ groovy SwitchRangeExample.groovy Good
Switch with Regular Expressions
Groovy switch can match against regular expressions.
def input = "admin@example.com"
switch(input) {
case ~/.*@admin\..*/:
println "Admin email"
break
case ~/.*@example\.com/:
println "Example domain"
break
default:
println "Unknown email"
}
The ~/pattern/ syntax creates a regex matcher. The input is checked against each pattern until a match is found.
Regex matching in switch statements is unique to Groovy and very powerful for string pattern matching.
$ groovy SwitchRegexExample.groovy Admin email
Switch with Type Checking
Groovy switch can check the type of the input value.
def value = 3.14
switch(value) {
case Integer:
println "Integer number"
break
case Float:
println "Float number"
break
case Double:
println "Double number"
break
default:
println "Unknown type"
}
This checks the runtime type of value against class types. The matching case executes when the value is an instance of the specified type.
Type checking in switch is useful for polymorphic behavior based on input types without explicit instanceof checks.
$ groovy SwitchTypeExample.groovy Double number
Truthy Evaluation
Groovy evaluates non-boolean values in conditions using truthy rules.
def name = "John" def count = 0 def list = [] if (name) println "Name has value" // true if (count) println "Count is non-zero" // false if (list) println "List has elements" // false
In Groovy, non-null/non-empty/true values evaluate to true. Zero, empty collections, null, and false evaluate to false.
This differs from Java where conditions must be strictly boolean. It makes Groovy code more concise for common checks.
$ groovy TruthyExample.groovy Name has value
Elvis Operator
The Elvis operator ?: provides default values for null references.
def username = null def displayName = username ?: "Guest" println "Welcome, $displayName"
This assigns "Guest" if username is null. The syntax is value ?: defaultValue. It's like a shortened ternary operator for null checks.
The Elvis operator is commonly used to provide fallback values and handle null safely without verbose if-else blocks.
$ groovy ElvisExample.groovy Welcome, Guest
Source
Groovy Conditionals Documentation
This tutorial covered Groovy conditional structures with practical examples. Conditionals are fundamental for controlling program flow in Groovy.
Author
List all Groovy tutorials.