[Kotlin] 코딩 테스트를 위한 코틀린 기본 문법 정리

😀 입출력

import java.io.*
import java.util.*

// 자바의 BufferedReader, InputStreamReader 이용
fun main(args: Array<String>) = with(BufferedReader(InputStreamReader(System.`in`))){

    val str = readLine() // 한줄 입력받기 (String)
    println(str) // 출력
    
    // 1 2 3 으로 들어온 입력 한번에 Type 바꿔 할당하기
    val (a,b,c) = readLine().split(" ").map { it.toInt() }
}

 

😀 String (문자열) 관련 메소드

fun main() {
    var str = "abcd"
    var str2 = "123"

    str.length // 문자열의 길이
    str[1] // 문자열의 특정 위치 접근
    str2.toInt() // 문자열 타입 변환 to'Type'()

    str.isEmpty() // 문자열 길이가 0이면 true, 아니면 false
    str.isBlank() // 문자열 길이가 0이거나 공백으로만 이루어져 있다면 true, 아니면 false
    str.contains("a") // 문자열에 a가 포함되어 있으면 true, 아니면 false
    str.compareTo("abd") // 문자열 사전순 비교, str 이 앞이면 -1, 같으면 0, 뒤면 1

    str.split(" ") // 공백으로 구분하여 List<String> 반환
    str.substring(2,4) // 2 ~ 3 위치 문자열 반환 (마지막 범위 포함 X)
    str.substring(1) // 1부터 끝까지 문자열 반환

    str.trim() // 문자열 앞 뒤 공백 제거 (문자열 사이 공백 제거 X) 결과 반환
    str.lowercase() // 대문자 => 소문자 결과 반환
    str.uppercase() // 소문자 => 대문자 결과 반환
    str.replace("a","b") // 문자열 "a"를 전부 "b"로 바꾼 결과 반환
    str.reversed() // 문자열 뒤집은 결과 반환

    str += "ef" // 문자열 추가
}

 

😀 StringBuilder 관련 메소드

코틀린에서 문자열을 합치기 위하여 자바의 StringBulider를 사용할 수 있다.

문자열을 단순히 '+' 연산을 실행하면 아예 새로운 문자열을 생성하기 때문에 효율이 떨어진다.

하지만 StringBulider는 문자열을 더하는 효율적인 방식으로 작동한다.

fun main() {
    val sb = StringBuilder()

    sb.append("abc") // 문자열 추가
    sb.insert(2,"ef") // 2 위치에 문자열 ef 삽입

    sb.delete(0, 2) // 0 ~ 1 범위의 문자열 삭제 (마지막 범위 포함 X)
    sb.deleteCharAt(1) // 1 위치의 문자 삭제
    
    sb.setCharAt(1, 'g') // 1 위치의 문자 g로 변경
    sb.reverse() // 문자열 뒤집기
    
    sb.setLength(0) // 문자열 길이 0으로 조절 (기존보다 짧은 길이면 삭제)
    sb.setLength(5) // 문자열 길이 5으로 조절 (기존보다 긴 길이면 공백으로 채움)

    // 배열의 숫자를 하나의 문자열로 합침 (1 2 3 4)
    val arr = arrayOf(1,2,3,4)
    arr.forEach { sb.append(it).append(' ') }
}

 

😀 Array, List, Set, Map

fun main(){

    // 1. Array
    /* 배열은 사이즈가 할당되어 있다. */
    val arr1 = arrayOf(1,2,3) // 1,2,3을 담은 배열 생성
    val arr2 = Array(3){0} // 크기가 3이고 초기값이 0인 배열 생성
    val arr3 = emptyArray<Int>() // Int 타입의 빈 배열 생성
    arr1[0] = 7 // 0번째 값을 7로 바꾼다 (배열은 Mutable 타입이기 때문에 수정 가능)


    // 2. List
    /* 리스트는 순서를 가지고, 사이즈가 자동으로 정해지며 기본은 Immutable 타입 */
    val list1 = listOf(1,2,3) // 1,2,3을 담은 리스트 생성
    val list2 = List(3){0} // 크기가 3이고 초기값이 0인 리스트 생성
    val list3 = arrayListOf<Int>(1,2,3) // 1,2,3을 담은 arrayList 생성 (Mutable)
    // list1[0] = 1 --> 오류발생 (수정 불가능)
    list3[0] = 1 // 0번째 값을 1로 바꾼다 (arrayList 는 Mutable 타입)
    list3.add(10) // 다음 값으로 10을 추가


    // 3. Set
    /* 집합은 순서를 가지지 않고, 중복 불가능. 사이즈가 자동으로 정해지며 기본은 Immutable 타입 */
    val set1 = setOf(1,2,3) // 1,2,3을 담은 Set 생성 (수정 불가)
    val set2 = mutableSetOf(1,2,3) // 1,2,3을 담은 mutableSet 생성 (수정 가능)
    set2.remove(2) // 집합에서 2 삭제


    // 4. Map
    /* 요소를 키와 값의 쌍의 형태로 저장. 키는 중복 불가능. 사이즈 자동, 기본 Immutable */
    val map1 = mapOf(1 to "Kim", 2 to "Han") // 수정 불가능
    val map2 = mutableMapOf(1 to "Kim", 2 to "Han") // 수정 가능
    map2.size // 맵의 사이즈 반환
    map2.keys // 맵의 모든 키 반환
    map2.values // 맵의 모든 값 반환
    map2.isEmpty() // 맵이 비어있으면 true, 아니면 false
    map2.containsKey(1) // 1에 해당하는 키가 있으면 true, 아니면 false
    map2.containsValue("Kim") // Kim에 해당하는 값이 있다면 true, 아니면 false
    map2[1] // 키에 해당하는 값 반환, 없다면 null
    map2.getOrDefault(1, "2") // 키에 해당하는 값 반환, 없다면 "2" 반환
    map2.put(3, "Lee") // 3과 Lee의 쌍 추가
    map2.remove(1) // 1에 해당하는 요소 제거
    map2.clear() // 초기화
}

 

😀 Collection 관련 메소드

fun main(){
    val list = arrayListOf(1,2,3,4,5)

    list.forEach() { print("$it " )} // 컬렉션에 포함된 모든 요소 출력
    list.minOrNull() // 컬렉션 최솟값 반환
    list.maxOrNull() // 컬렉션 최댓값 반환

    list.first() // 첫 번째 요소 반환
    list.first { it > 3 } // 조건에 맞는 첫 번째 요소 반환
    list.last() // 마지막 요소 반환
    list.last{it < 3} // 조건에 맞는 마지막 요소 반환

    list.filter { it < 3 } // 조건에 맞는 요소 반환
    list.map { it+5  } // 수식을 적용하여 값 변경하여 반환
    list.count() { it < 3 } // 조건에 맞는 요소의 개수 반환
    list.any { it < 3 } // 조건에 하나라도 일치하는 요소가 있다면 true
    list.all { it < 3 } // 모든 요소가 조건에 맞다면 true
    list.none { it < 3 } // 조건에 하나도 맞지 않으면 true

    list.reduce { acc, i -> acc * i } // 내부의 데이터를 다 모아줌
    list.fold(10) { acc, i -> acc * i } // 내부의 데이터를 다 모아줌 (초기값 지정)

    list.sorted() // 컬렉션 정렬하여 반환
    list.sortedDescending() // 컬렉션 정렬하여 반환 (내림차순)
    list.sort() // 컬렉션 정렬 (Mutable 타입만 가능)

    list.sortedBy { it } // 특정 기준점으로 컬렉션 정렬하여 반환
    list.sortedByDescending { it } // 특정 기준점 기준 컬렉션 정렬하여 반환 (내림차순)
}

 

😀 큐(Queue), 스택(Stack), 우선순위 큐(PriorityQueue)

import java.util.*

fun main(){

    // 1. Queue
    var q : Queue<Int> = LinkedList() // 큐로 선언하고 LinkedList 로 할당
    q.add(1)    // 객체를 큐에 추가 (큐가 가득찬 상태이면 illegalStateException 발생)
    q.offer(3)  // 객체를 큐에 추가 (큐가 가득찬 상태이면 false 반환)

    q.element()    // 맨 앞 객체 리턴 (큐가 비어있는 상태이면 NoSuchElementException 발생)
    q.elementAt(1) // 인덱스 값의 객체 리턴
    q.peek()   // 맨 앞 객체 리턴 (큐가 비어있는 상태이면 null 반환)

    q.remove()  // 삭제하면서 객체 반환 (큐가 비어있는 상태이면 NoSuchElementException 발생)
    q.poll()  // 삭제하면서 객체 반환 (큐가 비어있는 상태이면 false 반환)

    q.size // 큐 사이즈
    q.isEmpty() // 비어있으면 true, 아니면 false


    // 2. Stack
    var s = Stack<Int>()

    s.push(1) // 객체를 스택에 추가
    s.peek() // 맨 위의 객체 반환 (비어 있는 상태이면 EmptyStackException 발생)
    s.pop() // 맨 위의 객체 삭제하고 반환 (비어 있는 상태이면 EmptyStackException 발생)
    s.isEmpty() //비어있으면 true, 아니면 false
    s.size // 스택 사이즈


    // 3. PriorityQueue
    val pq = PriorityQueue<Int>() // 오름차순
    val pq2 = PriorityQueue<Int>(Collections.reverseOrder()) // 내림차순

    val pq3 = PriorityQueue<Node>()
}

// index 기준 비교 (오름차순)
data class Node(
    val index : Int,
    val value : Int
) : Comparable<Node> {
    override fun compareTo(other: Node): Int = index - other.index
}