[Kotlin 요약 정리] 3. 데이터 타입

3. 데이터 타입

1) 기본

- 코틀린에서는 기초 타입이 없고 모든 타입이 객체 형태이다.

- 타입 클래스에 정의된 기초 함수와 프로퍼티를 사용할 수 있다.

- Any는 코틀린의 최상위 클래스이기 때문에 어떤 타입의 데이터도 대입할 수 있다.

- 타입 종류: Int, Double, Float, Long, Short, Byte, Char, Boolean, String, Any, Unit, Nothing

 

2) 숫자 타입

- Number 클래스의 서브클래스: Int(32), Long(64), Float(32), Double(64), Short(16), Byte(8)

- 자동 형 변환을 제공하지 않는다.

- Decimals, Hexadecimals, Binaries 값 대입 가능

- Long 형은 값 뒤에 'L' 사용 (ex. 10L)

- 실수 기본형은 Double

- 실수형은 10.0e2로도 표현 가능

- Float 형은 값 뒤에 'f', 'F' 사용 (ex. 10.0f)

- 숫자 타입을 읽기 편하게 밑줄 사용 가능하며 값에는 영향을 주지 않는다. (ex. 1_000_000)

 

3) 논리 타입

- Boolean: true, false를 구분하기 위한 타입

- 논리 연산자

||: 논리합(or)

&&: 논리곱(and)

!: 부정(not)

 

4) 문자와 문자열 타입

- Char: 문자를 표현하는 타입(Number 타입이 아니라서 숫자로 연산 불가)

ex) 'A' / 'b'

- String: 문자열을 표현하는 타입(배열 형태로 접근 가능한 Char의 집합)

fun main() {

   val str: String = "ABCDE"

   println(str[0]) // A

   println(str[3]) // D

}

 

- raw string: 큰따옴표 세개를 사용해서 표현하며 엔터 등의 값이 적용된다.

fun main() {

   val str: String = """

       안녕??



       반가워~"""



   println(str)

}

// 결과



       안녕??



       반가워~

 

- 문자열 템플릿: '$' 기호를 이용해서 문자열 내에 변수 혹은 연산 내용을 입력하는 방식

fun main() {

   val name = "Wickies"

   var count = 1

   fun counter() = count ++



   for (i in 1..5)

   println("${counter()}번째 인사: 안녕? 내 이름은 $name")

}

// 결과

1번째 인사: 안녕? 내 이름은 Wickies

2번째 인사: 안녕? 내 이름은 Wickies

3번째 인사: 안녕? 내 이름은 Wickies

4번째 인사: 안녕? 내 이름은 Wickies

5번째 인사: 안녕? 내 이름은 Wickies

 

5) 타입 확인

- is 연산자를 사용하며 타입이 확인될 경우 해당 타입으로 자동 형변환 된다.

- !is의 형태로 Not을 추가할 수 있다.

fun checkType(data : Any){

   if(data is Int)

       println("연산 전: $data / 연산 후: ${data.times(-1)}")

    else if(data is String)

       println("연산 전: $data / 연산 후: ${data.toUpperCase()}")

    else if (data is Boolean)

       println("연산 전: $data / 연산 후: ${data.not()}")

}



fun main() {

   val any1 : Any = 10

   val any2 : Any = "str"

   val any3 : Any = true

   checkType(any1)

   checkType(any2)

   checkType(any3)

}

// 결과

연산 전: 10 / 연산 후: -10

연산 전: str / 연산 후: STR

연산 전: true / 연산 후: false

 

6) 형 변환

- 코틀린에서는 자동 형변환을 지원하지 않기 때문에 to타입() 형태의 함수를 이용해야 한다.

- 형 변환 함수: toByte(), toShort(), toInt(), toLong(), toFloat(), toDouble(), toChar()

fun main() {

   val byte : Byte = 1.toByte()

   val short : Short = 1.toShort()

   val int : Int = 1L.toInt()

   val float : Float = 1.toFloat()

   val double : Double = 1.toDouble()

   val char : Char = 97.toChar()

   println("$byte $short $int $float $double $char")

}

// 결과

1 1 1 1.0 1.0 a

 

- 연산되는 값은 자동 형변환이 가능하다

fun main() {

   println(1L+3)

   println('c'+"de")

}

// 결과

4

cde

 

- 상속관계에서는 as 연산자를 이용해서 형변환 가능

 

7) 배열

- 코틀린에서의 배열은 Array 객체로 표현되며 기본 함수를 포함하고 있다.

- 타입에 상관없이 추가가 가능하며 타입을 제한하고 싶을 때는 제네릭을 사용하거나 특정 타입 배열 클래스를 사용한다.

- 선언 형식: arrayOf(값1, 값2 ...)

fun main() {

   var arr = arrayOf(1, 2, 3, 4, 5)

   println("${arr[0]}, ${arr[1]}, ${arr[2]}, ${arr[3]}, ${arr[4]}")

}

// 결과 1, 2, 3, 4, 5

 

fun main() {

   var arr = arrayOf(1, "??", true)

   println("${arr[0]}, ${arr[1]}, ${arr[2]}")

   var arr2 = arrayOf<String>("a", "b", "c")

   println("${arr2[0]}, ${arr2[1]}, ${arr2[2]}")

   arr2.set(2, "?")

//    arr2.set(2, 4) // 타입 에러 발생!!

   println("${arr2[0]}, ${arr2[1]}, ${arr2[2]}")

   var arr3 = intArrayOf(1, 2, 3)

   println("${arr3[0]}, ${arr3[1]}, ${arr3[2]}")

   var arr4 = StringArray(0, 3, true)

   arr4.add("a")

   arr4.add("b")

   arr4.add("c")

   println("${arr4[0]}, ${arr4[1]}, ${arr4[2]}")

}



// 결과

1, ??, true

a, b, c

a, b, ?

1, 2, 3

a, b, c

 

8) List, Set, Map

- List: 순서가 있는 데이터 집합, 중복 허용

- Set: 순서가 없으며 데이터 중복을 허용하지 않음

- Map: 키와 값으로 이루어지는 데이터 집합, 순서가 없으며 키의 중복은 허용하지 않음

 

- 컬렉션 타입의 클래스들은 가변(mutable) 클래스와 불변(immutable) 클래스로 구분되며 각각 구분해서 선언한다.(ex. listOf() / mutableListOf())

 

fun main() {

   val list : List<Int> = listOf(1, 2, 3)

   var mutableList : MutableList<Int> = mutableListOf(1, 2, 3)

//    list.add(4) // 에러 발생!!

   mutableList.add(4)

}

 

9) 이터레이터

- 컬렉션 타입의 데이터를 사용하기 위한 인터페이스

- hasNext(): 가져올 수 있는 데이터 여부 반환(Boolean)

- next(): 다음 데이터를 반환

fun main() {

   val map : Map<Int, String> = mapOf<Int, String>(1 to "a", 2 to "b", 3 to "c")

   val iterator = map.iterator()

   while (iterator.hasNext())

       println(iterator.next())

}

// 결과

1=a

2=b

3=c