Groovy Reference

Getting Started — what Groovy is and where it came from, installing it (SDKMAN!, Homebrew, zip, Docker, Windows), JDK requirements per release line, Maven and Gradle coordinates and a first script.

Differences with Java — every documented difference from Java with a side-by-side example, from default imports and multi-methods to == and primitives.

Groovy & Other Languages — everyday idioms mapped from Java, Kotlin, Scala, Python and Ruby, and the trade-offs of dynamic typing.

Running Scripts & the groovy Command — the groovy command, -e, -n, -p, -i, the shebang line, arguments, exit codes and the classpath rules.

groovysh & groovyconsole — the JLine 3 REPL and the Swing console, their commands, history and embedding.

Lexical Structure, Comments, Keywords & Identifiers — comments, the shebang, reserved and contextual keywords, normal and quoted identifiers.

Strings & GStrings — the six literal forms, escapes, interpolation, lazy GStrings and the GString versus String pitfalls.

Numbers & Numeric Literals — literal forms, BigDecimal by default, suffixes, result types of arithmetic and promotion.

Booleans & the Groovy Truth — how every type is coerced to a boolean and how to customise it with asBoolean().

Lists & Arrays — list literals, indexing, slicing, operators, arrays and primitive arrays.

Maps — map literals, key rules, access styles, withDefault, spread maps and the common methods.

Ranges — inclusive and exclusive ranges, stepping, ranges of characters and dates, and custom Comparable ranges.

Variables, Typing, def, var & val — def, explicit types, var, val, final, multiple assignment and destructuring.

Program Structure, Packages, Imports & Scripts — packages, default and aliased imports, module imports, and scripts versus classes.

Operators: Arithmetic, Relational & Logical — arithmetic, relational, logical, bitwise, ternary and Elvis operators with the precedence table.

Object Operators — safe navigation, direct field access, method pointers and references, spread, spaceship and subscript operators.

Regular Expressions — the pattern, find and match operators, groups, slashy strings and the GDK regex helpers.

Operator Overloading — the operator-to-method table, comparison rules and compound-assignment overloading.

Control Structures — if, switch with isCase, switch expressions, loops, labels and the position rule.

Exceptions & Error Handling — try/catch/finally, multi-catch, try-with-resources and the dynamic exceptions.

Assertions & Power Assert — assert, power-assert output and assertions as executable documentation.

Type Coercion & Promotion — casts versus as, number promotion, closure to SAM coercion and map and list coercion.

Optionality — what may be left out: parentheses, semicolons, return and public.

Classes, Fields & Properties — classes, inner classes, fields versus properties, accessors and visibility.

Methods, Constructors & Parameters — methods, named-argument constructors, default and named parameters, varargs.

Inheritance, Interfaces & Generics — inheritance, abstract classes, interfaces with default methods, duck typing and generics.

Traits — trait methods, state, composition, conflicts and runtime traits.

Records & Sealed Types — records, compact constructors, copyWith and sealed hierarchies.

Enums & Annotations — enums with bodies, defining and using annotations.

Closures — closure syntax, parameters, captured variables, coercion and closures versus lambdas.

Closure Delegation: Owner, Delegate & This — how a closure resolves names: this, owner, delegate, resolve strategies and @DelegatesTo.

Functional Programming — currying, memoization, composition, trampolines and java.util.function interop.

Static Type Checking & @CompileStatic — @TypeChecked, @CompileStatic, flow typing and closure parameter hints.

Type Checking Extensions — writing extensions to the static type checker with the event API.

Built-in Type Checkers — the checkers shipped in groovy.typecheckers, from RegexChecker to NullChecker.

GDK Overview & Object Methods — how the GDK extends the JDK, the Object methods, ConfigSlurper, Expando and observable collections.

Working with Collections — iterating, filtering, transforming, aggregating, sorting and combining collections.

Files I/O & Paths — reading, writing and traversing files and Path objects.

External Processes — running commands with execute(), process streams, pipes and timeouts.

Dates & Times — java.time extensions, formatting, parsing and the TimeCategory duration DSL.

Runtime Metaprogramming & the MOP — the Meta-Object Protocol, invokeMethod, methodMissing, propertyMissing and interception.

Metaclasses, ExpandoMetaClass & Categories — metaclasses, ExpandoMetaClass and use(Category).

Extension Modules — writing, packaging and using instance and static extension methods.

AST Transformations: Code Generation & Class Design — @ToString, @Canonical, @Builder, @Delegate, @Lazy and the other class-design transformations.

AST Transformations: Logging, Safety, Concurrency & Directives — logging, concurrency, cloning, safety and directive transformations.

Writing AST Transformations & Macros — compilation phases, local and global transformations, the AST API and macros.

Async/Await — native async/await and Awaitable in Groovy 6.0 (incubating).

Generators, Channels & Structured Concurrency — generators, channels, selects and structured concurrency scopes (incubating).

Parallel Collections & Dataflow — parallel collection methods, pools and dataflow variables in groovy.concurrent.

Actors, Agents & Active Objects — Agent, Actor and @ActiveObject message-passing concurrency.

JSON — JsonSlurper, JsonOutput, JsonBuilder and typed parsing.

XML Parsing, GPath & Security — XmlParser, XmlSlurper, GPath and secure-by-default parsing.

XML: Creating & Manipulating — MarkupBuilder, StreamingMarkupBuilder and editing XML trees.

YAML & TOML — YamlSlurper, TomlSlurper, builders and typed parsing.

CSV & Markdown — CsvSlurper, CsvBuilder and MarkdownSlurper (incubating).

Databases with Groovy SQL — groovy.sql.Sql, queries, transactions, batches and datasets.

GINQ: SQL-like Collection Queries — GINQ queries with from, where, joins, grouping and windows.

Template Engines — the groovy.text engines, from SimpleTemplateEngine to MarkupTemplateEngine.

HTTP Client with HttpBuilder — the HttpBuilder closure DSL over the JDK HttpClient (incubating).

Builders — the builder pattern, the built-in builders and writing your own.

Domain Specific Languages — command chains, script base classes, @DelegatesTo and type-checked DSLs.

Compilation Customizers & Secure Scripting — CompilerConfiguration, customizers and running untrusted scripts safely.

Integrating Groovy into Java Applications — GroovyShell, GroovyClassLoader, GroovyScriptEngine and JSR 223.

Compiling with groovyc & Joint Compilation — groovyc, its options and joint compilation with Java.

Build Tools: Gradle, Maven & Ant — building Groovy with Gradle, Maven (GMavenPlus) and Ant.

Grape Dependency Management — @Grab, the grape command and its resolvers.

GroovyDoc — doc comments, Markdown comments, the groovydoc tool and its build integrations.

Groovlets, Servlets & JMX — Groovlets, servlet integration and JMX management.

Performance, invokedynamic & Native Images — invokedynamic call sites, static compilation and GraalVM native images.

Testing with JUnit & Groovy Test — JUnit 4, 5 and 6, GroovyAssert, mocks and test annotations.

Testing with Spock & Geb — Spock specifications and Geb browser tests (third-party).

Design by Contract with groovy-contracts — @Requires, @Ensures, @Invariant and the contract annotations.

Style Guide & Idioms — the official style guide rules with before-and-after examples.

Design Patterns in Groovy — the 21 classic patterns expressed in idiomatic Groovy.

What’s New & Migrating from Older Versions — every release from 1.0 to 6.0, legacy-to-modern table and migration notes.

Ecosystem & Groovy in Other Tools — projects built on or embedding Groovy, each with a brief description and links.

Cheat Sheet (PDF) — a one-page, printable summary of the whole section, with a legacy-to-modern strip.