💌 데이터 타입

📌 기초 데이터 타입

💜 숫자 타입

- Int, Long, Short, Double, Float

val intData: Int = 10
val result = IntData.minus(5)

fun main(args: Array<String>){
	println(result)
}

👁‍🗨
5

• 숫자 타입별 크기 (Type / Bit width)
  Double / 64
  Float / 32
  Long / 64
  Int / 32
  Short / 16
  Byte / 8

- Decimals, Hexadecimals, Binalries 값 대입 가능
- Long 형은 값 뒤에 'L' 사용
- 실수형은 10.0e2로도 표현 가능
- Float 형은 값 뒤에 'f' , 'F' 사용

val a3: Byte = 0b00001011
val a4: Int = 123
val a5: Int = 0x0F
val a6: Long = 10L
val a7: Double = 10.0
val a8: Double = 123.5e10
val a9: Float = 10.0f

💜 논리, 문자와 문자열 타입

• Boolean
  || 논리합
  && 논리곱
  ! 부정
• Char
  작은 따옴표 (' ')로 묶어서 표현
• String
  큰따옴표 (" ")로 묶거나 큰따옴표 세 개로 (""")로 묶어서 표현

val str2 = "Hello \n World"
val str3 = """Hello
World"""

문자열 내 변수는 "$ 변수명"으로 작성.
표현식은 "${표현식}"

💜 Any 타입

• 최상위 클래스로 어떤 타입의 데이터도 대입 가능

fun cases(obj: Any): String{
	when(obj){
    		1 -> return "One"
            	"Hello" -> return "Greeting"
            	is Long -> return "Long"
            	!is String -> return "Not a String"
            	else -> return "unknown"
    	}
}

fun main(args: Array<String>){
	println(cases(1))
    	println(cases(10))
}

👁‍🗨
One
Not a String

💜 Null 허용 타입

val a: Int = null		<- 에러
val b: Int? = null		<- 성공

fun parseInt(str: String): Int? {	// Null 허용 반환 타입 함수
	return str.toIntOrNull()
}

변수가 Any 타입으로 선언되었어도 ? 기호 명시적으로 선언해야 함.

💜 Any.Any? 타입

Any? <- ⭕️ Any
Any <- ❌ Any?

val myVal1: Any = 10
val myVal2: Any? = myVal1

val myVal3: Any? = 10
val myVal4: Any = myVal3	<- 에러
val myVal5: Any = myVal3 as Any		// 명시적 형 변환 필요

💜 Unit과 Nothing

• Unit 은 함수의 반환 구문이 없다는 것 표현 -> 흔히 자바에서 void
• Nothing 은 의미 있는 데이터가 없다는 것 표현

fun myFun1(){}
fun myFun2(): Unit{}

fun myFun(arg: Nothing?): Nothing{
	throw Exception()
}

💜 타입 확인과 캐스팅

• is : 타입을 확인하고 자동으로 캐스팅 (스마트 캐스트)

코틀린에서 기초 데이터 타입에 대한 자동형변환 제공 X
함수를 이용해야 한다.

var a1: Int = 10
var a2: Double = a1		<- 에러

var a3: Int = 10
var a4: Double = a3.toDouble()		<- 성공

값의 형 변환은 자동으로 이뤄진다.

val l = 1L + 3		// Long + Int -> Long

📌 컬렉션 타입

💜 배열

• Array 로 표현.
• arrayOf() 함수 이용이 젤 쉬움.

fun main(args: Array<String>){
	// arrayOf() 함수 이용
	var array = arrayOf(1, "kkang", true)
    array[0] = 10
    array[2] = "world"
    println("${array[0]} .. ${array[1]} .. ${array[2]}")
    println("size : ${array.size} .. ${array.get(0)} .. ${array.get(2)}")
}

👁‍🗨
10 .. kkang .. world
size : 3 .. 10 .. world

var arrayInt1 = arrayOf<Int>(10, 20, 30)		// Int 타입 데이터만 대입가능

xxxArrayOf() 함수 이용
booleanArrayOf()
byteArrayOf()
charArrayOf()
doubleArrayOf()
floatArrayOf()
intArrayOf()
longArrayOf()
shortArrayOf()

var arrayInt2 = intArrayOf(10, 20, 30)
var arrayInt3 = doubleArrayOf(10.0, 20.0, 30.0)

Array 클래스 이용
Array(size: Int, init: (Int) -> T)

var array3 = Array(3, {i -> i*10})

각 타입의 배열 클래스 이용
BooleanArray
ByteArray
CharArray
DoubleArray
FloatArray
IntArray
LongArray

var array4 = Array<Int>(3, {i -> i*10})
var array5 = IntArray(3, {i -> i*10})

빈 배열 만들기

var array2 = arrayOfNulls<Any>(3)	//	크기가 3인 빈 배열
var emptyArray = Array<String>(3,{""})	//	배열의 초깃값 빈상태("") 대입

💜 List, Set, Map

• Collection 타입 클래스
  List : 순서가 있는 데이터 집합, 데이터의 중복 허용
  Set : 순서가 없고 데이터 중복 허용 안함
  Map : 키와 값으로 이루어지는 데이터 집합. 순서가 없고 키의 중복 허용 안함

• 컬렉션 타입별 불변(immutable) / 가변(mutable) 함수
  < List >
  listOf() - 불변
  mutableListOf() - 가변
  < Set >
  setOf() - 불변
  mutableSetOf() - 가변
  < Map >
  mapOf() - 불변
  mutableMapOf() - 가변

• ArrayList 이용

val arrayList: ArrayList<String> = ArrayList()
arrayList.add("hello")
arrayList.add("kkang")
arrayList.set(1,"world")
println("${arrayList.get(0)} .. ${arrayList.get(1)}")

👁‍🗨
hello .. world

👉 Map 이용

// Pair 클래스 이용
val immutableMap1 = mapOf<String, String>(Pair("one", "hello"), Pair("two", "world"))
println("${immutableMap1.get("one")} .. ${immutableMap1.get("two")}")

// 키 to 값 형태 이용
val immutableMap2= mapOf<String, String>("one" to "hello", "two" to "kkang")
println("${immutableMap2.get("one")} .. ${immutableMap2.get("two")}")

val mutableMap = mutableMapOf<String, String>()
mutablMap.put("one", "hello")
mutableMap.put("two", "map")
println("${mutableMap.get("one")} .. ${mutableMap.get("two")})

👁‍🗨
hello .. world
hello .. kkang
hello .. map

👉 Set 이용

val immutableSet = setOf<String>("hello", "hello", "world")
println("${immutableSet.elementAt(0)} .. ${immutableSet.elementAt(1)}")

val mutableSet = mutableSetOf<String>()
mutableSet.add("hello")
mutableSet.add("set")
println("${mutableSet.elementAt(0)} .. ${mutableSet.elementAt(1)}")

👁‍🗨
hello .. world
hello .. set

💜 이터레이터

Iterator

• 컬렉션 타입의 데이터를 hasNext()와 next() 함수를 이용해 차례로 얻기위한 인터페이스
• hasNext() : 가져올 수 있는 데이터가 있으면 true, 없으면 false
• next() : 실제 데이터를 가져올 때 사용

fun main(args: Array<String>_{

	// LIST
   	 val list1 = listOf<String>("hello", "list")
   	 val iterator1 = list1.iterator()
   	 while (iterator1.hasNext()){
    		println(iterator.next())
   	 }


	// MAP
	val map = mapOf<String, String>("one" to "hello", "two" to "map")
	val iterator: Iterator<Map.Entry<String, String>> = map.iterator()
	while(iterator.hasNext()){
		val entry = iterator.next()
    	println("${entry.key} = ${entry.value})
	}


	// SET
	val set = setOf<String>("hello". "set")
	val iterator3 = set.iterator()
	while (iterator3.hasNext()){
		println("${iterator3.next()}")
	}


	val array = arrayOf("hello", "world")
	val iterator4 = array.iterator()
	while (iterator4.hasNext()){
		println("${iterator4.next()}")
	}
}

👁‍🗨🖥
hello
list
one - hello
two - map
hello
set
hello
world

📋 자바 vs 코틀린 ✏️

💛 코틀린에서는 모든 것이 객체이다

💛 코틀린에서는 기초 데이터 타입에 대한 자동 캐스팅을 제공하지 않는다

💛 코틀린에는 switch-case 구문이 없다

• 대신 when 이용

💛 코틀린은 배열을 [ ] 로 선언하지 않으며 { } 을 이용하여 초기화하지도 않는다

• 배열 표현 시 val array: Array 형태 이용
• 초깃값 대입 시 arrayOf() 등 함수 이용