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는 && (논리 AND), || (논리 OR), ! (논리 NOT) 등의 논리 연산자를 지원합니다.

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 "숫자는 0입니다"
        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 = """
    This is a multi-line
    string in Groovy.
"""
println multiLineStr

리스트(List)

Groovy에서 리스트는 다양한 타입의 요소를 포함할 수 있는 자주 사용되는 데이터 구조입니다. 다음은 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 }

리스트 변환

collect 메서드를 사용하여 리스트의 각 요소를 변환할 수 있습니다.

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)

Groovy에서 맵은 키-값 쌍을 저장하는 데 사용되는 자주 사용되는 데이터 구조입니다. 다음은 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` 메서드를 사용하여 맵의 크기를 확인할 수 있습니다.

```groovy
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