[Kotlin] 코틀린 문법

변수 선언

val : 불변

var : 가변

if로 초기화도 가능

var a = if( true ) { 0 } else { 1}

 

for문

기본 for문

• for( i in 0..10 ) -> 0 ~ 10까지
• for( i in 10 downTo 0 ) -> 10 ~ 0까지
• for( i in a..z ) -> a ~ z 까지
• for(i in z downTo a) -> z ~ a 까지
• for( (index, element) in (a..z).withIndex() ) : 인덱스도 같이 줄수 있음

배열 for문

• for( element in array ) : 원소 반환
• for( index in array.indices ) : 인덱스 반환
• for( (index, element) in array.withIndex() ) : 인덱스 원소 같이 반환

 

문자열

문자/문자열 배열 합치기

val stringArray = arrayOf( "a", "b", "c")

stringArray.joinToString("") : 매개변수는 어떤 문자로 합칠건지

 

해당 index 문자바꾸기

val charArray = string.toCharArray()

charArray[i] = "x"

charArray.joinToString("")

 

배열

1차원

val array1 = arrayOf(1, 2, 3)
val array2 = Array(3) { i -> i + 1 }
    
array1 : [1, 2, 3]
array2 : [1, 2, 3]

 

2차원

val array1 = arrayOf(arrayOf(1, 2, 3), arrayOf(1, 2, 3))

val array2 = Array(2){i -> Array(3){j -> j+1} }

 

array1 : [[1, 2, 3], [1, 2, 3]]
array2 : [[1, 2, 3], [1, 2, 3]]

 

인트 배열 : arrayOf<Int> = intArrayOf, Array<Int> = IntArray

다른 형도 똑같음

 

정렬

원본 정렬 :

• array.sort(),
• array.sortDescending()

정렬된 상태 리턴 :

• array.sorted() - List 리턴,
• array.sortedDescending() - List 리턴,
• array.sortedArray() - 배열 리턴,
• array.sortedArrayDescending() - 배열 리턴

2차원 배열 정렬

sortBy -  하나의 기준으로 정렬

val array = arrayOf(arrayOf(4, 3), arrayOf(2, 1), arrayOf(5, 2), arrayOf(1, 5), arrayOf(3, 4))

array.sortBy { it[0] } 0번째 index로 정렬

array.sortBy { it[1] } 1번쨰 index로 정렬

 

sortWith - 2개 이상의 기준으로 정렬 (compareBy 사용 - 기준을 바꿈)

val array = arrayOf(arrayOf(4, 3), arrayOf(2, 7), arrayOf(5, 2), arrayOf(1, 5), arrayOf(2, 4))

 

0번째 index로 정렬 후 1번째 index로 정렬

• array.sortWith(compareBy({it[0]}, {it[1]})) 
• array.sortWith(compareBy<Array<Int>>{it[0]}.thenBy{it[1]})

> 객체도 똑같이 해주면됨

> thenBy를 쓸때는 <> 제네릭을 꼭 넣어줘야함

> compareBy({기준1}, {기준2}, {기준3}) 이게 더 편한듯 thenBy쓰는거보다

> 오름차순 내림차순 섞어서 쓰기 thenBy, thenByDescending

ex) 문자열 길이 정렬 -> 같으면 사전 역순 

 

앞뒤 정보를 비교할려면 Comparator{o1, o2 -> todo} 를 사용한다

Comparator는 sortWith에서 상용 가능함

array.sortWith(Comparator{o1, o2 -> todo})

val array = arrayOf<String>("a", "abb", "abcd", "abc", "aabcde")
array.sortWith(compareBy<String>{it.length}.thenByDescending { it })

 

출력

1차원 : array.contentToString()

다차원 : array.contentDeepToString()

 

List

immutable : ListOf(), emptyList()

mutable : mutableListOf(), arrayListOf() ... 여러 구현체들  - mutableList, arrayList 둘다 arrayList 를 반홤

여러 List가 있는데 mutableList는 인터페이스임 근데 지금은 arrayList를 반환해서 mutableListOf로 쓰면될듯

 

> 빈 List 로 초기화 할려면 <>재네릭을 써줘야함

ex) val list = mutableList<Int>

 

초기화도 가능

val list = mutableList(크기){ index -> index * 1} : [0, 1, 2, 3, ...]

 

list.add()

list.remove()

list.get() = list[index]

... java랑 똑같음

 

 

Set

List와 동일 중복허용x

immutable : setOf(), emptySet()

mutable : mutableSetOf() ... 여러 구현체들

여러 Set가 있는데 mutableSet는 인터페이스임 mutableSetOf는 LinkedHashSet을 반환

 

set.add

set.remove

...

get은 없음 -> list 화 해서 사용하면됨

 

map     

immutable : mapOf, emptyMap()

mutable : mutableMapOf() ... 여러 구현체들 (ex. hashMapOf(), linkedMapOf(), sortedMpaOf() ...)

 

map.put(key, value) == map[key] = value

map.get(key) == map[key]

map.replace(key, value) == map[key] = value

[key] 로 접근하는게 좋은듯

 

key있는지 확인 있으면 +1, key없으면 1넣음

map[key] = map[key]?.plus(1)?: 0

 

map to List

map.toList()

-> List<Pair<key, value>> 이런 List형태임

 

Collection 유용한 함수

maxOrNull : max 값 반환, 값이 없으면 null 반환

minOrNull : min 값 반환, 값이 없으면 null 반환

-> map에서는 maxOrNull { it.key } 이런식으로 사용 가능

 

maxWithOrNull : 여러 기준으로 찾기 가능

maxWithOrNull(compareBy({it.lenght}))

-> map에서는 maxWithOrNull(compareBy({it.value.length})) 이런식~

 

ex) 문자열 길이, 사전순

val list = mutableListOf<String>()

list.add("abcdaaa")
list.add("acaaaaa")
list.add("aeaaaaa")
list.add("abaaaaa")
list.add("abaaaaa")
list.add("abcaaaa")
println(list.maxWithOrNull(compareBy({it.length}, {it.maxOrNull()}))) // 사전순
println(list.maxWithOrNull(compareBy({it.length}, {it.minOrNull()}))) // 사전 역순

find() : 값 찾기

filter() : 특정 값 걸러내기

 

fold() : 누적합 구하기, 첫번째 초기값을 줄 수 있음 -> ex) list.fold(0){ total, i -> i+total}

reduce() : 누적합 구하기, 첫번째요소를 초기값으로 사용 -> ex) list.reduce{ total, i -> i+total}

total에 누적이 쌓임

 

...필요하면 더 찾으면서 정리하기

 

Stack

보통Stack, LinkedList, ArrayDeque로 구현 가능

기존 자바에서 Stack으로 써왔으니 Stack으로 쓰자

 

val stack = Stack<Int>()

stack.push()

stack.pop()

stack.peek()

stack.isEmpty()

stack.search() : peek가 1이고 +1씩 더해감, 없으면 -1

 

val stack = LinkedList<Int>()

stack.push()

stack.pop()

stack.peek()

stack.isEmpty()

 

queue와 stack둘다 linkedList로 구현가능한데 이는 뒤로 삽입이 되냐 앞으로 삽입이 되냐에 따라서 구분 가능

push를 사용하면 앞으로 삽입됨

val stack1 = LinkedList<Int>()
stack1.push(1)
stack1.push(2)
stack1.push(3)

println(stack1)

//[3, 2, 1]

 

val stack = ArrayDeque<Int>() 양방향 삽입이 가능한 queue

stack.push()

stack.pop()

stack.peek(0

stack.isEmpty()

queue와 stack둘다 ArrayDeque로 구현가능한데 이는 뒤로 삽입이 되냐 앞으로 삽입이 되냐에 따라서 구분 가능

push를 사용하면 앞으로 삽입됨

val stack2 = ArrayDeque<Int>()
stack2.push(1)
stack2.push(2)
stack2.push(3)

println(stack2)

//[3, 2, 1]

 

Queue

LinkedList, ArrayDeque로 구현가능

자바에서 LinkedList로 써왔으니 LinkedList로 쓰자

 

val queue = LinkedList<Int>()

queue.add()

queue.remove()

queue.peek()

queue.isEmpty()

queue와 stack둘다 linkedList로 구현가능한데 이는 뒤로 삽입이 되냐 앞으로 삽입이 되냐에 따라서 구분 가능

add를 사용하면 뒤로 삽입됨

val queue = LinkedList<Int>()

queue.add(1)
queue.add(2)
queue.add(3)

println(queue)

//[1, 2, 3]

 

val queue = ArrayDeque<Int>()

queue.add()

queue.remove()

queue.peek()

queue.isEmpty()

queue와 stack둘다 ArrayDeque로 구현가능한데 이는 뒤로 삽입이 되냐 앞으로 삽입이 되냐에 따라서 구분 가능

add를 사용하면 뒤로 삽입됨

val queue = ArrayDeque<Int>()

queue.add(1)
queue.add(2)
queue.add(3)

println(queue)

//[1, 2, 3]

 

Priority Queue

PriorityQeue로 구현가능 compareBy를 통해서 우선순위 기준을 정해줄 수 있음

val priorityQueue = PriorityQueue<Int>() 기본은 minHeap임

val priorityQueue = PriorityQueue<Int>(compareBy{-it}) : maxHeap

 

여러 기준

val pQueue = PriorityQueue<String>(compareBy({it.length}, {it})) 

-> 우선순위 - 문자열 길이, 같을경우 사전순

 

Pair, Triple 

클래스를 만들기 귀찮을때 사용하면 좋을듯?

val pair = Pair<Int, String> (1, "a")

first와 second로 접근 가능

pair.first -> 1

pair.second -> a

 

val triple = Triple<Int, Int, String>(1, 1, "a")

first, second, third로 접근가능

 

Elvis Operator

Elvis Operator는 ?: 이다

 

x 값이 Null일 때는 0을 저장하고 아니면 x값을 저장하게 하는 것

val dogName: String? = "Sulgi"

val nameLength: Int = if (dogName! = null) dogName.length else 0

----------------

val nameLength: Int = dogName?.length?:0

 

let

null 체크후 코드 실행해야 하는 경우

fun main(){
    var person : Person? = null
    val isReserved = person?.let{ it : Person ->
    	//Todo
    }
}

person이 null이 아닐경우 let 실행

 

run

수행 시킬 코드를 블록화 할때 사용하는듯

val queueProgresses = LinkedList<Int>()
val queueSpeeds = LinkedList<Int>()

var i = 0
queueSpeeds.forEach{element -> run{
    queueProgresses[i] += element
    i++
}}

forEach, forEachIndexed

collection 구조 반복문 쉽게 가능

array.forEach{ element -> todo}

 

forEachIndexed 를 쓰면 index도 활용 가능

array.forEachIndexed{ index, element -> todo }