Kotlin基础 数据类型（一）

对象：对象其实就是一种封装的概念，它把事物封装成一个类，然后提供类的接口，而具体的过程人们是看不到的。

变量：以关键字开始，接变量名，最后可加类型：
val(来自value)——不可变引用。相当于final。
var(来自variable)——可变引用。相当于非final。

类（默认public）

class Person(val name: String)

属性（成员变量）

class Person {
    val name: String
    var isMarried: Boolean
}

函数（方法）

fun 函数名(){
}
fun 函数名(参数): 返回值类型{
}

数值类型
Double Float
Long Int Short Byte

字面值（添加下划线）
eg：123 123L 0x0f 0b000111 123.5f
123.5（Double 123.5e10）

在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。
在 java 平台上，数值被 JVM 虚拟机以字节码的方式物理存储的，
除非我们需要做可空标识(比如说 Int?) 或者涉及泛型。在后者中数值是装箱过的。
//经过了装箱，创建了两个不同的对象

val boxedA: Int? = a
val anotherBoxedA: Int? = a

//虽然经过了装箱，但是值是相等的，都是10000
println(boxedA === anotherBoxedA) //  false，值相等，对象地址不一样
println(boxedA == anotherBoxedA) // true，值相等

eg：

fun test3() {
    //Kotlin并不会自动装箱
    val i: Int = 1000
    println(i)
    //因为j和k都被当做对象操作，因此会将i进行装箱做操，然后复制给j、k
    val j: Int? = i
    val k: Int? = i
    println(j === k)
}
反编译成java字节码之后
public static final void test3() {
      int i = 1000;
      boolean var1 = false;
      System.out.println(i);
      Integer j = Integer.valueOf(i);
      Integer k = Integer.valueOf(i);
      boolean var3 = j == k;
      boolean var4 = false;
      System.out.println(var3);
}

i和j,k的不同在于多了?
？代表j,k可以被赋值为null, 既然可以是null，那就不能是原始类型，只能是对象，
因此Kotlin会自动的为其进行装箱操作。
在Kotlin中一切都是对象(没有如同java中的基本类型)。
当我们在代码中使用整形数字的时候，Kotlin会自动的将其进行装箱操作

显示转换
低精度类型不是高精度类型的子类型
每个数值类型都支持下面的转换：

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

运算符
val x = (1 shl 2) and 0x000FF000
下面是全部的位运算操作符(只可以用在 Int 和 Long 类型)：
shl(bits) – 左移位 (Java’s <<)
shr(bits) – 右移位 (Java’s >>)
ushr(bits) – 无符号右移位 (Java’s >>>)
and(bits) – 与
or(bits) – 或
xor(bits) – 异或
inv() – 反向

字符（单引号包裹，特殊字符使用反斜杠\转义）
Char不能直接当做数值来使用

布尔值
true false
|| && !

字符串String表示
转义字符
a.val s = “Hello World!\n”
b.整行String 是由三个引号包裹的("""),不可以包含转义符但可 以包含其它字符：
val text = “”"
for (c in “foo”)
print©
“”"
c.可以通过 trim-margin() 函数移除空格
d.引用时使用$符号

val i = 10
val s = "i = $i" // 求值为 "i = 10"
或者是一个带大括号的表达式：
val s = "abc"
val str = "$s.length is ${s.length}" // 结果为 "abc.length is 3"
转义字符
val price = """
${'$'}9.99
"""  // 结果$9.99

数组Array

Array instances can be created using the [arrayOf], [arrayOfNulls] and [emptyArray]
   // 创建一个 Array<String>  内容为 ["0", "1", "4", "9", "16"] 闭包
    val asc = Array(5) { i -> (i * i).toString() }
    for (a in asc){
        println(a)
    }
    val a1 = arrayOf("hello","test")
    val a2 = arrayOfNulls<String?>(2)
    val a3 = emptyArray<String?>()
    val a31: Array<String?> = emptyArray()
    val a4 = intArrayOf(1,2,3)

集合List
声明和创建 List

listOf(): List<T>
该函数返回不可变的List集合，包含null（Kotlin 1.1 返回的是 java.util.Arrays$ArrayList）
listOfNotNull(): List<T>
该函数返回不可变的List集合，不包含null（Kotlin 1.1 返回的是 java.util.ArrayList）
mutableListOf(): MutableList<T>
该函数返回可变的MutableList集合
arrayListOf(): ArrayList<T>
该函数返回可变的ArrayList集合
注意：如果期望使用ArrayList的话，最好使用arrayListOf()，
而不要使用mutableListOf()，以免 Kotlin 底层修改逻辑导致程序出现bug

List 的遍历

for(item in list) { ... }
//for-in 遍历，遍历元素
for(index in list.indices) { ... }
//for-in 遍历，遍历下标
for ((index, item) in list.withIndex()) { ... }
//withIndex() 方法返回一个 Iterable 对象，该对象的所有元素都是 IndexedValue
list.forEach { ... }
//forEach Lambda 表达式遍历

可变 List 的添加、删除和替换

add(index: Int, element: E): Unit
在指定索引 index 处插入一个新元素 E
removeAt(index: Int): E
删除索引 index 处的元素，return 当前被删除的元素
list[index] = E
将索引 index 处的元素替换为 E
clear(): Unit
清空 List 中的所有元素

集合Set
声明和创建 Set

setOf(): Set<T>
该函数返回不可变的Set集合，按添加顺序（Kotlin 1.1 返回的是LinkHashSet）
mutableSetOf(): MutableSet<T>
该函数返回可变的Set集合，按添加顺序（Kotlin 1.1 返回的是LinkHashSet）
hashSetOf(): HashSet<T>
该函数返回可变的HashSet集合，不保证顺序
linkedSetOf(): LinkedHashSet<T>
该函数返回可变的LinkedHashSet集合，按添加顺序
sortedSetOf(): TreeSet<T>
该函数返回可变的TreeSet集合，按从小到大顺序

其余的与List类似
注意：如果期望使用LinkedHashSet的话，最好使用linkedSetOf()，
而不要使用setOf()和mutableSetOf()，以免 Kotlin 底层修改逻辑导致程序出现bug