[Kotlin] - Pair
Pair๋
Pair
๋, ํ ์;๋ ๋ถ๋ถ์ด ํจ๊ป ๋ถ์ด ํ๋๋ฅผ ์ด๋ฃจ๋ ๊ฒ์ ์๋ฏธํ๋ค.
kotlin
์์๋ ๋์ผํ๊ฒ ์์ ์๋ฏธํ๋ ํด๋์ค์ด๋ฉฐ, ํด๋์ค ๊ตฌ์กฐ๋ ์๋์ ๊ฐ์ด ์๊ฒผ๋ค.
public data class Pair<out A, out B>(
public val first: A,
public val second: B
) : Serializable
์์ธํ ๋ด์ฉ์ ๊ณต์ ๋ฌธ์๋ฅผ ์ฐธ๊ณ ํ๋ฉด ์ข์ ๊ฒ ๊ฐ๋ค.
Pair์ ์ฌ์ฉ
์์ ์ค๋ช ํ ๊ฒ๊ณผ ๊ฐ์ด 2๊ฐ์ ๋ณ์๋ฅผ ๋ฌถ์ด์ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ์ด๋ ํ ํ์ ์ด๋ ๋ฃ์ ์ ์๋ค.
๋ฐ์ดํฐ ์ ์ฅ
์๋ ์ฝ๋์ ๊ฐ์ด ๋ค์ํ ๋ฐฉ๋ฒ์ผ๋ก ์ ์๊ฐ ๊ฐ๋ฅํ๋ค.
var a = Pair(1, "์งฑ๊ตฌ")
val b = Pair<Int, String>(second = "์ฒ ์", first = 2)
val (c1, c2) = Pair(3, "์ ๋ฆฌ")
val (d1, d2) = 4 to "ํ๋ฐ๋กฌ"
์ฝ๊ฐ ์์ํ ์ฝ๋๊ฐ ์๋ค๋ฉด c1
, c2
๋ณ์๋ฅผ ๊ดํธ๋ก ๋ฌถ์ด ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.
Pair
๊ฐ ํ ์์ ์๋ฏธํ๋ ๊ฒ์ฒ๋ผ ํ ์์ ๋ณ์๋ก ๋ฌถ์ด์ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.
๋ฐ์ดํฐ ์ถ๋ ฅ
์ถ๋ ฅ์ Pair
์ ์ฒซ ๋ถ๋ถ์ ์ฌ์ฉํ๊ณ ์ถ๋ค๋ฉด first
๋ฅผ ํธ์ถํ๊ณ , ๋ ๋ฒ์งธ ๋ถ๋ถ์ ์ฌ์ฉํ๊ณ ์ถ๋ค๋ฉด second
๋ฅผ ํธ์ถํ๋ฉด ๋๋ค.
println("a.first = ${a.first} \t a.second = ${a.second}")
println("a = $a")
println("c.first = $c1 \t c.second = $c2")
// a.first = 1 a.second = ์งฑ๊ตฌ
println("a.first = ${a.first} \t a.second = ${a.second}")
// a = (1, ์งฑ๊ตฌ)
println("a = $a")
// b.first = 2 b.second = ์ฒ ์
println("b.first = ${b.first} \t b.second = ${b.second}")
// b = (2, ์ฒ ์)
println("b = $b")
// c.first = 3 c.second = ์ ๋ฆฌ
println("c.first = $c1 \t c.second = $c2")
// d.first = 4 d.second = ํ๋ฐ๋กฌ
println("d.first = $d1 \t d.second = $d2")
๋ฐ์ดํฐ ์์
์์ ํด๋์ค ๊ตฌ์กฐ๋ฅผ ๋ณด๋ฉด ์๋ฏ์ด val
๋ก ๋์ด ์์ด์ ๋ฐ์ดํฐ๋ฅผ ์์ ํ ์ ์๋ค.
๊ทธ๋ผ์๋ ๊ผญ ์์ ์ด ํ์ํ ๊ฒฝ์ฐ copy
๋ฅผ ํตํด ๋ค์ ํ ๋นํ๋ ๋ฐฉ์์ผ๋ก ํ ์ ์๋ค.
a = a.copy(first = 5, second = "๋")
๋ฐ์ดํฐ ์ ๋ ฌ
Pair
๋ ๋ค๋ฅธ ํด๋์ค์ ๋ค๋ฅด๊ฒ PriorityQueue
๋ฅผ ํตํด ์ ๋ ฌํ ์ ์๋ค.
fun main() {
val pq = PriorityQueue<Pair<Int, Int>>()
pq.offer(1 to 1)
pq.offer(2 to 2)
while (!pq.isEmpty()) {
val cur = pq.poll()
println(cur.first)
}
}
์์ ๊ฐ์ด ์์ฑํ๋ฉด ์ปดํ์ผ ํ์์๋ ์๋ฌ๋ ๋์ง ์์ง๋ง, ๋ฐํ์์์ ์๋์ ๊ฐ์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
Exception in thread "main" java.lang.ClassCastException:
class kotlin.Pair cannot be cast to class java.lang.Comparable
(kotlin.Pair is in unnamed module of loader 'app'; java.lang.Comparable is in module java.base of loader 'bootstrap')
์๋ฌ ๋ด์ฉ์ ์ดํด๋ณด๋ฉด Pair
ํด๋์ค๋ Comparable
๋ก ์บ์คํธํ ์ ์๋ค๋ ๋ด์ฉ์ด๋ค.
์ฆ, Comparable
์ ๊ตฌํํ์ง ์์ ๋ฌด์๊ณผ ๋น๊ต๋ฅผ ํด์ ์ ๋ ฌํ ์ง ์ ์๋์ด ์์ง ์๋ค๋ ๊ฒ์ด๋ค.
์ด๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ์๊ฐ๋ณด๋ค ๊ฐ๋จํ๋ค.
// ๋ฐฉ์ 1
val pq = PriorityQueue<Pair<Int, Int>>(Comparator() { a, b -> a.first - b.first })
// ๋ฐฉ์ 2
val pq = PriorityQueue<Pair<Int, Int>> { a, b -> a.first - b.first }
์์ ๊ฐ์ด Comparator
๋ฅผ ์ ๊ณตํด ์ ๋ ฌ์ ํด์ฃผ๋ฉด ๋๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ