Kotlin 기본 문법

✅ 변수와 함수 선언

변수 타입 변수명 : 자료형= 값
- var : 변경 가능
- val : 변경 불가능, 읽기 전용
fun 함수명(매개변수명: 매개변수타입): 반환타입 {동작}

var name: String = "이름"
val age: Int = 25
val x = 5
val y = 2

fun sayHello(name:String): String{
    return "Hello, $name"
}

//기본 출력
println("Welcome to $name")
//표현식 처리 가능
println("합은 ${x + y}입니다.")

✅ 조건문 if 와 when

fun checkMax( a: Int, b:Int){
 	var max : Int
    if (a>b){
    	max = a
    }else{
    	max = b
    }
    println("max : $max")
}

//코틀린은 if문도 표현식, 값을 반환할 수 있다
fun checkMax(a: Int, b:Int){
 	val max = if (a>b) a else b
    println("max : $max")
}

//when은 switch와 비슷한 역할을 수행
//val res = when (값){조건1 -> 반환값1 조건2 -> 반환값2 else -> 기본반환값}
fun getLabel(score:Int){
    val label = when(score){
        100 -> "perfect"
        in 90..99 -> "Excellent"
        in 80..89 -> "Good"
        in 0..79 -> "Needs Imporovement"
        else -> "invlaid"
    }
    println("when을 사용한 성적 구분 : $score 은 $label 입니다")
}

//조건 없는 when
fun notCondWhen(x:Int){
    val mess = when{
        x>0 -> "양수"
        x<0 -> "음수"
        else -> "0"
    }
    println(println("조건 없는 when : $mess"))
}

// is를 사용한 분기 가능
fun resWhenIs(x:Any){
    val resWhenIs = when(x){
        is String -> "문자열 , $x"
        is Int -> "정수 , $x"
        else -> "알 수 없음"
    }
    println("is를 사용한 타입별 분기 : $resWhenIs")
}

//함수 내부 return 값으로 사용
fun getColorCode(color: String): String = when (color) {
    "red" -> "#FF0000"
    "green" -> "#00FF00"
    "blue" -> "#0000FF"
    else -> "#000000"
}

✅ 반복문 for 과 while

범위 표현
for(i in 1..5)	1..5	1 2 3 4 5
for(i in 0 until 5)	until 5	0 1 2 3 4
for(i in 5 downTo 1)	downTo 1	5 4 3 2 1
for (i in 0..5 step 2)	step 2	0 2 4

//리스트 반복
val items = listOf("a", "b", "c")

for(i in items){
	println(i)
}

//인덱스와 값 동시 접근
for ((index, item) in items.withIndex()) {
    println("[$index] $item")
}

//람다식
items.forEach {item -> println("Item: $item")}

//판단 후 출력 - 아무것도 출력되지 않음
fun countDown() {
    var i = 5
    while (i > 5) {
        println("i = $i")
        i--
    }
}

//실행 후 판단 = i=5 출력 후 중지
fun countDownDo() {
    var i = 5
    do {
        println("i = $i")
        i--
    } while (i > 5)
}

✅ 안전 연산자

?를 사용한 nullable 타입 처리

fun printLeng(str:String?){
    println(str?.length) // null 일 경우 null, 아니면 길이 출력
    
    // ?: 엘비스 연산자
    // null 일 경우 세팅할 기본 값 제공
    val ifNull = str?.length ?: 0
    println("엘비스 연산처리 완료 후 값 : $ifNull") // null 일 경우 0 출력
    
    // !!을 사용한 강제 언래핑
    //nullPointerEx 발생
    // str!!.length
    
    // ?.let을 사용한 안전한 코드 실행
    //nul 체크 후 코드 블럭 실행
    str?.let{println("길이 : {it.length}")} //null 아니면 실행
}

✅ Collection Types - 값은 타입의 모음 List, Set, Map

List - 순서가 있는 컬렉션, 중복된 값 허용, 읽기 전용

fun printFruits(){
    val fruits = listOf("Apple","Banana","Cherry","Apple") //불변 리스트
    println(fruits) //[Apple, Banana, Cherry, Apple]
    println(fruits[1])
    
    for(f in fruits){
        println(f)
    }
}

fun modifyFruits(){
    val mutable = mutableListOf("Apple","Banana","Cherry") //수정 가능한 리스트
    mutable.add("Grape")
    mutable[0] = "Orange"
    println(mutable) //[Orange, Banana, Cherry, Grape]
}

set - 순서 없는 컬렉션, 중복 허용 안함

fun setFruits(){
    val fruits = setOf("Apple","Banana","Cherry","Apple") //중복 비허용
    println(fruits) // [Apple, Banana, Cherry]
    for(f in fruits){
        println(f)
    }
}

fun modifySetFruits(){
    val mutable = mutableSetOf("Apple","Banana","Cherry") //중복 자동 제거 및 셋 수정 가능
    mutable.add("Grape")
    mutable.add("Apple") //중복 데이터 추가 안됨
    println(mutable) //[Orange, Banana, Cherry, Grape]
}

Map<key,value> : 고유 키를 통해 값을 탐색하는 컬렉션 타입</key,value>
- Map<String,(Int, Int)->Int> : String 타입의 키를 통해 정수형 변수 두개를 받아 정수형은 값을 반환한 값을 찾는 변수
- mapOf : Map 객체를 생성하는 함수
- 키 생성 조건
  1. 기본 타입 전부 가능 ex) String, Int, Boolean ...
  2. 객체 타입일 정우 equals() 혹은 hashCode()가 정의 되어 있어야 한다
    - data class 사용 시 자동으로 equals, hashCode 생성
  3. null 사용 불가

// Map<key,value> = mapOf(
// 실제 구현 부
// "고유키" to 할당 값
// )
 
 fun main() {
    val fruits = mapOf("apple" to 3, "banana" to 2, "cherry" to 5)
    println(fruits)  // {apple=3, banana=2, cherry=5}
    println(fruits["banana"])  // 출력: 2
}

fun main() {
    val mutableFruits = mutableMapOf("apple" to 3, "banana" to 2) //수정 가능
    mutableFruits["cherry"] = 5  // 새로운 키-값 쌍 추가
    mutableFruits["apple"] = 4   // 기존 값 수정

    println(mutableFruits)  //{apple=4, banana=2, cherry=5}
}

fun main() {
   
    val add = operate(4,2){x,y -> x+y}
    val sub = operate(4,2){x,y -> x-y}
    val mul = operate(4,2){x,y -> x*y}
    println(add)
    println(sub)
    println(mul)
    
    //Map 사용
    val op = operatorMap["add"] ?: { _, _ -> 0 }
    // {_,_->0} : 기본 값으로 0을 반환하는 람다식
    println(op(10, 3))  // 13
}

fun operate(a: Int, b:Int, op:(Int, Int)->Int):Int{
    return op(a,b)
}

//동작을 함수 외부로 위임해서 유연한 코드 작성 가능
val operatorMap:Map<String, (Int, Int)->Int> = mapOf(
	"add" to {x,y -> x+y},
    "sub" to {x,y -> x-y},
    "mul" to {x,y -> x*y}
)

✅ 람다 함수 Lambda

이름 없는 함수로 변수에 할당하거나 다른 함수의 인자로 전달

fun main() {
    val sum = { x: Int, y: Int -> x + y }  // 두 값을 더하는 람다 함수
    println(sum(3, 5))  // 8
    
    val greet = { name: String -> "Hello, $name!" }
    println(greet("Kotlin"))  // Hello, Kotlin!
    
    var result = operate(5, 3) { a, b -> a + b }  
    println(result)  // 8
    
    result = operate(5, 3) { a, b -> a - b }
    println(result)  // 2
}

//고차 함수 - 람다함수가 매개변수인 경우
fun operate(x: Int, y: Int, op: (Int, Int) -> Int): Int {
    return op(x, y)  // 람다 함수를 실행하여 결과 반환
}

HaveYouEverON

Kotlin 기본 문법

티스토리툴바