associate
associate
ํจ์๋ Kotlin์ ์ปฌ๋ ์
ํ์ฅ ํจ์ ์ค ํ๋๋ก, ๋ฆฌ์คํธ(List)๋ ๋ค๋ฅธ Iterable ๊ฐ์ฒด๋ฅผ Map
์ผ๋ก ๋ณํํ ๋ ์ฌ์ฉ๋๋ ๋งค์ฐ ์ ์ฉํ ํจ์์
๋๋ค. ์ด ํจ์๋ ๋ฆฌ์คํธ์ ๊ฐ ์์์ ๋ํด ํค(Key)์ ๊ฐ(Value)์ ์์ฑํ์ฌ ์๋ก์ด ๋งต์ ๋ง๋ค์ด ์ค๋๋ค.
associate
ํจ์์ ๊ธฐ๋ณธ์ ์ธ ๋์ ๊ตฌ์กฐ
associate
ํจ์์ ๊ธฐ๋ณธ์ ์ธ ๋์ ๊ตฌ์กฐassociate
ํจ์๋ ํ๋์ ๋๋ค(lambda) ํจ์๋ฅผ ์ธ์๋ก ๋ฐ์ต๋๋ค. ์ด ๋๋ค ํจ์๋ ๋ค์๊ณผ ๊ฐ์ ์ญํ ์ ์ํํฉ๋๋ค.
Iterable์ ๊ฐ ์์๋ฅผ ํ๋์ฉ ์ํํฉ๋๋ค.
๊ฐ ์์์ ๋ํด
Pair
๊ฐ์ฒด๋ฅผ ๋ฐํํฉ๋๋ค. ์ดPair
๊ฐ์ฒด๋key
์value
๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด,item.id to item.name
๊ณผ ๊ฐ์ดto
์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌPair
๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.associate
ํจ์๋ ์ดPair
๋ค์ ๋ชจ์์ ์๋ก์ดMap<Key, Value>
๋ฅผ ์์ฑํฉ๋๋ค.
๋ง์ฝ ๋์ผํ ํค๊ฐ ์ฌ๋ฌ ๋ฒ ์์ฑ๋๋ค๋ฉด, ๋ง์ง๋ง์ ์์ฑ๋ ํค-๊ฐ ์์ด ์ต์ข
๋งต์ ํฌํจ๋ฉ๋๋ค. ์ด ์ ์ associate
ํจ์๋ฅผ ์ฌ์ฉํ ๋ ํนํ ์ฃผ์ํด์ผ ํ ๋ถ๋ถ์
๋๋ค.
๊ธฐ๋ณธ์ ์ธ ํํ: fun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>
Iterable<T>
:associate
ํจ์๋ฅผ ํธ์ถํ๋ ์๋ณธ ์ปฌ๋ ์ ์ ๋๋ค.T
๋ ์ปฌ๋ ์ ์์์ ํ์ ์ ๋๋ค.transform: (T) -> Pair<K, V>
: ๊ฐ ์์T
๋ฅผ ๋ฐ์์Pair<K, V>
๋ฅผ ๋ฐํํ๋ ๋๋ค ํจ์์ ๋๋ค.K
๋ ๋งต์ ํค ํ์ ,V
๋ ๋งต์ ๊ฐ ํ์ ์ ๋๋ค.Map<K, V>
: ์ต์ข ์ ์ผ๋ก ๋ฐํ๋๋ ๋งต ๊ฐ์ฒด์ ๋๋ค.
associate
ํจ์์ ์ค์ ๋์
associate
ํจ์์ ์ค์ ๋์๋ค์์ associate
ํจ์๊ฐ ์ด๋ป๊ฒ ๋์ํ๋์ง ๋ณด์ฌ์ฃผ๋ ๊ฐ๋จํ ์์ ์
๋๋ค. User
๋ผ๋ ๋ฐ์ดํฐ ํด๋์ค๊ฐ ์๊ณ , ์ด ๋ฆฌ์คํธ๋ฅผ id
๋ฅผ ํค๋ก ํ๋ ๋งต์ผ๋ก ๋ณํํด ๋ณด๊ฒ ์ต๋๋ค.
data class User(val id: Int, val name: String, val age: Int)
fun main() {
val users = listOf(
User(1, "Alice", 30),
User(2, "Bob", 25),
User(3, "Charlie", 35)
)
// users ๋ฆฌ์คํธ๋ฅผ id๋ฅผ ํค๋ก, User ๊ฐ์ฒด ์ ์ฒด๋ฅผ ๊ฐ์ผ๋ก ํ๋ ๋งต์ผ๋ก ๋ณํ
val userMap: Map<Int, User> = users.associate { user ->
user.id to user
}
// ๊ฒฐ๊ณผ ์ถ๋ ฅ
println(userMap)
// ์ถ๋ ฅ ๊ฒฐ๊ณผ: {1=User(id=1, name=Alice, age=30), 2=User(id=2, name=Bob, age=25), 3=User(id=3, name=Charlie, age=35)}
// ๋งต์์ ํน์ id๋ฅผ ๊ฐ์ง ์ ์ ์ฐพ๊ธฐ
val alice = userMap[1]
println(alice)
// ์ถ๋ ฅ ๊ฒฐ๊ณผ: User(id=1, name=Alice, age=30)
}
์ด ์์ ์์ users.associate { user -> user.id to user }
๋ถ๋ถ์ด ํต์ฌ์
๋๋ค.
users
๋ฆฌ์คํธ์ ์ฒซ ๋ฒ์งธ ์์์ธUser(1, "Alice", 30)
๊ฐ ๋๋ค๋ก ์ ๋ฌ๋ฉ๋๋ค.๋๋ค๋
1 to User(...)
(Pair(1, User(...))
)๋ฅผ ๋ฐํํฉ๋๋ค.associate
๋ ์ดPair
๋ฅผ ์๋ก์ด ๋งต์ ์ถ๊ฐํฉ๋๋ค.1
์ด ํค,User(...)
๊ฐ ๊ฐ์ด ๋ฉ๋๋ค.๋ค์ ์์์ธ
User(2, "Bob", 25)
์ ๋ํด์๋ ๋์ผํ ๊ณผ์ ์ด ๋ฐ๋ณต๋ฉ๋๋ค.์ต์ข ์ ์ผ๋ก ๋ชจ๋ ์์์ ๋ํ ๋ณํ์ด ๋๋๋ฉด,
Map<Int, User>
๊ฐ ์์ฑ๋ฉ๋๋ค.
associate
์ ์ ์ฌํ ํจ์๋ค ๋น๊ต
associate
์ ์ ์ฌํ ํจ์๋ค ๋น๊ตKotlin์๋ associate
์ ๋น์ทํด ๋ณด์ด๋ ๋ค๋ฅธ ํจ์๋ค๋ ์์ต๋๋ค. ์ด๋ค์ ๊ตฌ๋ถํ์ฌ ์ฌ์ฉํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
1. associateBy
associateBy
๋ associate
๋ณด๋ค ๋ ๊ฐ๊ฒฐํ๊ฒ ํค๋ง ์์ฑํ๊ณ , ์๋ณธ ๊ฐ์ฒด ์ ์ฒด๋ฅผ ๊ฐ์ผ๋ก ์ฌ์ฉํ๊ณ ์ถ์ ๋ ์ ์ฉํฉ๋๋ค. associate
๋ ํค์ ๊ฐ์ ๋ชจ๋ ์ง์ Pair
๋ก ๋ง๋ค์ด ๋ฐํํด์ผ ํ์ง๋ง, associateBy
๋ ํค๋ง ๋ฐํํ๋ ๋๋ค๋ฅผ ๋ฐ์ต๋๋ค.
ํํ: fun <T, K> Iterable<T>.associateBy(keySelector: (T) -> K): Map<K, T>
val userMapBy: Map<Int, User> = users.associateBy { it.id }
// ๊ฒฐ๊ณผ๋ ์ associate ์์ ์ ๋์ผํฉ๋๋ค.
2. associateWith
associateWith
๋ associateBy
์ ๋ฐ๋๋ก, ์๋ณธ ๊ฐ์ฒด๋ฅผ ํค๋ก ์ฌ์ฉํ๊ณ , ๊ฐ๋ง ์์ฑํ๊ณ ์ถ์ ๋ ์ ์ฉํฉ๋๋ค.
ํํ: fun <T, V> Iterable<T>.associateWith(valueTransform: (T) -> V): Map<T, V>
val userNameMap: Map<User, String> = users.associateWith { it.name }
// ๊ฒฐ๊ณผ: {User(...) -> "Alice", User(...) -> "Bob", User(...) -> "Charlie"}
Kotlin์ associate
ํจ์๋ ๋ฆฌ์คํธ๋ฅผ ๋งต์ผ๋ก ๋ณํํ๋ ๋งค์ฐ ์ ์ฐํ๊ณ ๊ฐ๋ ฅํ ๋๊ตฌ์
๋๋ค. associate
๋ ํค์ ๊ฐ์ ๋ชจ๋ ์ง์ ์ปค์คํฐ๋ง์ด์งํ์ฌ Pair
๋ก ๋ฐํํ๋ ๋ฐฉ์์ด๊ณ , associateBy
๋ ํค๋ง ์ง์ ํ๊ณ ๊ฐ์ ์๋ณธ ๊ฐ์ฒด๋ก ์ฌ์ฉํ๋ฉฐ, associateWith
๋ ํค๋ฅผ ์๋ณธ ๊ฐ์ฒด๋ก ์ฌ์ฉํ๊ณ ๊ฐ๋ง ์ง์ ํ๋ ๋ฐฉ์์
๋๋ค.
Last updated