์ ์ด ํ๋ฆ์ ๊ณ์ฐ์ ์์๋ฅผ ์ ํ๋ ๊ฒ์
๋๋ค.
์์์ ํจ๊ป ๊ณต๋ถํด๋ณด๊ฒ ์ต๋๋ค.
if๋ฌธ์ ์กฐ๊ฑด๋ฌธ์ ์๋ฏธํฉ๋๋ค. if๋ฌธ์ ํ์์
if(์กฐ๊ฑด๋ฌธ){
์คํ๋ฌธ
}
else if{
์คํ๋ฌธ}
else{
์คํ๋ฌธ}
if ๋ค์ ์ค๋ ์กฐ๊ฑด๋ฌธ์ด ์ฐธ์ด๋ผ๋ฉด ๋ค์์ ์ค๋ ์คํ๋ฌธ์
์๋๋ผ๋ฉด else if์ ์กฐ๊ฑด๋ฌธ์ ํ์ธํฉ๋๋ค. ์กฐ๊ฑด์ด ๋ง๋ค๋ฉด ๋ค์ ์คํ๋ฌธ์ ์คํํ๊ณ
์๋๋ผ๋ฉด else์ ์ฝ๋๋ฅผ ์คํํฉ๋๋ค.
์กฐ๊ฑด์ ๋ฐ๋ผ ์คํํ ๋ฌธ์ฅ๊ณผ ์คํํ์ง ์์ ๋ฌธ์ฅ์ด ๋๋ ์ ์ฒด ํ๋ฆ์ ์ ์ดํ๋ ๊ฒ์
๋๋ค.
์ฝํ๋ฆฐ์ ์์ ํ null์ฒ๋ฆฌ๋ฅผ ์ํด์ ์๋น์ค ์ฐ์ฐ์๋ผ๋ ๊ฒ์ ์ฌ์ฉํฉ๋๋ค.
?:(์๋น์ค ์ฐ์ฐ์)๋ฅผ ์ฌ์ฉํ์ฌ ํด๋น ๊ฐ์ด null์ผ ๋์ default ๊ฐ์ ์ค์ ํ ์ ์์ต๋๋ค. ์๋น์ค ์ฐ์ฐ์๋ ?:default๊ฐ์ผ๋ก ์ฌ์ฉํฉ๋๋ค.
ex)
fun main(args: Array<String>) {
val a:Int ?=null
val b:Int=a ?: 10
println(b)
}
์ ์ฝ๋์ ์คํ ๊ฒฐ๊ณผ๋ 10์ด ์ถ๋ ฅ๋ฉ๋๋ค. b์๊ฒ a๊ฐ์ ๋์ ํ์์ ๋ a๊ฐ null์ด๋ฏ๋ก ์๋น์ค ์ฐ์ฐ์ด ์คํ๋์ด 10์ด๋ผ๋ default๊ฐ์ด ๋์ ๋ ๊ฒ์ด์ฃ .
when์ ํ๊ตญ์ด๋ก ์ง์ญํ๋ฉด ์ธ์ ์
๋๋ค.
๋ป์ฒ๋ผ when์ ์ฉ๋๋ ์ธ์ ๋ฌด์์ ํ ๊ฑด์ง์ ๋ํ ๋ด์ฉ์
๋๋ค.
when๋ฌธ์ ์๋ฐ๋ ๋ค๋ฅธ ์ธ์ด์ switch case๋ฌธ๊ณผ ์ฌ์ฉ ๋ฐฉ๋ฒ๋ง ๋ค๋ฅผ ๋ฟ,
๋ด์ฉ์ ๋๊ฐ์ต๋๋ค. when๋ฌธ์ ์ฌ์ฉ๋ฐฉ์์
when(value){
vlaue์ ๊ฐ->{์คํ๋ฌธ}
else ->{์คํ๋ฌธ}
}
์ ํํ๋ฅผ ๊ฐ์ต๋๋ค.
if๋ฌธ์ผ๋ก๋ ๊ฐ์ ๋์์ ์ํํ ์ ์์ง๋ง when๋ฌธ์ ์ฌ์ฉํ์์ ๋์ ์ฝ๋์ ์ฉ๋๊ฐ ๋ช
ํํ๊ณ ๊ฐ๋
์ฑ์ด ์ข์์ง๋๋ค.
๋น์ทํ ์ฉ๋์ ๋ณ์๊ฐ ๋ง์ด ํ์ํ ๋, ํ๋ํ๋ ๋ณ์๋ฅผ ์ ์ธํ๊ณ ์ฌ์ฉํ๋ ๊ฒ์ ๊ต์ฅํ ๋ถํธํ๊ณ ๋นํจ์จ์ ์ ๋๋ค. ๊ทธ๋์ ์ฐ๋ฆฌ๋ ๋ฐฐ์ด์ ์ฌ์ฉํฉ๋๋ค.
๋ฐฐ์ด์ ์ ์ธํ๋ ๋ฐฉ๋ฒ์๋ ๋๊ฐ์ง๊ฐ ์์ต๋๋ค.
var arr = arrayOf<Int>(1,2,3,4)
var arr = arrayOf(1,2,3,4)
์ด ๋ ๋ฐฐ์ด์ ๊ฐ์๋ ์๋ฌด ์๋ฃํ์ด๋ ๋ค์ด๊ฐ๋ ์๊ด ์์ต๋๋ค.
๋ฐฐ์ด์๋ index๋ผ๊ณ ๋ถ๋ฅด๋ ๋ฐฐ์ด์ ์์น๊ฐ ์์ต๋๋ค. ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ๊ฐ์ด 1,2,3,4๊ฐ ์๋ Intํ์ ๋ฐฐ์ด์ ์์ฑํ๋ค๋ฉด
1์ ๋ฐฐ์ด์ 0๋ฒ, 3์ 2๋ฒ index์ ๋ค์ด ์๋ ๊ฒ์ด์ฃ .
๊ทธ๋ผ index๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ๊ฐ์ ๊ฐ์ ธ์ค๊ฑฐ๋ ์์ ํ๋ ๋ฒ์ ์์๋ณด๊ฒ ์ต๋๋ค,
๋ฐฐ์ด๋ช
.get(index)์ ๋ฐฉ์์ผ๋ก index์ ์์น์ ์๋ ๊ฐ์ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค,
ex) arr.get(0) //๋ฐฐ์ด์ ์ฒ์ ๊ฐ์ด ๋ฐํ
๋ฐฐ์ด[index]๋ก๋ ๊ฐ๋ฅํฉ๋๋ค.
ex)arr[1] //๋ฐฐ์ด์ ๋๋ฒ์งธ ๊ฐ
๋ฐฐ์ด๋ช
.set(index,๊ฐ)์ผ๋ก index ์์น์ ์๋ ๊ฐ์ ์์ ํ ์ ์์ต๋๋ค.
ex) arr.set(0,3) // ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ๊ฐ์ 3์ผ๋ก ์์
Collection์ ๋ฐ์ดํฐ๋ค์ ์งํฉ์์ผ ๋์ ๊ฒ์ ๋งํฉ๋๋ค.
val ์ด๋ฆ=listOf<์๋ฃํ>=(๊ฐ)์ ํ์์ผ๋ก ์ ์ธํฉ๋๋ค.
๊ฐ์ ์ค๋ณต์ ์ ๊ฒฝ์ฐ์ง ์์ต๋๋ค.
ex)
var li= listOf<Int>(1,2,3,3,3)
println(li)
์คํ ํ๋ฉด
๋ฐฐ์ด๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ด๋ฆ.get(index) ํน์ ์ด๋ฆ[index]๋ก ๊ฐ์ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค.
๊ฐ์ด ์ค๋ณต๋๋ฉด ํ๋๋ก ์ทจ๊ธํ๋ Collection์
๋๋ค. ์๋ฃ์ ์์๊ฐ ์์ต๋๋ค.
val ์ด๋ฆ=setOf<์๋ฃํ>=๊ฐ์ ํ์์ผ๋ก ์ ์ธํฉ๋๋ค.
ex)
var setEx= setOf<Int>(1,2,3,3,3)
println(setEx)
์คํ ํ๋ฉด
key์ value๋ก ์๋ฃ๋ฅผ ๊ด๋ฆฌํฉ๋๋ค.
val ์ด๋ฆ=mapOf<key์ ์๋ฃํ,value์ ์๋ฃํ>(key to value)์ ํ์์ผ๋ก ์ ์ธํฉ๋๋ค.
์ง๊ธ๊น์ง ๋ฐฐ์ด Collection์ ๊ฐ์ด ๋ณํ์ง ์๋ Immutable Collection์
๋๋ค. ๋ฐ๋ผ์ set์ผ๋ก ๊ฐ์ ์์ ํ๊ฑฐ๋, ๊ฐ์ ์ถ๊ฐํ ์ ์์ต๋๋ค.
๊ฐ์ ๋ณ๊ฒฝํ๊ธฐ ์ํด์ Mutable Collection์ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
Mutable List์ ์ ์ธ ๋ฐฉ์๊ณผ ๊ฐ์ ๊ฐ์ ธ์ค๋ ๋ฐฉ์์ List์ ๊ฐ์ต๋๋ค.
val ์ด๋ฆ=mutableListOf<์๋ฃํ>(๊ฐ)
์ด๋ฆ.set(index,๊ฐ)์ผ๋ก ๊ฐ์ ๋ณ๊ฒฝํ๊ฑฐ๋ ์ด๋ฆ.add(index,๊ฐ)์ผ๋ก ๊ฐ์ ์ถ๊ฐํ ์ ์์ต๋๋ค. **์ด๋ฆ.removeAt(index)๋ก ๊ฐ์ ์ญ์ ํ ์ ์์ต๋๋ค.
ex)
val MnumList= mutableListOf<Int>(1,2,3)
println(MnumList)
MnumList.set(0,0) //0๋ฒ index์ ๊ฐ์ 0์ผ๋ก ์์
println(MnumList)
MnumList.add(3,4) //3๋ฒ index์ 4๋ฅผ ์ถ๊ฐ
println(MnumList)
์คํํ๋ฉด
Mutable Set์ ์ ์ธ ๋ฐฉ์์ Set๊ณผ ๊ฐ์ต๋๋ค.
val ์ด๋ฆ=mutableSetOf<์๋ฃํ>(๊ฐ)
์ด๋ฆ.add(๊ฐ)์ผ๋ก ๊ฐ์ ์ถ๊ฐํ ์ ์์ต๋๋ค.
์ด๋ฆ.remove(๊ฐ)์ผ๋ก ๊ฐ์ ์ ๊ฑฐํ ์ ์์ต๋๋ค.
ex)
val mNulSet = mutableSetOf<Int>(1, 2, 3, 3, 4)
println(mNulSet)
mNulSet.add(6)
println(mNulSet)
์คํ ํ๋ฉด
Mutable Map์ ์ ์ธ ๋ฐฉ์๋ Map๊ณผ ๊ฐ์ต๋๋ค.
val ์ด๋ฆ=mutableMapof<key์ ์๋ฃํ,value์ ์๋ฃํ>(key to value)
์ด๋ฆ.put(key,value)๋ก ๊ฐ์ ์ถ๊ฐํ ์ ์์ต๋๋ค.
์ด๋ฆ.replace(key,value)๋ก ๊ฐ์ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค.
ex)
val mNumMap= mutableMapOf<String,Int>("a" to 1,"b" to 2)
println(mNumMap)
mNumMap.put("c",3)
println(mNumMap)
์คํํ๋ฉด
- Collection์ ๋ํด์๋ ๊ตฌ๊ธ๋ง์ ํตํด ์กฐ๊ธ ๋ ์์๋ณด์.
- ์๋น์ค ์ฐ์ฐ์ ์ ๊ธฐํ๋ค.