一、内置类型

一. 基本类型

常见的数据类型

字节：Byte
整型：Int & Long
浮点型：Float & Double
字符：Char
字符串：String

声明变量
在Kotlin中以关键字开始，然后是变量名称，最后加上类型（类型可以省略，会自动推导）。

val b : String = "Hello Kotlin"

修饰符：
val（来自value）：只读变量，使用val声明的变量不能在初始化之后再次赋值。它对应的是java的final变量。
var（来自variable）：可读写变量，这种变量的值可以被改变。这种声明对应的是普通（非final）的Java变量。

易混淆的 Long 类型标记

val d = 12345678910L  //必须是大写的L

Kotlin 的数值类型转换
Java：

int e = 10;
long f = e;

Kotlin:

val e = 10 
val f = e.toLong()

无符号类型
无符号类型只需要在有符号类型前加一个‘U’，如 UByte。

val g : UInt = 10u

更简单的字符串格式化：字符串模版
在字符串字面值中引用局部变量，只需要在变量名称前面加上字符$。

val name = "Kotlin"
println("Hello,$name!")

如果你要使用字符$，需要进行转义。

比较
在 Java 中“==”比较的是引用，不是内容，而在kotlin中比较的内容， “===”比较的才是引用。

二. 数组

声明

分类	Kotlin	Java
整型	IntArray	int[]
整型装箱	Array<Int>	Integer[]
字符	CharArray	char[]
字符装箱	Array<Char>	Character[]
字符串	Array<String>	String[]

数组的创建
Java：

int[] c = new int[]{1,2,3,4,5};

Kotlin:

val c0 = intArrayOf(1,2,3,4,5)
val c1 = IntArray(5){ it + 1} // 5是数组的大小，it的值为数组下标，表示值为下标 + 1

数组的遍历
Java：

float[] e = new float[]{1,3,5,7};
for (float element : e) {
  System.out.println(element);
}

Kotlin：

val e = floatArrayOf(1f,3f,5f,7f)
e.forEach{
  element ->
    println(element)
}

包含关系

if(1 in list){
  ...
}

三. 区间

区间的创建
创建闭区间，包含起止值

val intRange = 1 .. 10
val charRange = 'a' .. 'z'
val longRange = 1L .. 100L

创建开区间，不包含结束值

val intRange = 1 until 10

倒序区间

val intRangeReverse = 10 downTo 1

区间的步长

val intRangeWithStep = 1 .. 10 step 2

区间的应用

val array = intArrayOf(1,3,5,7)
for (i in 0 until array.size){
  ...
}

四. 集合框架

分类	Kotlin	Java
不可变List	List<T>	List<T>
可变List	MutableList<T>	List<T>
不可变Map	Map<K,V>	Map<K,V>
可变Map	MutableMap<K,V>	Map<K,V>
不可变Set	Set<T>	Set<T>
可变Set	MutableSet<T>	Set<T>

Pair

val pair = "Hello" to "Kotlin"
val pair2 = Pair("Hello","Kotlin")

val first = pair.first
val second = pair.second

val(x,y) = pair

五. 函数

函数定义

// Unit：返回值类型，等价于 Java 的 void，函数返回值为 Unit 可省略
fun main(args : Array<String>) : Unit {
    println(args.contentToString())
}

函数的类型

fun foo(){}
() -> Unit


fun foo(p0 : Int) : String {...}
(Int) -> String


class Foo{
    fun bar(p0:String,p1:Long):Any{...}
}
Foo.(String,Long) -> Any

函数的引用
函数的引用类似 C 语言中的函数指针，可用于函数传递

fun foo(){}
::foo

变长参数

fun main(vararg args: String) {
    println(args.contentToString())
}

多返回值

fun multiReturnValues():Triple<Int,Long,Double>{
    return Triple(1,3L,4.0)
}

六. 实例

计算器

fun main(vararg args : String){
    if(args.size < 3) {
        return showHelp()
    }

    val operators = mapOf(
          "+" to :: plus,
          "-" to :: minus,
          "*" to :: times,
          "/" to :: div,
    )
    
    val op = args[1]
    val opFunc = operators[op] ?: return showHelp()

  try{
     println("Input:${args.joinToString(" ")}")
     println("Output:${opFunc(args[0].toInt,args[2].toInt())}")
  }catch(Exception e){
    showHelp()
  }
   
}

fun plus(arg0 : Int, arg1 : Int) : Int {
    return arg0 + arg1
}

fun minus(arg0 : Int, arg1 : Int) : Int {
    return arg0 - arg1
}

fun times(arg0 : Int, arg1 : Int) : Int {
    return arg0 * arg1
}

fun div(arg0 : Int, arg1 : Int) : Int {
    return arg0 / arg1
}

fun showHelp(){
    println("""
          Simple Calculator:
          Input: 3 * 4
          Output:12
    """.trimIndent())
}