기본 문법 - moggaa/kotlin-coding-test Wiki

배열

fun array(){

    //주어진 요소로 int 배열 생성
    val arr1 = intArrayOf(1,2,3)

    // 기본값을 가지는 int 배열 생성
    val arr2 = IntArray(10)

    // 값을 초기화 할 수 있는 int 배열 생성
    val arr3 = IntArray(10){
        it*2
    }

    // null 값으로 초기화하는 가지는 배열 생성
    val nullArr = arrayOfNulls<Int>(10)

    //다차원배열 생성
    val arr4 = Array(10){
        IntArray(10)
    }

    // 배열 -> 리스트
    val arrayToList = arr3.toList()
    val arrayToMutableList = arr3.toMutableList()

    //배열 출력 (테스트용)
    println(arr3.contentToString())
}

리스트

fun list(){
    //주어진 요소로 리스트 생성
    val list1= listOf(1,2,3)

    // 값을 초기화하는 리스트 생성
    val list2 = List(10){
        it
    }

    // 리스트 -> 배열
    val listToIntArray = list2.toIntArray()
    val listToArray = list2.toTypedArray()

    //리스트 슬라이싱 (array도 적용가능)
    val list3 = list2.slice(1..list2.lastIndex)
    val list4 = list2.slice(1 until list2.size)
    val list5 = list2.slice( 5 downTo 1 step 2 )

    //가변 리스트
    val list6 = MutableList(10){
        list2[it]
    }
    list6[5] = 1
    list6.add(10)

    //인덱스와 함께 for문
    for((index,value) in list6.withIndex()){
        println("$index $value")
    }
}

문자열

fun string(){
    val str = "abcdefghijklmnop"

    //문자열 내 문자 접근
    println(str[0])

    //문자열 slice
    str.slice(1..4)

    //문자열 split
    str.split(' ')

    //문자열 replace
    str.replace('c','f')

    //문자열 거꾸로
    println(str.reversed())

    //문자열 -> char array
    str.toCharArray()

    //해당하는 문자의 index
    str.indexOf('a')

    //해당 문자열 포함하는지
    println(str.contains("abc"))

    //해당 정규식 포함하는지
    println(str.matches(Regex(".*a")))
}

정렬

data class Person(var name : String, var age : Int)
fun sort(){
    var arr1 = intArrayOf(3,2,1)

    //배열 정렬
    arr1.sort()
    //내림차순 정렬
    arr1.sortDescending()

    //정렬된 새로운 배열 반환
    arr1.sortedArray()

    //배열 정렬 후 새로운 리스트 반환
    arr1.sorted()

    var arr2 = arrayOf(
        Person("Park", 10),
        Person("Park", 11),
        Person("Kim", 12),
        Person("Choi", 5),
        Person("Lee", 19)
    )

    //정렬 기준 설정
    arr2.sortBy{
        it.name
    }
    arr2.sortByDescending {
        it.name
    }

    //comparator 선언한 정렬
    arr2.sortWith(kotlin.Comparator { o1, o2 ->
        o1.name.compareTo(o2.name)
    })

    //compareBy 이용한 정렬
    arr2.sortWith(compareBy({it.name},{it.age}))

    arr2.sortWith(compareBy({-it.name.length},{it.age}))

    arr2.sortWith(compareByDescending<Person> { it.name }.thenBy { it.age })

    //대소문자 구분 없이 정렬
    arr2.sortWith(compareBy(String.CASE_INSENSITIVE_ORDER){it.name})

    
    //불변 컬렉션은 sorted로 새로운 리스트를 만들어야 한다.
    var list1 = listOf(
        Person("Park", 10),
        Person("Park", 11),
        Person("Kim", 12),
        Person("Choi", 5),
        Person("Lee", 19)
    )
    list1.sortedBy{it.age}
    
}

컬렉션

가장 좋은 큐 자료구조는 ?? : ArrayDeque를 사용하자

https://stackoverflow.com/questions/6129805/what-is-the-fastest-java-collection-with-the-basic-functionality-of-a-queue

fun dataStructure(){
    /**
     * 스택
     */
    val stack = mutableListOf<Int>()
    //push
    stack.add(10)
    //pop
    val num1 = stack.removeLast()
    //peek
    val num2 = stack.last()
    //isEmpty
    stack.isEmpty()

    /**
     * 큐
     */
    val queue:Queue<Int> = LinkedList()
    //추가
    queue.offer(32)
    //꺼내기
    val num3 = queue.poll()
    //peek
    val num4 = queue.peek()

    /**
     * 데크
     */

    val deque:Deque<Int> = ArrayDeque()
    //추가
    deque.addFirst(10)
    deque.addLast(20)
    //꺼내기
    deque.pollFirst()
    deque.pollLast()
    //peek
    deque.peekFirst()
    deque.peekLast()

    /**
     *  우선순위 큐
     */

    val pq1 = PriorityQueue<Int>()

    val pq2 = PriorityQueue<Int>(Collections.reverseOrder())

    val pq3 = PriorityQueue<Person>(compareBy { it.name })

    pq1.offer(10)
    pq1.poll()
    pq1.peek()

    /**
     * Set = map을 기반으로 만들어짐
     */

    //mutableSet = LinketHashSet
    val set1 = HashSet<Int>()
    set1.add(20)
    set1.add(10)
    for(num in set1){
        println(num)
    }

    //treeSet RB tree base
    val set2 = TreeSet<String>{ s1,s2 ->
        s1.length - s2.length
    }
    set2.add("aaaaa")
    set2.add("aa")
    for(str in set2){
        println(str)
    }
    
    //hashSet = 순서 미보장
    val set3 = HashSet<Int>()

    

    /**
     * 맵
     */
    //mutableMap = LinkedHashMap 순서보장
    val map = LinkedHashMap<Int,Int>()
    map[1]=1
    map[2]=2
    for((key,value) in map){
        println("$key $value")
    }

    //treeMap = RB tree base, 모든 연산이 O(logN) , 정렬된채로 출력 가능
    val map2 = TreeMap<String,Int>{c1,c2 ->
        c1.compareTo(c2)
    }
    map2["aaa"] = 2
    map2["bbb"] = 1
    for((key,value) in map2){
        println("$key $value")
    }

    //hasMap = 순서 미보장
    val map3 = HashMap<Int,Int>()

}
⚠️ **GitHub.com Fallback** ⚠️