๐ŸŽˆKotlin ์—ฌํ–‰๊ธฐ 2์ผ์ฐจ

์ดํ˜•์ง„ยท2020๋…„ 9์›” 19์ผ
0

์ฝ”ํ‹€๋ฆฐ ์—ฌํ–‰๊ธฐ

๋ชฉ๋ก ๋ณด๊ธฐ
2/5

์ง€๋‚œ ์—ฌํ–‰

  • val๊ณผ var
  • null
  • ํ•จ์ˆ˜
  • ์—ฐ์‚ฐ์ž

์˜ค๋Š˜ ๊ฐ€๋ณธ ๊ณณ

1. ์ œ์–ด ํ๋ฆ„

์ œ์–ด ํ๋ฆ„์€ ๊ณ„์‚ฐ์˜ ์ˆœ์„œ๋ฅผ ์ •ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.
์˜ˆ์‹œ์™€ ํ•จ๊ป˜ ๊ณต๋ถ€ํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

if๋ฌธ

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์˜ ์šฉ๋„๋„ ์–ธ์ œ ๋ฌด์—‡์„ ํ•  ๊ฑด์ง€์— ๋Œ€ํ•œ ๋‚ด์šฉ์ž…๋‹ˆ๋‹ค.
when๋ฌธ์€ ์ž๋ฐ”๋‚˜ ๋‹ค๋ฅธ ์–ธ์–ด์˜ switch case๋ฌธ๊ณผ ์‚ฌ์šฉ ๋ฐฉ๋ฒ•๋งŒ ๋‹ค๋ฅผ ๋ฟ,
๋‚ด์šฉ์€ ๋˜‘๊ฐ™์Šต๋‹ˆ๋‹ค. when๋ฌธ์˜ ์‚ฌ์šฉ๋ฐฉ์‹์€

when(value){
vlaue์˜ ๊ฐ’->{์‹คํ–‰๋ฌธ}
else ->{์‹คํ–‰๋ฌธ}
}

์˜ ํ˜•ํƒœ๋ฅผ ๊ฐ–์Šต๋‹ˆ๋‹ค.
if๋ฌธ์œผ๋กœ๋„ ๊ฐ™์€ ๋™์ž‘์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์ง€๋งŒ when๋ฌธ์„ ์‚ฌ์šฉํ•˜์˜€์„ ๋•Œ์˜ ์ฝ”๋“œ์˜ ์šฉ๋„๊ฐ€ ๋ช…ํ™•ํ•˜๊ณ  ๊ฐ€๋…์„ฑ์ด ์ข‹์•„์ง‘๋‹ˆ๋‹ค.

2. ๋ฐฐ์—ด

๋น„์Šทํ•œ ์šฉ๋„์˜ ๋ณ€์ˆ˜๊ฐ€ ๋งŽ์ด ํ•„์š”ํ•  ๋•Œ, ํ•˜๋‚˜ํ•˜๋‚˜ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•˜๊ณ  ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์€ ๊ต‰์žฅํžˆ ๋ถˆํŽธํ•˜๊ณ  ๋น„ํšจ์œจ์ ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ ์šฐ๋ฆฌ๋Š” ๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

๋ฐฐ์—ด์˜ ์„ ์–ธ

๋ฐฐ์—ด์„ ์„ ์–ธํ•˜๋Š” ๋ฐฉ๋ฒ•์—๋Š” ๋‘๊ฐ€์ง€๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

1. ์ž๋ฃŒํ˜• ๋ช…์‹œ

var arr = arrayOf<Int>(1,2,3,4)

2. ์ž๋ฃŒํ˜• ์ƒ๋žต

var arr = arrayOf(1,2,3,4)
์ด ๋•Œ ๋ฐฐ์—ด์˜ ๊ฐ’์—๋Š” ์•„๋ฌด ์ž๋ฃŒํ˜•์ด๋‚˜ ๋“ค์–ด๊ฐ€๋„ ์ƒ๊ด€ ์—†์Šต๋‹ˆ๋‹ค.

๋ฐฐ์—ด์˜ ์‚ฌ์šฉ

๋ฐฐ์—ด์—๋Š” index๋ผ๊ณ  ๋ถ€๋ฅด๋Š” ๋ฐฐ์—ด์˜ ์œ„์น˜๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฐฐ์—ด์˜ ์ธ๋ฑ์Šค๋Š” 0๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด ๊ฐ’์ด 1,2,3,4๊ฐ€ ์žˆ๋Š” Intํ˜•์˜ ๋ฐฐ์—ด์„ ์ƒ์„ฑํ–ˆ๋‹ค๋ฉด
1์€ ๋ฐฐ์—ด์˜ 0๋ฒˆ, 3์€ 2๋ฒˆ index์— ๋“ค์–ด ์žˆ๋Š” ๊ฒƒ์ด์ฃ .
๊ทธ๋Ÿผ index๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐฐ์—ด์˜ ๊ฐ’์„ ๊ฐ€์ ธ์˜ค๊ฑฐ๋‚˜ ์ˆ˜์ •ํ•˜๋Š” ๋ฒ•์„ ์•Œ์•„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค,

1. ๊ฐ€์ ธ์˜ค๊ธฐ

๋ฐฐ์—ด๋ช….get(index)์˜ ๋ฐฉ์‹์œผ๋กœ index์˜ ์œ„์น˜์— ์žˆ๋Š” ๊ฐ’์„ ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค,
ex) arr.get(0) //๋ฐฐ์—ด์˜ ์ฒ˜์Œ ๊ฐ’์ด ๋ฐ˜ํ™˜
๋ฐฐ์—ด[index]๋กœ๋„ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.
ex)arr[1] //๋ฐฐ์—ด์˜ ๋‘๋ฒˆ์งธ ๊ฐ’

2. ์ˆ˜์ •ํ•˜๊ธฐ

๋ฐฐ์—ด๋ช….set(index,๊ฐ’)์œผ๋กœ index ์œ„์น˜์— ์žˆ๋Š” ๊ฐ’์„ ์ˆ˜์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
ex) arr.set(0,3) // ๋ฐฐ์—ด์˜ ์ฒซ๋ฒˆ์งธ ๊ฐ’์„ 3์œผ๋กœ ์ˆ˜์ •

3. Collection

Collection์€ ๋ฐ์ดํ„ฐ๋“ค์„ ์ง‘ํ•ฉ์‹œ์ผœ ๋†“์€ ๊ฒƒ์„ ๋งํ•ฉ๋‹ˆ๋‹ค.

List

val ์ด๋ฆ„=listOf<์ž๋ฃŒํ˜•>=(๊ฐ’)์˜ ํ˜•์‹์œผ๋กœ ์„ ์–ธํ•ฉ๋‹ˆ๋‹ค.
๊ฐ’์˜ ์ค‘๋ณต์„ ์‹ ๊ฒฝ์“ฐ์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
ex)

    var li= listOf<Int>(1,2,3,3,3)
    println(li)

์‹คํ–‰ ํ™”๋ฉด

๊ฐ’ ๊ฐ€์ ธ์˜ค๊ธฐ

๋ฐฐ์—ด๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์ด๋ฆ„.get(index) ํ˜น์€ ์ด๋ฆ„[index]๋กœ ๊ฐ’์„ ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

Set

๊ฐ’์ด ์ค‘๋ณต๋˜๋ฉด ํ•˜๋‚˜๋กœ ์ทจ๊ธ‰ํ•˜๋Š” Collection์ž…๋‹ˆ๋‹ค. ์ž๋ฃŒ์— ์ˆœ์„œ๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค.
val ์ด๋ฆ„=setOf<์ž๋ฃŒํ˜•>=๊ฐ’์˜ ํ˜•์‹์œผ๋กœ ์„ ์–ธํ•ฉ๋‹ˆ๋‹ค.
ex)

    var setEx= setOf<Int>(1,2,3,3,3)
    println(setEx)

์‹คํ–‰ ํ™”๋ฉด

Map

key์™€ value๋กœ ์ž๋ฃŒ๋ฅผ ๊ด€๋ฆฌํ•ฉ๋‹ˆ๋‹ค.
val ์ด๋ฆ„=mapOf<key์˜ ์ž๋ฃŒํ˜•,value์˜ ์ž๋ฃŒํ˜•>(key to value)์˜ ํ˜•์‹์œผ๋กœ ์„ ์–ธํ•ฉ๋‹ˆ๋‹ค.

๊ฐ’์˜ ๋ณ€๊ฒฝ

์ง€๊ธˆ๊นŒ์ง€ ๋ฐฐ์šด Collection์€ ๊ฐ’์ด ๋ณ€ํ•˜์ง€ ์•Š๋Š” Immutable Collection์ž…๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ set์œผ๋กœ ๊ฐ’์„ ์ˆ˜์ •ํ•˜๊ฑฐ๋‚˜, ๊ฐ’์„ ์ถ”๊ฐ€ํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.
๊ฐ’์„ ๋ณ€๊ฒฝํ•˜๊ธฐ ์œ„ํ•ด์„  Mutable Collection์„ ์‚ฌ์šฉํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

Mutable List

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

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

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์— ๋Œ€ํ•ด์„œ๋Š” ๊ตฌ๊ธ€๋ง์„ ํ†ตํ•ด ์กฐ๊ธˆ ๋” ์•Œ์•„๋ณด์ž.
  • ์—˜๋น„์Šค ์—ฐ์‚ฐ์ž ์‹ ๊ธฐํ•˜๋‹ค.

0๊ฐœ์˜ ๋Œ“๊ธ€