์ปฌ๋ ์ ์ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํ์ฌ ํฌํจ๋ ์์๋ค์ ํ๋์ฉ ๊บผ๋ด์ ์ฌ์ฉํ๋ค.
ํ์ง๋ง ์ฝํ๋ฆฐ์ ํจ์ํ ์ธ์ด์ ํน์ง์ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์ ์ข ๋ ํธ๋ฆฌํ๊ฒ ์ปฌ๋ ์ ์ ์ฌ์ฉํ ์ ์๋ค.
์ปฌ๋ ์ ํจ์
- list, set, map๊ณผ ๊ฐ์ ์ปฌ๋ ์ ๋๋ ๋ฐฐ์ด์ ์ผ๋ฐ ํจ์ ๋๋ ๋๋ค ํจ์ ํํ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ๋ณต๋ฌธ ์์ด๋ ์์๋ฅผ ์ฐธ์กฐํ์ฌ ์ํํ๊ฑฐ๋ ์กฐ๊ฑด์ ๊ฑธ๊ณ ๊ตฌ์กฐ์ ๋ณ๊ฒฝ๊น์ง ๊ฐ๋ฅํ ์ฌ๋ฌ๊ฐ์ง ํจ์๋ฅผ ์ง์นญํ๋ค.
forEach
์ปฌ๋ ์ ๊ฐ์ฒด์ ์ฌ์ฉํ๋ฉด ์ค๊ดํธ ์์์ ์ปฌ๋ ์ ์ ํฌํจ๋ ๋ชจ๋ ์์๋ฅผ it์ด๋ผ๋ ๋ณ์๋ก ์์๋๋ก ์ฐธ์กฐํ ์ ์๋ค.
collection.forEach{
println(it)
}
filter
์ปฌ๋ ์ ๊ฐ์ฒด์ ์ฌ์ฉํ๋ฉด ์ค๊ดํธ ์์์ it์ ์กฐ๊ฑด์ ๊ฑธ์ด ์กฐ๊ฑด์ ๋ง๋ ๊ฐ์ฒด๋ง ๋ค์ ์ปฌ๋ ์ ์ผ๋ก ๋ง๋ค์ด ๋ฐํํ๋ค.
collection.forEach{
it < 4
}
map
์ค๊ดํธ ์์์ it์ ์์์ ์ ์ฉํ์ฌ ์ผ๊ด์ ์ผ๋ก ์์๋ค์ ๊ฐ์ ๋ณ๊ฒฝํ ํ ๋ณ๊ฒฝํ์ ๊ฐ์ฒด๋ฅผ ๋ค์ ์ปฌ๋ ์ ์ผ๋ก ๋ง๋ค์ด ๋ฐํํ๋ค.
collection.forEach{
it * 4
}
any, all, none
- ์ค๊ดํธ ์์์ it์ ์กฐ๊ฑด์ ๊ฑธ์ด์ค ๋ค
- any : ํ๋๋ผ๋ ์กฐ๊ฑด์ ๋ง์ผ๋ฉด true๋ฅผ ๋ฐํํ๋ค.
- all : ๋ชจ๋ ์กฐ๊ฑด์ ๋ง์ผ๋ฉด true๋ฅผ ๋ฐํํ๋ค.
- none : ํ๋๋ผ๋ ์กฐ๊ฑด์ ๋ง์ง ์์ผ๋ฉด true๋ฅผ ๋ฐํํ๋ค.
first
์ผ๋ฐํจ์๋ก ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ์ฒซ๋ฒ์งธ ์์๋ฅผ ๋ฐํํ๋ค.
๋๋คํจ์ ํํ๋ก ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ์ค๊ดํธ ์์ it์ ์กฐ๊ฑด์ ๊ฑธ์ด์ฃผ๋ฉด, ์กฐ๊ฑด์ ๋ง๋ ์ฒซ๋ฒ์งธ ์์๋ฅผ ๋ฐํํ๋ค.
find ํจ์๋ก ๋์ฒดํ ์ ์๋ค.
last
์ผ๋ฐํจ์๋ก ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๋ง์ง๋ง ์์๋ฅผ ๋ฐํํ๋ค.
๋๋คํจ์ ํํ๋ก ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ์ค๊ดํธ ์์ it์ ์กฐ๊ฑด์ ๊ฑธ์ด์ฃผ๋ฉด, ์กฐ๊ฑด์ ๋ง๋ ๋ง์ง๋ง ์์๋ฅผ ๋ฐํํ๋ค.
findLast ํจ์๋ก ๋์ฒดํ ์ ์๋ค.
firstOrNull & lastOrNull
firstํจ์์ lastํจ์๋ ์กฐ๊ฑด์ ๋ง๋ ๊ฐ์ฒด๊ฐ ์๋ ๊ฒฝ์ฐ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.(NoSuchElementException)
firstOrNull์ด๋ lastOrNull ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๋ ์ ์ ๊ฐ์ฒด๊ฐ ์๋๊ฒฝ์ฐ Null์ ๋ฐํํ๋ค.
count
์ผ๋ฐํจ์๋ก ์ฌ์ฉํ๋ฉด ํฌํจ๋ ๋ชจ๋ ์์ดํ ์ ๊ฐ์๋ฅผ ๋ฐํํ๋ค.
์ค๊ดํธ์ ํจ๊ป it์ ์กฐ๊ฑด๋ฌธ์ ๊ฑธ๋ฉด ์กฐ๊ฑด์ ๋ง๋ ์์์ ๊ฐ์๋ฅผ ๋ฐํํ๋ค.
์์
fun main(){
val nameList = listOf("๊นํ์ธ", "๊น์ฒ ์", "๊น์ํฌ", "ํ๊ธธ๋", "์ด์์ ")
nameList.forEach{ print(it + " ") }
println()
println(nameList.filter { it.startsWith("๊น") })
println(nameList.map{ "์ด๋ฆ : " + it})
println(nameList.any{ it == "์ฅ์์ค" })
println(nameList.all{ it.length == 3 })
println(nameList.none { it.startsWith("๋ฐ") })
println(nameList.first { it.startsWith("๊น")})
println(nameList.last { it.startsWith("๊น")})
println(nameList.count { it.startsWith("ํ")})
}
๊นํ์ธ ๊น์ฒ ์ ๊น์ํฌ ํ๊ธธ๋ ์ด์์
[๊นํ์ธ, ๊น์ฒ ์, ๊น์ํฌ]
[์ด๋ฆ : ๊นํ์ธ, ์ด๋ฆ : ๊น์ฒ ์, ์ด๋ฆ : ๊น์ํฌ, ์ด๋ฆ : ํ๊ธธ๋, ์ด๋ฆ : ์ด์์ ]
false
true
true
๊นํ์ธ
๊น์ํฌ
1
accociateBy
- ์ปฌ๋ ์ ์ ๊ฐ์ฒด(์์)์์ key๋ฅผ ์ถ์ถํ์ฌ map์ผ๋ก ๋ณํํ๋ ํจ์๋ค.
collection.associateBy{it.name}
groupBy
- key๊ฐ ๊ฐ์ ์์๋ผ๋ฆฌ ๋ฐฐ์ด๋ก ๋ฌถ์ด map์ผ๋ก ๋ง๋๋ ํจ์๋ค.
collection.groupBy{it.birthYear}
partition
- ์์ดํ ์ ์กฐ๊ฑด์ ๊ฑธ์ด ๋๊ฐ์ ์ปฌ๋ ์ ์ผ๋ก ๋๋์ด ์ค๋ค.
- ๋๋์ด์ง ๋ ์ปฌ๋ ์ ์ Pair๋ผ๋ ํด๋์ค์ ๋ด๊ฒจ ํ๋์ ๊ฐ์ฒด๋ก ๋ฐํ๋๋ค.
- Pair์์ ๋ ์ปฌ๋ ์ ์ first, second๋ก ์ฐธ์กฐํ๋ค.
- ๋๋ ๋ณ์ ์ ์ธ์ ๊ดํธ๋ก ๋ณ์๋ฅผ ๋ ๊ฐ ์ ์ธํด์ฃผ๋ฉด ๊ฐ๊ฐ์ ๋ณ์ ์ด๋ฆ์ผ๋ก ๋ฐ์ ์ ์๋ค.
collection.partition{it.birthYear > 2022}
//๋๋
val(over2022, under2022) = collection.partition{it.birthYear > 2022}
์์
fun main(){
data class Person(val name: String, val birthYear: Int)
val personList = listOf(Person("ํ์ธ", 1000),
Person("์ฒ ์", 2000),
Person("์ํฌ,", 2001),
Person("์ฒ ์", 2004))
println(personList.associateBy { it.birthYear })
println(personList.groupBy { it.name })
val(over2002, under2002) = personList.partition { it.birthYear > 2002 }
println(over2002)
println(under2002)
}
{1000=Person(name=ํ์ธ, birthYear=1000), 2000=Person(name=์ฒ ์, birthYear=2000), 2001=Person(name=์ํฌ,, birthYear=2001), 2004=Person(name=์ฒ ์, birthYear=2004)}
{ํ์ธ=[Person(name=ํ์ธ, birthYear=1000)], ์ฒ ์=[Person(name=์ฒ ์, birthYear=2000), Person(name=์ฒ ์, birthYear=2004)], ์ํฌ,=[Person(name=์ํฌ,, birthYear=2001)]}
[Person(name=์ฒ ์, birthYear=2004)]
[Person(name=ํ์ธ, birthYear=1000), Person(name=์ฒ ์, birthYear=2000), Person(name=์ํฌ,, birthYear=2001)]
flatMap
- ์์๋ง๋ค ๋ง๋ค์ด์ง ์ปฌ๋ ์ ์ ํฉ์ณ์ ๋ฐํํ๋ค.
- ์ค๊ดํธ์์ ์์๋ง๋ค ์๋ก์ด ์ปฌ๋ ์ ์ ์์ฑํ๋ฉด ์ด๋ฅผ ํฉ์ณ์ ํ๋์ ์ปฌ๋ ์ ์ผ๋ก ๋ฐํํ๋ค.
- collection.flatMap{ listOf(it*3, it+3) }
์ปฌ๋ ์ ์ 2, 3 ์ด ๋ค์ด์์๋ค๋ฉด ๋ฐํ๋ ์ปฌ๋ ์ ์ 6, 5, 9, 6 ์ด๋ค.
getOrElse
- ๊ดํธ์์ ์ธ๋ฑ์ค ์์น๋ฅผ ๋ฃ๊ณ , ํด๋น ์ธ๋ฑ์ค ์์น์ ์ ์์๊ฐ ์์ผ๋ฉด ์์๋ฅผ ๋ฐํํ๊ณ ์๋ค๋ฉด ์ค๊ดํธ์ ์ง์ ํ ๊ธฐ๋ณธ๊ฐ์ ๋ฐํํ๋ค.
// collection = [6, 5, 9, 6]
collection.getOrElse(1){50} // ์ธ๋ฑ์ค 1์ ์์นํ 5 ๋ฐํ
collection.getOrElse(8){50} // ์ธ๋ฑ์ค 8 ์์ผ๋ฏ๋ก ๊ธฐ๋ณธ๊ฐ 50 ๋ฐํ
zip
- ์ปฌ๋ ์ ๋ ๊ฐ์ ์์๋ฅผ 1๋1๋ก ๋งค์นญํ์ฌ Pairํด๋์ค์ ๋ด์ ํ ๋ฆฌ์คํธ์ ๋ฃ์ด ๋ฐํํ๋ค.
- ์ด ๋ ๊ฒฐ๊ณผ ๋ฆฌ์คํธ์ ์์ ๊ฐ์๋ ๋ ์์ ์ปฌ๋ ์ ์ ๋ฐ๋ผ๊ฐ๊ฒ ๋๋ค.
์์
fun main(){
val numbers = listOf(-3, 7, 2, -10, 1)
println(numbers.flatMap { listOf(it * 10, it + 10) })
println(numbers.getOrElse(1){50})
println(numbers.getOrElse(10){50})
val names = listOf("A", "B", "C", "D")
println(names zip numbers)
}
[-30, 7, 70, 17, 20, 12, -100, 0, 10, 11]
7
50
[(A, -3), (B, 7), (C, 2), (D, -10)]
๐ก์ปฌ๋ ์ ์ ์ฌ์ฉํด์ผํ๋ ์ํฉ์์ ์ปฌ๋ ์ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐ๋ณต๋ฌธ๊ณผ ์กฐ๊ฑด๋ฌธ์ ๋๋ถ๋ถ ๋์ฒดํ ์ ์๋ค.
๐ก์ปฌ๋ ์ ํจ์๋ ๋๋ค ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ปฌ๋ ์ ์ ์ข ๋ ํธ๋ฆฌํ๊ฒ ์กฐ์ํ ์ ์๋ ์ฅ์ ์ ๊ฐ์ง ํจ์๋ค.
๐ก์ปฌ๋ ์ ํจ์๋ ๋ฐ์ดํฐ ์กฐ์์ ๋ ์์ํ๊ฒ ๋ง๋ค ์ ์๋ ๋ค์ํ ๊ธฐ๋ฅ์ ๊ฐ์ง๊ณ ์๋ค.
'์๋๋ก์ด๋๐ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ฝํ๋ฆฐ] ๋นํธ์ฐ์ฐ (0) | 2024.07.09 |
---|---|
[์ฝํ๋ฆฐ] ์์, ๋ฆ์ ์ด๊ธฐํ, ์ด๊ธฐํ ์ง์ฐ (0) | 2024.07.08 |
[์ฝํ๋ฆฐ] Set & Map (0) | 2024.07.08 |
[์ฝํ๋ฆฐ] Data Class & Enum Class (1) | 2024.07.08 |
[์ฝํ๋ฆฐ] ์ค์ฒฉ ํด๋์ค์ ๋ด๋ถ ํด๋์ค (0) | 2024.07.07 |