Часто используемый синтаксис Groovy

Groovy — это гибкий язык программирования, основанный на платформе Java, который сочетает в себе многие мощные возможности Python, Ruby и Smalltalk. Ниже приведены некоторые часто используемые конструкции языка Groovy, которые помогут вам быстро освоиться.

Объявление переменных

В Groovy для объявления переменных можно использовать ключевое слово def, а также явно указывать тип данных.

// Использование ключевого слова def
def name = "Groovy"

// Явное указание типа
String greeting = "Hello, ${name}!"

Типы данных

Groovy поддерживает множество типов данных, включая целые числа, вещественные числа, логические значения и строки.

def a = 10          // Целое число
def b = 10.5        // Вещественное число
def c = true        // Логическое значение
def d = "Groovy"    // Строка

Логические операции

Groovy поддерживает логические операторы: && (логическое И), || (логическое ИЛИ), ! (логическое НЕ).

def a = 10
def b = 20

if (a > 0 && b > 0) {
    println "Оба числа положительные"
} else if (a > 0 || b > 0) {
    println "По крайней мере одно число положительно"
} else {
    println "Оба числа неположительные"
}

Условные операторы

Groovy поддерживает условные операторы if-else и switch.

def number = 10
if (number > 0) {
    println "Число положительное"
} else {
    println "Число неположительное"
}

switch (number) {
    case 0:
        println "Число равно нулю"
        break
    case { it > 0 }:
        println "Число положительное"
        break
    default:
        println "Число отрицательное"
}

Циклы

Groovy поддерживает циклы for, while и do-while.

// Цикл for
for (i in 0..9) {
    println i
}

// Цикл while
def i = 0
while (i < 10) {
    println i++
}

// Цикл do-while
def j = 0
do {
    println j++
} while (j < 10)

Работа со строками

Конкатенация строк

В Groovy можно использовать оператор + или синтаксис ${} для объединения строк.

def name = "Groovy"
def greeting = "Hello, " + name + "!"
println greeting  // Вывод: Hello, Groovy!

def greeting2 = "Hello, ${name}!"
println greeting2  // Вывод: Hello, Groovy!

Извлечение подстроки

Для извлечения части строки используется метод substring.

def str = "Hello, Groovy!"
println str.substring(7)  // Вывод: Groovy!
println str.substring(0, 5)  // Вывод: Hello

Замена подстрок

Метод replace позволяет заменять содержимое строки.

def str = "Hello, Groovy!"
println str.replace("Groovy", "Java")  // Вывод: Hello, Java!

Разделение строки

Метод split разделяет строку на массив по заданному разделителю.

def str = "Hello, Groovy!"
def parts = str.split(", ")
println parts[0]  // Вывод: Hello
println parts[1]  // Вывод: Groovy!

Разделение и получение элементов

Метод tokenize разделяет строку на список и позволяет получить нужный элемент по индексу.

def str = "Hello, Groovy!"
println str.tokenize(",")[1]  // Вывод: Groovy!

Удаление пробелов

Метод trim удаляет пробелы в начале и конце строки.

def str = "  Hello, Groovy!  "
println str.trim()  // Вывод: Hello, Groovy!

Длина строки

Свойство length возвращает длину строки.

def str = "Hello, Groovy!"
println str.length()  // Вывод: 14

Проверка наличия подстроки

Метод contains определяет, содержит ли строка заданную подстроку.

def str = "Hello, Groovy!"
println str.contains("Groovy")  // Вывод: true

Поиск подстроки

Метод indexOf находит позицию подстроки в строке.

def str = "Hello, Groovy!"
println str.indexOf("Groovy")  // Вывод: 7

Сравнение строк

Для сравнения строк используются операторы ==, !=, <, >, <=, >=.

def str1 = "Hello, Groovy!"
def str2 = "Hello, Java!"
println str1 == str2  // Вывод: false
println str1 != str2  // Вывод: true
println str1 < str2  // Вывод: true
println str1 > str2  // Вывод: false
println str1 <= str2  // Вывод: true
println str1 >= str2  // Вывод: false

Экранирование символов

Символ \ используется для экранирования специальных символов, например, \n обозначает перевод строки.

def str = "Hello,\nGroovy!"
println str  // Вывод: Hello,
             // Groovy!

Шаблонизация строк

Groovy поддерживает встраивание переменных в строки с помощью синтаксиса ${}.

def name = "Groovy"
def greeting = "Hello, ${name}!"
println greeting  // Вывод: Hello, Groovy!

Регулярные выражения

Для работы с регулярными выражениями используется оператор ==~.

def emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
def str = "google@163.com"
println str ==~ emailPattern  // Вывод: true

Многострочные строки

Многострочные строки можно определить с помощью тройных кавычек """ или '''.

def multiLineStr = """
    Это многострочная
    строка в Groovy.
"""
println multiLineStr

Списки (List)

Списки (List) — одна из наиболее часто используемых структур данных в Groovy, позволяющая хранить элементы разных типов. Ниже представлены некоторые распространённые операции со списками.

Создание списка

Список можно создать с помощью квадратных скобок [].

def list = [1, 2, 3, 'Groovy', true]

Доступ к элементам списка

Элементы списка доступны по индексу, начиная с 0.

def list = [1, 2, 3, 'Groovy', true]
println list[3]  // Вывод: Groovy

Изменение элементов списка

Элементы списка можно изменять по индексу.

def list = [1, 2, 3, 'Groovy', true]
list[3] = 'Java'
println list  // Вывод: [1, 2, 3, 'Java', true]

Добавление элементов

Элементы можно добавить в список с помощью метода add или оператора слева направо <<.

def list = [1, 2, 3]
list.add(4)
println list  // Вывод: [1, 2, 3, 4]

list << 5
println list  // Вывод: [1, 2, 3, 4, 5]

Удаление элементов

Элементы можно удалить из списка с помощью метода remove.

def list = [1, 2, 3, 4, 5]
list.remove(0)
println list  // Вывод: [2, 3, 4, 5]

Длина списка

Количество элементов в списке можно узнать с помощью метода size.

def list = [1, 2, 3, 4, 5]
println list.size()   // Вывод: 5

Перебор элементов списка

Перебор элементов списка можно осуществить с помощью цикла for.

def list = [1, 2, 3, 4, 5]
for (item in list) {
    println item
}

Также можно использовать метод each для перебора элементов списка.

def list = [1, 2, 3, 4, 5]
list.each { println it }

Преобразование списка

def list = [1, 2, 3, 4, 5]
def newList = list.collect { it * 2 }
println newList  // Вывод: [2, 4, 6, 8, 10]

Фильтрация списка

find

Возвращает первый элемент, удовлетворяющий заданному условию.

def list = [1, 2, 3, 4, 5]
println list.find { it % 2 == 0 }  // Вывод: 2

findAll

Возвращает новый список, содержащий все элементы, удовлетворяющие условию.

def list = [1, 2, 3, 4, 5]
def newList = list.findAll { it % 2 == 0 }
println newList  // Вывод: [2, 4]

Проверка на соответствие условиям

any

Проверяет, есть ли хотя бы один элемент, удовлетворяющий условию.

def list = [1, 2, 3, 4, 5]
println list.any { it % 2 == 0 }  // Вывод: true

every

Проверяет, все ли элементы удовлетворяют условию.

def list = [1, 2, 3, 4, 5]
println list.every { it % 2 == 0 }  // Вывод: false

Вырезание части списка

С помощью метода subList можно получить часть списка.

def list = [1, 2, 3, 4, 5]
println list.subList(1, 4)  // Вывод: [2, 3, 4]

Сортировка списка

Список можно отсортировать с помощью метода sort.

def list = [3, 1, 4, 2, 5]
println list.sort()  // Вывод: [1, 2, 3, 4, 5]

Инвертирование списка

Список можно перевернуть с помощью метода reverse.

def list = [1, 2, 3, 4, 5]
println list.reverse()  // Вывод: [5, 4, 3, 2, 1]

Проверка наличия элемента в списке

Метод contains проверяет, есть ли в списке заданный элемент.

def list = [1, 2, 3, 4, 5]
println list.contains(3)  // Вывод: true
println list.contains(6)  // Вывод: false

Объединение списков

Списки можно объединить с помощью метода plus или оператора +.

def list1 = [1, 2, 3]
def list2 = [4, 5, 6]
println list1.plus(list2)  // Вывод: [1, 2, 3, 4, 5, 6]
println list1 + list2      // Вывод: [1, 2, 3, 4, 5, 6]

Очистка списка

Список можно очистить с помощью метода clear.

def list = [1, 2, 3, 4, 5]
list.clear()
println list  // Вывод: []

Отображения (Map)

Отображения (Map) — одна из наиболее часто используемых структур данных в Groovy, предназначенная для хранения пар «ключ–значение». Ниже представлены некоторые распространённые операции с отображениями.

Создание отображения

Отображение можно создать с помощью квадратных скобок [:] или фигурных скобок {}.

def map = [:]
map = ["name": "Groovy", "version": 2.5]

Доступ к элементам отображения

Значения в отображении можно получить по ключу.

def map = ["name": "Groovy", "version": 2.5]
println map["name"]  // Вывод: Groovy

Изменение значений в отображении

Значения в отображении можно изменить по ключу.

def map = ["name": "Groovy", "version": 2.5]
map["name"] = "Java"
println map  // Вывод: [name:Java, version:2.5]

Добавление новых элементов

Новые элементы можно добавить в отображение с помощью метода put или простым присваиванием.

def map = ["name": "Groovy"]
map.put("version", 2.5)
println map  // Вывод: [name:Groovy, version:2.5]

map["author"] = "James"
println map  // Вывод: [name:Groovy, version:2.5, author:James]

Удаление элементов

Элементы можно удалить из отображения с помощью метода remove.

def map = ["name": "Groovy", "version": 2.5]
map.remove("version")


println map  // Выводит [name:Groovy]

Размер отображения

Для получения размера отображения можно использовать метод size.

def map = ["name": "Groovy", "version": 2.5]
println map.size()  // Выводит 2

Перебор элементов отображения

Методом each можно перебрать пары ключ–значение в отображении.

def map = ["name": "Groovy", "version": 2.5]
map.each { key, value ->
    println "${key}: ${value}"
}

Проверка наличия ключа или значения

С помощью методов containsKey и containsValue можно проверить, есть ли в отображении определённый ключ или значение.

def map = ["name": "Groovy", "version": 2.5]
println map.containsKey("name")  // Выводит true
println map.containsValue(2.5)  // Выводит true

Очистка отображения

Метод clear позволяет очистить отображение.

def map = ["name": "Groovy", "version": 2.5]
map.clear()
println map  // Выводит [:]

Объединение отображений

С помощью метода putAll можно добавить все элементы одного отображения в другое.

def map1 = ["name": "Groovy"]
def map2 = ["version": 2.5]
map1.putAll(map2)
println map1  // Выводит [name:Groovy, version:2.5]

Получение всех ключей или значений

Методами keySet и values можно получить все ключи или значения отображения.

def map = ["name": "Groovy", "version": 2.5]
println map.keySet()  // Выводит [name, version]
println map.values()  // Выводит [Groovy, 2.5]

Функции

В Groovy функции называются методами (Method) и могут быть определены как внутри классов, так и как часть скриптов. Ниже приведены основные синтаксические конструкции для определения и вызова функций в Groovy.

Определение функции

Функцию можно определить с помощью ключевого слова def.

def greet(name) {
    return "Hello, ${name}!"
}

Вызов функции

После определения функции её можно вызвать, указав имя и аргументы.

def result = greet("Groovy")
println result  // Выводит Hello, Groovy!

Функция с параметрами по умолчанию

При определении функции можно задать значения по умолчанию для её параметров.

def greet(name = "World") {
    return "Hello, ${name}!"
}

println greet()        // Выводит Hello, World!
println greet("Groovy") // Выводит Hello, Groovy!

Функция с несколькими аргументами

Можно определить функцию, принимающую несколько аргументов.

def add(a, b) {
    return a + b
}

println add(3, 5)  // Выводит 8

Анонимная функция

Анонимную функцию можно определить и присвоить её переменной или передать в качестве аргумента.

def multiply = { a, b -> a * b }
println multiply(3, 5)  // Выводит 15

Функция с переменным числом аргументов

Можно определить функцию, принимающую переменное количество аргументов.

def sum(... numbers) {
    def total = 0
    for (number in numbers) {
        total += number
    }
    return total
}

println sum(1, 2, 3, 4)  // Выводит 10

Функция, принимающая замыкание

Можно определить функцию, которая принимает замыкание (Closure) в качестве аргумента.

def operate(a, b, closure) {
    return closure(a, b)
}

def add = { x, y -> x + y }
println operate(3, 5, add)  // Выводит 8

Функция, возвращающая несколько значений

Можно определить функцию, возвращающую несколько значений; результат будет представлен в виде списка.

def getCoordinates() {
    return [10, 20]
}

def (x, y) = getCoordinates()
println "x: ${x}, y: ${y}"  // Выводит x: 10, y: 20

Рекурсивная функция

Рекурсивную функцию можно определить так, чтобы она вызывала саму себя внутри своей реализации.

def factorial(n) {
    if (n <= 1) {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

println factorial(5)  // Выводит 120