val a = 1_2_3 與 val a = 123 是相同的

val a : Float = 1
或者
val a = 1f

val i = 1 
val d = 1.1
val f = 1.1f

printDouble(d)
printDouble(i) // 錯誤:類型不匹配 
printDouble(f) // 錯誤:類型不匹配

十進制：     123
   -- Long類型 123L
十六進制：  0x0f
二進制：     0b001

val a: Int = 10000
println(a === a) // 輸出“true”
val boxedA: Int? = a
val anotherBoxedA: Int? = a
println(boxedA === anotherBoxedA) // !!!輸出“false”!!!

但保留相等性
val a: Int = 10000
println(a == a) // 輸出“true”
val boxedA: Int? = a
val anotherBoxedA: Int? = a
println(boxedA == anotherBoxedA) // 輸出“true”

// 假想的代碼，實際上并不能編譯:
val a: Int? = 1 // 一個裝箱的 Int (java.lang.Integer)
val b: Long? = a // 隱式轉換產生一個裝箱的 Long (java.lang.Long)
print(b == a) // 驚!這將輸出“false”鑒于 Long 的 equals() 會檢測另一個是否也為 Long

//以下的方式也是錯的
 val b: Byte = 1 // OK, 字面值是靜態檢測的
 val i: Int = b // 錯誤


但是可以通過顯式轉換
 val i: Int = b.toInt() // OK:顯式拓寬

可以使用以下的方式
— toByte(): Byte
— toShort(): Short
— toInt(): Int
— toLong(): Long
— toFloat(): Float
— toDouble(): Double 
— toChar(): Char

注意：
val l = 1L + 3 // Long + Int => Long

 val x = 5 / 2.toDouble() 
 println(x == 2.5)

val x = (1 shl 2) and 0x000FF000 

這是完整的位運算列表(只用于 Int 與 Long):

— shl(bits) ? 有符號左移
— shr(bits) ? 有符號右移
— ushr(bits) ? 無符號右移
— and(bits) ? 位與
— or(bits) ? 位或
— xor(bits) ? 位異或
— inv()?位非

區間實例以及區間檢測:a..b、x in a..b、x !in a..b

字符字面值用單引號括起來: '1' 。特殊字符可以用反斜杠轉義。支持這幾個轉義序列:\t 、 \b 、\n 、\r 、\' 、\" 、\\ 與 \$ 。編碼其他字符要用 Unicode 轉義序列語法:'\uFF00'


fun decimalDigitValue(c: Char): Int {
     if (c !in '0'..'9')
            throw IllegalArgumentException("Out of range") 
    return c.toInt() - '0'.toInt() // 顯式轉換為數字
}            

// 創建一個 Array<String> 初始化為 ["0", "1", "4", "9", "16"] 
val asc = Array(5) { i -> (i * i).toString() }
asc.forEach { println(it) }

val x: IntArray = intArrayOf(1, 2, 3) x[0] = x[1] + x[2]

// 大小為 5、值為 [0, 0, 0, 0, 0] 的整型數組 
val arr = IntArray(5)

// 例如:用常量初始化數組中的值
// 大小為 5、值為 [42, 42, 42, 42, 42] 的整型數組 
val arr = IntArray(5) { 42 }

// 例如:使用 lambda 表達式初始化數組中的值
// 大小為 5、值為 [0, 1, 2, 3, 4] 的整型數組(值初始化為其索引值) 
var arr = IntArray(5) { it * 1 }

val a :UByte = 1u
val b: Byte = a.toByte()

注意：將類型從無符號類型更改為對應的有符號類型(反之亦然)是二進制不兼容變更
無符號類型是使用另一個實驗性特性(即內聯類)實現的。

與原生類型相同，每個無符號類型都有相應的為該類型特化的表示數組的類型:
— kotlin.UByteArray : 無符號字節數組
— kotlin.UShortArray : 無符號短整型數組
— kotlin.UIntArray : 無符號整型數組
— kotlin.ULongArray : 無符號?整型數組
與有符號整型數組一樣，它們提供了類似于 Array 類的 API 而沒有裝箱開銷。
此外，區間與數列也支持 UInt 與 ULong(通過這些類 kotlin.ranges.UIntRange 、 kotlin.ranges.UIntProgression 、kotlin.ranges.ULongRange 、 kotlin.ranges.ULongProgression )

— 如需傳播實驗性，請以 @ExperimentalUnsignedTypes 標注使用了無符號整型的聲明。
— 如需選擇加入而不傳播實驗性，要么使用 @OptIn(ExperimentalUnsignedTypes::class) 注解標注聲明，
  要么將 -Xopt-in=kotlin.ExperimentalUnsignedTypes 傳給編譯器。

val text = """
            |Tell me and I > forget.
            |Teach me and I > remember.
            |Involve me and > I learn.
            |(Benjamin Franklin) """

println(text)

輸出結果(上下的換行,和前面的空格都是):
  

            |Tell me and I > forget.
            |Teach me and I > remember.
            |Involve me and > I learn.
            |(Benjamin Franklin) 


val text = """
            |Tell me and I > forget.
            |Teach me and I > remember.
            |Involve me and > I learn.
            |(Benjamin Franklin) """.trimMargin()

println(text)

輸出結果:

Tell me and I > forget.
Teach me and I > remember.
Involve me and > I learn.
(Benjamin Franklin) 

注意:trimMargin() 函數為去除前導空格，默認以 ｜ 作為邊界前綴，所以等同于trimMargin("|") ，邊界前綴可以自己定義

 val i = 10
 println("i = $i") // 輸出“i = 10”


 val s = "abc"
 println("$s.length is ${s.length}") // 輸出“abc.length is 3”

import org.example.Message // Message 可訪問
import org.test.Message as testMessage // testMessage 代表“org.test.Message”