# 목차
[1] 문자열 보간
[2] 자바와 상호 운용성
[3] 슬래시 String → Regex Expression에 유용 ex) test =~ /${regex}.*/
[4] List
[5] 객체 연산자
[6] 정규식 활용
[7] 스프레드 연산자
[8] 여러 매개변수 한 번에 적용
[9] 범위 연산자 .. 활용
[10] 첨자 연산자 활용
[11] in 연산자 활용
[12] 강제 형 변환
[13] Class명에 파라미터를 주면 .메소드명을 선언하지 않아도 알아서 찾아 감
[14] 함수 매개 변수
[15] Field와 Property
[활용1] String Parsing and Search for filename
[활용2] Json Parsing
[1] 문자열 보간
1. example
def name = 'Guillaume' // a plain string
def greeting = "Hello ${name}"
println greeting.toString() == 'Hello Guillaume'결과 : true
2. example
def sum = "The sum of 2 and 3 equals ${2 + 3}"
println sum.toString() == 'The sum of 2 and 3 equals 5'결과 : true
def 변수는 유형이 정해지지 않은 변수나 함수를 정의할 때 사용하며,
def로 정의한 변수는 ${변수명}으로 호출이 가능함.
${ } 사이에 변수명 뿐만 아니라 사칙 연산 등도 가능
[2] 자바와 상호 운용성
1. example
String takeString(String message) {
return message
}
def message = "The message is ${'hello'}"
println(message.getClass())
def result = takeString(message)
println(result.getClass())
println result결과 :
class org.codehaus.groovy.runtime.GStringImpl
class java.lang.String
The message is hello
def message = "The message is ${'hello'}" message의 type은 GString이지만 String과 호환 가능
2. example
char c1 = 'A'
println c1.getClass()
println c1 instanceof Character
def c2 = 'B' as char
println c2.getClass()
println c2 instanceof Character
def c3 = (char)'C'
println c3.getClass()
println c3 instanceof Character결과 :
class java.lang.Character
true
class java.lang.Character
true
class java.lang.Character
true
[3] 슬래시 String → Regex Expression에 유용 ex) test =~ /${regex}.*/
1. example
def color = 'blue'
def interpolatedSlashy = /a ${color} car/
println interpolatedSlashy == 'a blue car'
println interpolatedSlashy
println interpolatedSlashy.getClass()
println 'a blue car'
println 'a blue car'.getClass()결과 :
true
a blue car
class org.codehaus.groovy.runtime.GStringImpl
a blue car
class java.lang.String
→ ‘문자열’은 /문자열/과 같음
[4] List
1. example
def numbers = [1, 2, 3]
println numbers.getClass()
println numbers.size()결과 :
class java.util.ArrayList
3
2. example
def key = 'name'
def person = [key: 'Guillaume']
def person2 = [ /${key}/ : 'Guillaume']
def person3 = [(key): 'Guillaume']
println person.containsKey('name')
println person.containsKey('key')
println person
println person2
println person3결과 :
false
true
[key:Guillaume]
[name:Guillaume]
[name:Guillaume]
→ (변수명) 으로 변수를 받아 올 수도 있지만 되도록 ${변수명}을 사용하는 것을 권장
[5] 객체 연산자
1. example
class User {
public final String name
User(String name) { this.name = name}
String getName() { "Name: $name" }
}
def user = new User('Bob')
println user.getClass()
println user.name.getClass()
println user.@name.getClass()
println user.name
println user.@name결과 :
class groovyTest02.User
class java.lang.String
class java.lang.String
Name: Bob
Bob
[6] 정규식 활용
def text = "some text to match"
def m = text =~ /match/
println m.find()
def t = text ==~ /match/
println t결과 :
true
false
→ =~는 일치하는 것이 하나라도 있으면 true를 반환하고
==~는 전부 일치해야 true를 반환
[7] 스프레드 연산자
1. example
class Car {
String make
String model
}
def cars = [
new Car(make: 'Peugeot', model: '508'),
new Car(make: 'Renault', model: 'Clio')]
def makes = cars*.make
println makes결과 : [Peugeot, Renault]
2. example
class Component {
Long id
String name
}
class CompositeObject implements Iterable<Component> {
def components = [
new Component(id: 1, name: 'Foo'),
new Component(id: 2, name: 'Bar')]
@Override
Iterator<Component> iterator() {
components.iterator()
}
}
def composite = new CompositeObject()
println composite*.id
println composite*.name결과 :
[1, 2]
[Foo, Bar]
→ 스프레드 연산자는 Iterable 인터페이스를 구현하는 모든 클래스에서 사용 가능
3. example
import groovy.transform.Canonical
class Make {
String name
List<Model> models
}
@Canonical
class Model {
String name
}
def cars = [
new Make(name: 'Peugeot',
models: [new Model('408'), new Model('508')]),
new Make(name: 'Renault',
models: [new Model('Clio'), new Model('Captur')])
]
def makes = cars*.name
println makes
def models = cars*.models*.name
println models
println models.sum() // flatten one level
println models.flatten() // flatten all levels (one in this case)결과 :
[Peugeot, Renault]
[[408, 508], [Clio, Captur]]
[408, 508, Clio, Captur]
[408, 508, Clio, Captur]
4. example
class Car {
String make
String model
}
def cars = [
[
new Car(make: 'Peugeot', model: '408'),
new Car(make: 'Peugeot', model: '508')
], [
new Car(make: 'Renault', model: 'Clio'),
new Car(make: 'Renault', model: 'Captur')
]
]
def models = cars.collectNested{ it.model }
println models결과 : [[408, 508], [Clio, Captur]]
[8] 여러 매개변수 한 번에 적용
1. example
int function(int x, int y, int z) {
x*y+z
}
def args = [4,5,6]
println function(*args)결과 : 26
[9] 범위 연산자 .. 활용
1. example
def range = 0..5
println( (0..5).collect())
println( (0..<5).collect())
println( range )
println( range.size())결과 :
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4]
0..5
6
2. example
def list = [0,1,2,3,4]
println list[2] //== 2
list[2] = 4
println list[0..2]// == [0,1,4]
list[0..2] = [6,6,6]
println list //== [6,6,6,3,4]결과 :
2
[0, 1, 4]
[6, 6, 6, 3, 4]
[10] 첨자 연산자 활용
1. example
class User {
Long id
String name
def getAt(int i) {
switch (i) {
case 0: return id
case 1: return name
}
throw new IllegalArgumentException("No such element $i")
}
void putAt(int i, def value) {
switch (i) {
case 0: id = value; return
case 1: name = value; return
}
throw new IllegalArgumentException("No such element $i")
}
}
def user = new User(id: 1, name: 'Alex')
println user[0] //== 1
println user[1]// == 'Alex'
user[1] = 'Bob'
println user.name //== 'Bob'
println()
println(user.getAt(0))//== 1
user.putAt(1, 'Oliver')
println(user[1]) //== 'Oliver'결과 :
1
Alex
Bob
1
Oliver
[11] in 연산자 활용
1. example
def list = ['Grace','Rob','Emmy']
println ('Emmy' in list)결과 : true
[12] 강제 형 변환
1. example
Integer x = 123
String s = (String) x
println(x.getClass())
println(s.getClass())결과 :
class java.lang.Integer
class java.lang.String
2. example
class Identifiable {
String name
}
class User {
Long id
String name
def asType(Class target) {
if (target == Identifiable) {
return new Identifiable(name: name)
}
throw new ClassCastException("User cannot be coerced into $target")
}
}
def u = new User(name: 'Xavier')
def p1 = u as Identifiable
def p2 = u.asType(Identifiable)
println(u.getClass())
println(p1.getClass()) // instanceof Identifiable
println(p2.getClass()) // instanceof Identifiable
println(p1.getName())결과 :
class groovyTest02.User
class groovyTest02.Identifiable
class groovyTest02.Identifiable
Xavier
→ asType으로 형 변환을 해도 되지만 간단하게 as Class명으로도 가능 함
[13] Class명에 파라미터를 주면 .메소드명을 선언하지 않아도 알아서 찾아 감
1. example
class MyCallable {
int call(int x) {
2*x
}
int call(int x, y) {
return x*y
}
}
def mc = new MyCallable()
println mc.call(2) // == 4
println mc(2, 4) // == 4결과 :
4
8
→ 오버로딩(같은 이름이지만 파라미터가 다른 케이스)도 됨
2. example
class Bucket {
int size
Bucket(int size) { this.size = size }
Bucket plus(Bucket other) {
return new Bucket(this.size + other.size)
}
}
def b1 = new Bucket(4)
def b2 = new Bucket(11)
println((b1 + b2).size) // == 15결과 : 15
[14] 함수 매개 변수
1) example
def foo(Map args, Integer number) { "${args.name}: ${args.age}, and the number is ${number}" }
println(foo(name: 'Marie', age: 1, 23))
println(foo(23, name: 'Marie', age: 1))결과 :
Marie: 1, and the number is 23
Marie: 1, and the number is 23
→ 함수에 매개변수를 넣을 때 명시적으로 주면 순서에 상관 없이 알아서 적용 됨
단, 함수의 첫 번째 매개변수 설정으로 Map이 들어가지 않으면, 해당 변수들을 줄 때 [ ]로 묶어서 주어야 함
다음 예시 참고)
2. example
def foo(Integer number, Map args) { "${args.name}: ${args.age}, and the number is ${number}" }
println(foo(23, [name: 'Marie', age: 1]) )
println(foo(name: 'Marie', age: 1, 23))결과 :
Marie: 1, and the number is 23
Caught: groovy.lang.MissingMethodException: No signature of method: groovyTest02.test_220914.foo() is applicable for argument types: (LinkedHashMap, Integer) values: [[name:Marie, age:1], 23]
Possible solutions: foo(java.lang.Integer, java.util.Map), run(), run(), find(), any(), wait()
groovy.lang.MissingMethodException: No signature of method: groovyTest02.test_220914.foo() is applicable for argument types: (LinkedHashMap, Integer) values: [[name:Marie, age:1], 23]
Possible solutions: foo(java.lang.Integer, java.util.Map), run(), run(), find(), any(), wait()
3. example
def foo(Object... args) { args.length }
println foo() //== 0
println foo(1) //== 1
println foo(1, 2) //== 2결과 :
0
1
2
→ 타입… args나, 타입[] args로 매개 변수 설정을 하면 매개 변수를 여러 개를 받을 수 있음
def foo(Object... args) { args.length } == def foo(Object[] args) { args.length }
4. example
def method(Object o1, Object o2) { 'o/o' }
def method(Integer i, String s) { 'i/s' }
def method(String s, Integer i) { 's/i' }
println method('foo', 42) //== 's/i'
List<List<Object>> pairs = [['foo', 1], [2, 'bar'], [3, 4]]
println pairs.collect { a, b -> method(a, b) } //== ['s/i', 'i/s', 'o/o']결과 :
s/i
[s/i, i/s, o/o]
→ 오버로딩이 가능하며 주어지는 파라미터에 맞춰서 알아서 적용이 됨
[15] Field와 Property
1. example
class Person {
String name
void name(String name) {
this.name = "Wonder$name"
}
String wonder() {
this.name
}
}
def p = new Person()
p.name = 'Marge'
println p.name // == 'Marge'
p.name('Marge')
println p.wonder() // == 'WonderMarge'결과 :
Marge
WonderMarge
→ ( )로 파라미터를 입력하는 것에 따라서 다르게 적용
[활용1] String Parsing and Search for filename
1. test
String path = "/user01/temp/sample_test.csv"
def file_path = path.split("/")
//println(file_path.size())
def file_name = file_path[file_path.size() - 1].toString()
println(file_name)
def result = (file_name =~ /sample/).findAll()
println(result)
if (result.size()> 0)
println("true")
else
println("false")
[활용2] Json Parsing
import groovy.json.JsonSlurper
import groovy.util.Eval
def object = /{"json_info": {"inner_id": "code_001", "code_kind": "D"}}/
def jsonPath = '.json_info.code_kind'
//println(object)
//println(object.getClass())
def jsonSlurper = new JsonSlurper()
def jsonObj = jsonSlurper.parseText(object)
//println(jsonObj)
def resultVal = Eval.me("jsonObj", jsonObj, "jsonObj" + jsonPath)
println("code_kind = " + (resultVal))결과 : code_kind = D
→ Json은 ' . '을 통해서 하위 value에 접근이 가능 함
따라서, Eval.me("jsonObj", jsonObj, "jsonObj" + jsonPath)의
Eval.me는 표현식을 적용해주며,
jsonObj가 Json Object이기 때문에 .json_info.code_kind으로 하위 value에 접근이 가능 함
결과적으로 jsonObj.json_info.code_kind이 되므로, json_info의 code_kind의 value를 반환 함