[kotlinlang.org] 한글화. 1 기본 유형

[원본] https://kotlinlang.org/docs/basic-types.html

사전지식 : C와 Java에서는 기본형 타입을 제공했다.

 

---

Kotlin에서는 기본 유형(숫자, 부울, 문자, 문자열, 배열)도 일반 클래스로 이루어져 있습니다.

 

숫자

정수

Kotlin에서 4개의 숫자유형(Byte, Short, Int, Long)을 사용합니다. 선언시 언급이 없다면 컴파일러는 값을 유추하게 됩니다. 32bit를 넘어가지 않으면 Int로, 32bit를 넘어간다면 Long으로 유추합니다. 만약 강제로 64bit 정수로 선언하고 싶다면, 숫자 뒤에 L을 붙여줍니다.

Byte(8bit), Short(16bit), Int(32bit:기본), Long(64bit)
강제 Long선언 : 접미사 L (예 : 123L)

 

소수

Float와 Double은 IEEE754표준을 준수합니다. Float는 단정밀도, Double은 배정밀도를 제공합니다. 기본적으로 Double로 유추하기 때문에 강제로 Float를 만들고 싶다면 숫자 뒤에 F(또는 f)를 붙여줍니다.

Float(32bit), Double(64bit:기본)
강제 Float선언 : 접미사 F(또는 f) (예 : 1.23f)

 

상수

Kotlin은 2진수, 10진수 16진수를 표시할 수 있고(8진수 제외됨), 지수표기법을 지원합니다. 표기의 편의를 위해서 _(Underbar;밑줄)을 보조적으로 사용할 수 있습니다.

2진수 : 0b(또는 0B)로 시작 (예 : 0b10011)
10진수 : 접두어 없음 (예 : 1234)
16진수 : 0x(또는 0X)로 시작 (예 : 0xFA)
지수표현 : 소수부e지수부 (예 : 1.5e2)
편의상 표기(옵션) : 밑줄을 사용합니다. (예 : 0b0010_1110)

 

명시적 변환

※ Kotlin에는 암시적 형변환이 없습니다. 명시적 변환을 사용하십시오.

암시적 변환 불가능 → toByte, toShort, toInt, toLong, toFloat, toDoube, toChar

 

JVM에서의 숫자체계

※ JVM : 자바 가상 머신

Java에서는 기본형에 대한 Boxing클레스를 지원해왔습니다. Nullable인 경우에 한해서 원본의 위치가 바뀔 수 있다는 점에 명심하십시오. 변경기준은 -128..127입니다.

fun main() {
    val a: Int = 127
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a
    // nullable로 boxing 객체를 복사하더라도 원본의 위치를 유지시킵니다.

    val b: Int = 128
    val boxedB: Int? = b
    val anotherBoxedB: Int? = b
    // 숫자가 커지면 원본의 위치가 변경됩니다.
    
    val c: Int = 128
    val boxedC: Int = c
    val anotherBoxedC: Int = c
    // nullable이 아니면 원본의 위치변경이 일어나지 않습니다.

    println(boxedA === anotherBoxedA) // true
    println(boxedB === anotherBoxedB) // false
    println(boxedC === anotherBoxedC) // true
}

nullalbe변수의 경우 복사시 원본의 위치가 변경 될 수 있습니다. (기준 -128..127 이외)

 

연산

+(더하기), -(빼기), *(곱하기), /(나누기), %(나머지) 연산을 지원합니다. 정수와 정수의 나눗셈의 결과는 항상 정수입니다.(소수부분이 버려집니다.)

※ 사용자 정의 클래스는 연산자를 재정의 할 수 있습니다. (연산자 오버로딩 참고)

+(더하기), -(빼기), *(곱하기), /(나누기), %(나머지)

fun main() {
    val i = 7
    val j = 3 // 8 나누기 3은
    println(i / j) // 몫이 2 이고,    
    println(i % j) // 나머지가 1 입니다.
}

2
1

 

자동변환

fun main() {
    val i = 2 + 2L // Long으로 변환해줍니다.
    if(i is Long) println("Long")
    
    val d = 2.5 * 4 // 4를 double로 형변환 해줍니다.
    println(d)
}

Long
10.0

 

비트연산

왼쪽으로 밀기(<<, SHift Left) : shl(bits) - x2효과가 있음
오른쪽으로 밀기(>>, SHift Right) : shr(bits) - ÷2효과가 있음
부호없는 오른쪽으로 밀기(>>>, Unsighed SHift Right) : ushr(bits)
and(bits), or(bits), xor(bits), int() - 비트반전

fun main() {
    var bit1 = 0b001101
    var bit2 = 0b010100
    
    printBinary(bit1)
    printBinary(bit2)

    println()
    printBinary(bit1 and bit2)
    printBinary(bit1 or bit2)
    printBinary(bit1 xor bit2)
    
    println()
    printBinary(bit1 shl 3)
    printBinary(bit1 shr 1)
}

// (i=2진수로 변환할 데이터, minLen=출력할 최소 자릿수(8))
// xxxxxxxx(10진수)
fun printBinary(i: Int, minLen: Int = 8){
    var l = minLen - i.toString(2).length
    while(l!=0){
        print("0")
        l--
    }
    println(i.toString(2) + "(" + i.toString() + ")")
}

00001101(13)
00010100(20)

00000100(4)
00011101(29)
00011001(25)

01101000(104)
00000110(6)

 

비교연산

a == b : a와 b가 같은가?
a != b : a와 b가 같지 않은가?
a < b, a > b, a >= b, a <= b

a와 b가 Float나 Double (또는 해당변수에서 선언, 추론, 스마트캐스팅의 결과로 저장된 null)인경우 부동소수점 연산에 대한 표준(IEEE 754)를 따릅니다.
(equals, compareTo에 관한 용법이 있으나, 실제 적용에 대한 내용은 잘 모르겠습니다. 아래 원문 참조)
https://kotlinlang.org/docs/basic-types.html#floating-point-numbers-comparison

 

부호없는 정수

UByte(8bit), UShort(16bit), UInt(32bit:기본), ULong(64bit)
접미사 u를 이용하여 선언 할 수 있습니다.

fun main() {
    val a : UInt = 1u // UInt 대소문자에 유의합니다.
    val b = 2u // 생략 가능합니다.
    
	println(a + b)   
}

Beta버전에서는 Unsigend에 관한 배열을 지원합니다.
※ @ExperimentalUnsignedType 을 사용하여 경고를 억제할 수 있습니다.

UByteArray, UShortArray, UIntArray, ULongArray

 

 

Boolean

부울(Boolean)은 "true참"/"false거짓"만 될 수 있습니다. AND, OR, NOT 연산을 지원합니다. 
&&과 ||은 느린수행(lazy work)으로 동작합니다. (연속된 연산에서 왼쪽부터 수행)

Boolean : true | false
&& : and, || : or, ! : not

fun main() {
    val myTrue: Boolean = true
    val myFalse: Boolean = false
    val boolNull: Boolean? = null

    println(myTrue || myFalse)
    println(myTrue && myFalse)
    println(!myTrue)
}

true
false
false

 

문자

작은 따옴표로 묶습니다. \(이스케이프 백슬러쉬)를 이용하여 특수문자를 출력할 수 있습니다. 유니코드는 "\u"접두어를 붙입니다.

작은따옴표 : 문자 (예 : 'A')
특수문자 : \t, \n, \r, \', \", \\, \$ (탭, 줄바꿈, 입력바 첫행, 강제 출력(', ", \, $))
유니코드 : \u (예 : '\uAC00')

fun main() {
    var char: Char 

    char = 'A'	// 작은 따옴표로 저장합니다.
    print(char)
    
    char = '\t' // 탭을 입력합니다.
    print(char)
    
    char = '\uAC00' // 유니코드로 '가'를 출력합니다.
    print(char)
}

A	가

 

문자열

문자열은 변경되지 않습니다. 또한 for문을 통하여 제어할 수도 있습니다. 문자열은 + 기호로 결합 될 수 있습니다.

큰 따옴표 : 문자 (예 : "문자열")
문자열 결합 : + (예 : "ABC"+"DE" = "ABCDE"
※ 문자열 함수가 문자열 변경을 반영하지 않음에 주의

fun main() {
val str = "abcd"
    for (c in str) {
        println(c)
    }
}

a
b
c
d

 

문자열이 변경되지 않는 예 :

fun main() {
    val str = "abcd"
    println(str.uppercase()) // 새로운 문자열을 할당합니다.
    println(str) // 원래 문자는 그대로 있습니다.
}

ABCD
abcd

 

여러열 문자열

여러열 문자열 : """

여러열을 사용할 경우, 코드 개행(탭)으로 인해서 출력이 원할하지 않을 수 있습니다. 이때는 trimMargin()을 사용합니다. 일반적으로 trimMargin은 | 여백접두사를 사용하지만, 인자를 전달함으로써 변경이 가능합니다.

fun main() {
    val str = """여러줄 출력 예제 : 
                | - trimMargin()
                | - 인자값을 전달 할 수도 있습니다.
                | - 기본적으로 |를 사용합니다."""
    
    println(str) // 원하지 않는 출력
    
    println(str.trimMargin()) // 띄어쓰기, 탭을 제거합니다.
}

여러줄 출력 예제 : 
                | - trimMargin()
                | - 인자값을 전달 할 수도 있습니다.
                | - 기본적으로 |를 사용합니다.
여러줄 출력 예제 : 
 - trimMargin()
 - 인자값을 전달 할 수도 있습니다.
 - 기본적으로 |를 사용합니다.

 

배열

※ 해석 : 객체지향 프로그래밍은 class라는 키워드를 사용합니다.
class는 설계도에 해당하고, 실제 생성된 것을 인스턴스라고 합니다. 아래 내용은 설계도에 해당합니다.
<>는 제넥릭(임시 타입)이고, get은 호출 할 때 호출되는 함수, set은 저장할 때, iterator는 다음을 찾을때 사용하는 함수입니다. 아래 코드에서 하고 싶은 말은 get을 할 때, 인덱스(정수)를 요청하고 있고, set을 할 때는 정수와 값을 요청하고 있다는 것을 언급하는 것입니다.

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
    // ...
}

선언 arrayOf() 사용
배열은 [ ] 로 표기합니다. (예 :  1, 2, 3을 갖는 배열 [1, 2, 3])
입력 : array[index] = value
출력 : return_value = array[index] 

fun main() {
    // 문자열로 이루어진 다음 배열을 생성합니다. ["0", "1", "4", "9", "16"]
    val asc = Array(5) { i -> (i * i).toString() }
    asc.forEach { println(it) }
}

0
1
4
9
16

입출력 예시 : 

fun main() {
    val birds = arrayOf("꽥꽥이", "짹짹이", "삐약이")
    
    println(birds[1])	// 0번부터 부여됨, 1번은 "짹짹이"
    
    birds[2] = "빡빡이"	// "삐약이"를 "빡빡이"로 변경
    
    for(b in birds) {
        print("$b ")
    }
}

짹짹이
꽥꽥이 짹짹이 빡빡이

 

기본유형 배열

boxing이 되지 않은 배열은 아래 함수를 통해서 생성할 수 있습니다.

***Aray, ***ArrayOf (예 : IntArray, intArrayOf), (※ ***는 기본형)

fun main() {
	var arr = IntArray(5) // 0으로 초기화 됩니다. [0, 0, 0, 0, 0]
    arr.forEach{ print("$it ") }
    println()

    arr = IntArray(5) { 42 } // 해당값으로 초기화 됩니다. [42, 42, 42, 42, 42]
    arr.forEach{ print("$it ") }
    println()

    arr = IntArray(5) { it * 1 } // it은 자신의 인덱스를 의미합니다. [0, 1, 2, 3, 4]
    arr.forEach{ print("$it ") }
}

0 0 0 0 0 
42 42 42 42 42 
0 1 2 3 4