Kotlin
#Kotlin 수업 정리 1
청춘고양이
2022. 11. 8. 19:22
반응형
import insertSort as insertSort
fun main(args: Array<String>) {
// 컬렉션 //
//arrayOf : 여러개의 변수를 지정 가능
//listOf : 불변의 리스트, 중복 가능
//setOf : 불변의 리스트, 중복 x ex -> setOf("1", "2", "3", "3") -> 뒤에 3은 찍히지 않음
//mapOf("a"to 1, "b"to 2, "c"to 3) 작성 예시, 키-값 형태로 변수를 여러개 저장 ,mapOf 또한 불변 키
//mutableListOf : 바꿀 수 있는 리스트
//mutableMapOf : 바꿀 수 있는 맵
//상호간 변화 가능 함.
//바꿀 수 없는 리스트틑 바꿀 수 있는 리스트로 만들 때에는 array.toMutableListOf() 사용 하면 됨
//바꿀 수 있는 리스트를 바꿀 수 없는 리스트로 만들 때에는 array.toList() 를 사용 => listOf(....)
val array = mutableListOf("1", "2", "3")
//val array = arrayOf("1","2","3")
array.forEachIndexed { idx, x ->
println("${idx}" + x)
}
println();
array[0] = "10"
//이렇게 하면 컴파일 에러 발생 이유는 이 부분은 값을 가져오기 때문 !, 따로 add 를 해줘야됨
//array[3] = "10"
array.add("10");
array.forEachIndexed { idx, x ->
println("${idx} " + x)
}
// 덧셈 뺄셈
//덧셈
var something1 = 1 + 1
var something2 = 1 + 1
var something3 = something1 + something2
//뺄셈
something1 = 1 - 1
something2 = 1 - 1
something3 = something1 - something2
//곱셈/나눗셈
something1 = 1 * 1
something2 = 1 * 1
something3 = something1 / something2
// 나머지 연산
something1 = 10 % 3
println(something1)
//Modular _ Shifting
something1 = 3 % 3 + 1
//++, --, Pre / Post
something1 = 1
println(something1++) // something1--
println(something1)
println(++something1) // --something1
println(something1)
//관계 연산
println(1 > 2)
println(1 < 2)
println(1 >= 2)
println(1 <= 2)
// kotlin 에서 삼항 연산은 없음
// 대신 엘비스 연산자를 사용 할 수 있음.
// 엘비스 -> null 이면 1을 찍음
println(null ?: 1)
//비트연산 예시
var x: Int = 2 // Bit : 0000 0000 0000 0010
var y: Int = 1 // Bit : 0000 0000 0000 0001
var z = x or y // Bit : 0000 0000 0000 0011
//좌측으로 밈
var sx = x shl 1 // Bit : 0000 0000 0000 0100
//우측으로 밈
var sy = x shr 1 // Bit : 0000 0000 0000 0001
// 비트와이즈라고 구글링하면 자료 많이 나옴.
x = 2
if (x > 2) {
println("x > 2")
} else if (x > 1) {
println("x > 1")
} else {
println("ELSE")
}
if (x > 2) {
return println("x > 2")
}
if (x > 1) {
return println("x > 1")
}
//코드 수정시 when 이 유연함.
when {
x > 1 -> {
println("x > 1")
}
x > 2 -> {
println("x > 2")
}
x > 3 -> {
println("x > 3")
}
else -> {
println("ELSE")
}
}
//명확하게 값을 아는 경우
when (x) {
1 -> {
println("x == 1")
}
2 -> {
println("x == 2")
}
else -> {
println("ELSE")
}
}
//반복문 : while(횟 수가 불명확 할 때), do-while, for(횟 수가 명확 할 때), for-in
x = 0
while (x < 10) {
print("$x ")
x++
}
println()
y = 0
do {
print("$y ")
y++
} while (y < 10)
println()
var range = 0..10
var list = listOf(1, 2, 3, 4, 5)
for (i in 0 until 5) {
print("${list[i]}")
}
println()
for (i in 4 downTo 0 step 2) {
print("${list[i]}")
}
println()
//1. 사람의 구조를 변수, 상수를 사용하요 선언
val head: Byte = 1
val body: Byte = 1
var arm: Byte = 2
val lag: Byte = 2
//Number 의 함수
//toByte, toShort, toInt, toFloat, toDouble, toBooLean, toString
//Unsigned 의 함수
//toUByte, toUShort, toUInt, toULong
arm = (arm.toByte() + 1.toByte()).toByte()
//2. 사람이 할 수 있는 동작 만들어보기
val action: () -> Unit = {
println("action")
}
action()
//3. 제어 및 반복
//1 == 점프 2 == 걷기 4 == 달리기 8 == 발차기
val user = 1
val jumpOption = 1 shl 0
val workOption = 1 shl 1
val runOption = 1 shl 2
val kickOption = 1 shl 3
val optionList = listOf<Int>(jumpOption, workOption, runOption, kickOption)
for (item in optionList) {
when (item) {
user and jumpOption -> println("점프")
user and workOption -> println("걷기")
user and runOption -> println("달리기")
user and kickOption -> println("발차기")
}
}
println("코틀린 구구단")
for (x in 2..9) {
println("== ${x}단 ==")
for (y in 1..9) {
println("$x x $y = ${x * y}")
}
}
//알고리즘1 : 정수 내림차순 정렬하기, for 문 사용
val list = arrayListOf(4, 2, 7, 1, 10, 6, 3, 8, 9, 5)
println("---- 정렬 후")
insertSort(list)
list.forEach { (print("${it}")) }
println("Program arguments: ${args.joinToString()}")
val targetList = mutableListOf<Int>(4, 2, 7, 1, 10, 6, 3, 8, 9, 5)
val swap: (MutableList<Int>, Int, Int) -> Unit = { it, iidx, jidx ->
val value = it[iidx]
it[iidx] = it[jidx]
it[jidx] = value
}
var min: Int
for (i in 0 until targetList.size - 1) {
min = i
for (j in i + 1 until targetList.size) {
if (targetList[min] > targetList[j]) min = j
}
swap(targetList, i, min)
}
//라벨 : GOTO 구문처럼 특정한 위치로 바로 이동할 수 있도록 라벨 처리 단, 함수 이름은 항상 라벨링된 것으로 간주
//패키지 : 파일의 묶음
//함수 : 하나의 특별한 목적의 작업을 수행하기 위해 독립적으로 설계된 프로그램 코드의 집합
//반환 값이 없을 경우 Unit 을 사용해서 void 처럼 사용 가능.
//함수 몸체가 단일 줄 일 경우 이퀄로 단일 줄 사용 가능
//가변 파라미터 : 가변적 개수만큼 파라미터를 사용하며, 배열로 취급
//중위 : 두 피연산자의 중간에 들어가는 함수, 확장함수로 선언을 해줘야 함.
//지역함수 : 함수 안에 지역적으로 사용되는 다른 함수를 선언 가능.
//함수를 한번 만들어 보자.
fun plus(a: Int, b: Int): Int {
val result = a + b
return result
}
//Dynamic parameter 가 있을 경우, 그리고 한번에 더해 줄 수 있는 reduce 를 사용.
fun plusVarage(vararg value: Int): Int {
val result = value.reduce { total, v ->
total + v
}
return result
}
//타입 설정 안한 함수.
fun printSome(str: String) {
println(str)
}
"Hello" concat "World"
println(plusVarage(1))
//람다: 익명 함수로, 코드를 간결하게 사용하고 전달할 수 있도록 하는 개념의 함수, 리턴 값이 없는 함수
val lambda: (Int) -> String = { it ->
println(it)
""
}
lambda(1)
//고차 함수 : 람다안에 람다 전달.
fun lambdaCaller(externalLambda: (Int) -> String) {
externalLambda(1)
}
lambdaCaller(lambda)
//TODO 표준 함수 -> 이 부분은 구글링 하면서 찾아봐야됨.
//인라인 함수 호출
callInline() // => 변환 => println("callInline") <- 인라인 함수
//리스트 2 개를 합치는 함수
fun <T : Any> concatList(listValueFirst: List<T>, listValueSecondary: List<T>): List<T> {
val listResult = mutableListOf<T>()
listResult.addAll(listValueFirst)
listResult.addAll(listValueSecondary)
return listResult.toList()
}
concatList(
listOf(2, 3),
listOf(4, 5)
).forEach {
print(it)
}
}
//인라인 함수: 함수가 호출되는 위치에 인라인 함수 코드를 복제
inline fun callInline() {
println("callInline")
}
//중위 함수
infix fun String.concat(str: String) {
println(this + " " + str)
}
fun insertSort(list: ArrayList<Int>) {
var startIdx = 1
var lastIdx = 0
var temp = 0
for (i in startIdx until list.size) {
temp = list[i]
lastIdx = i
while ((lastIdx > 0) && (list[lastIdx - 1] > temp)) {
list[lastIdx] = list[lastIdx - 1]
lastIdx--
}
list[lastIdx] = temp
}
}반응형