Kotlin 基础语法

文档:
https://developer.android.google.cn/kotlin/learn#higher-order

1.基础

基本数据类型
Byte、Short、Int、Long、Float、Double


* val 用于值从不更改的变量。使用 val 声明的变量无法重新赋值。如希望值始终不变
* var 用于值可以更改的变量。
* count 常量
  例如:var count: Int = 10
   类型推断: 
   例如:var count = 10

  判断
    if  //同java

 NULL检查机制
//类型后面加?表示可为空
var age: String? = "23" 
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1

fun parseInt(str: String): Int? {
  // ...
}
override fun onCreate(savedInstanceState: Bundle?) {



   When 表达式 : when 类似switch,else 同 default
         when (x) {
              1 -> print("x == 1")
              2 -> print("x == 2")
              else -> { // 注意这个块
               print("x 不是 1 ，也不是 2")
             }
}


  for循环:for (i in 4)

     for (i in 1..4) print(i) // 输出“1234”

     for (i in 4..1) print(i) // 什么都不输出

  while 与 do...while 循环  同java

  继承/实现    class/interface     MainActivity : AppCompatActivity

  函数: fun
         fun onCreateViewHolder(parent: ViewGroup,viewType: Int): SpaceXViewHolder<ViewRocketBinding> {


⚠️..kt文件编译后和.java 一样,
集合类型

http://www.kotlincn.net/docs/reference/constructing-collections.html

mutableListOf 可变集合:
 一对接口代表每种集合类型：
* 		一个 只读 接口，提供访问集合元素的操作。
* 		一个 可变 接口，通过写操作扩展相应的只读接口：添加、删除和更新其元素。

更改可变集合不需要它是以 var 定义的变量：写操作修改同一个可变集合对象，因此引用不会改变。 但是，如果尝试对 val 集合重新赋值，你将收到编译错误
val numbers = mutableListOf("one", "two", "three", "four")
numbers.add("five")   // 这是可以的
//numbers = mutableListOf("six", "seven")      // 编译错误
只读集合类型是型变的。 这意味着，如果类 Rectangle 继承自 Shape，则可以在需要 List <Shape> 的任何地方使用 List <Rectangle>。 换句话说，集合类型与元素类型具有相同的子类型关系。 map 在值（value）类型上是型变的，但在键（key）类型上不是


List: 不可变集合是没有add…
val numbers = listOf("one", "two", "three", "four")

创建集合的最常用方法是使用标准库函数 listOf<T>()、setOf<T>()、mutableListOf<T>()、mutableSetOf<T>()。
还有用于创建没有任何元素的集合的函数：emptyList()、emptySet() 与 emptyMap()。 创建空集合时，应指定集合将包含的元素类型。
在特定时刻通过集合复制函数，例如toList()、toMutableList()、toSet() 等等
例如:
val sourceList = mutableListOf(1, 2, 3)
val copyList = sourceList.toMutableList()
val readOnlyCopyList = sourceList.toList()
sourceList.add(4)

迭代器
val numbersIterator = numbers.iterator()
while (numbersIterator.hasNext()) {
    println(numbersIterator.next())
}

操作集合
Slice
slice() 返回具有给定索引的集合元素列表。 索引既可以是作为区间传入的也可以是作为整数值的集合传入的。

val numbers = listOf("one", "two", "three", "four", "five", "six")    
println(numbers.slice(1..3))
println(numbers.slice(0..4 step 2))
println(numbers.slice(setOf(3, 5, 0)))    

[two, three, four]
[one, three, five]
[four, six, one]

Take 与 drop
要从头开始获取指定数量的元素，请使用 take() 函数。 要从尾开始获取指定数量的元素，请使用 takeLast()。 当调用的数字大于集合的大小时，两个函数都将返回整个集合。
要从头或从尾去除给定数量的元素，请调用 drop() 或 dropLast() 函数。

val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.take(3))
println(numbers.takeLast(3))
println(numbers.drop(1))
println(numbers.dropLast(5))

[one, two, three]
[four, five, six]
[two, three, four, five, six]
[one]

val numbers = mutableListOf(1, 2, 3, 4, 3)
numbers.remove(3) 

elementAt() 
对于不提供索引访问或非静态已知提供索引访问的集合很有用。 在使用 List 的情况下，使用索引访问操作符 （get() 或 []）更为习惯。

val numbers = linkedSetOf("one", "two", "three", "four", "five")
println(numbers.elementAt(3))    
​
val numbersSortedSet = sortedSetOf("one", "two", "three", "four")
println(numbersSortedSet.elementAt(0)) // 元素以升序存储

four
four


Set
val numbers = setOf(1, 2, 3, 4)
if (numbers.contains(1)) println("1 is in the set")

Map
val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 1)
if (numbersMap.containsValue(1)) println("The value 1 is in the map") // 同上


val numbersMap = mapOf("one" to 1, "two" to 2, "three" to 3)
println(numbersMap.keys)
println(numbersMap.values)
[one, two, three]
[1, 2, 3]
Target platform: JVMRunning on kotlin v. 1.4.30
过滤
可以使用 filter() 函数来过滤 map 或其他集合。 对 map 使用 filter() 函数时， Pair 将作为参数的谓词传递给它。 它将使用谓词同时过滤其中的键和值。
val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
val filteredMap = numbersMap.filter { (key, value) -> key.endsWith("1") && value > 10}
println(filteredMap)
{key11=11}


协程 多线程:进程 > 线程 > 协程

fun main() {
    GlobalScope.launch { // 在后台启动一个新的协程并继续
        delay(1000L) // 非阻塞的等待 1 秒钟（默认时间单位是毫秒）
        println("World!") // 在延迟后打印输出
    }
    println("Hello,") // 协程已在等待时主线程还在继续
    Thread.sleep(2000L) // 阻塞主线程 2 秒钟来保证 JVM 存活
}
Hello,
World!

join()等待直到子协程执行结束

val job = GlobalScope.launch { // 启动一个新协程并保持对这个作业的引用
    delay(1000L)
    println("World!")
}
println("Hello,")
job.join() // 等待直到子协程执行结束

比较:
runBlocking	创建新的协程，运行在当前线程上，所以会堵塞当前线程，直到协程体结束
GlobalScope.launch	启动一个新的线程，在新线程上创建运行协程，不堵塞当前线程 [常用] 
GlobalScope.asyn	启动一个新的线程，在新线程上创建运行协程，并且不堵塞当前线程，支持 通过await获取返回值



通道基础
一个 Channel 是一个和 BlockingQueue 非常相似的概念。其中一个不同是它代替了阻塞的 put 操作并提供了挂起的 send，还替代了阻塞的 take 操作并提供了挂起的 receive。

val channel = Channel<Int>()
launch {
    // 这里可能是消耗大量 CPU 运算的异步逻辑，我们将仅仅做 5 次整数的平方并发送
    for (x in 1..5) channel.send(x * x)
    //关闭通道
    channel.close() // 我们结束发送
}
// 这里我们打印了 5 次被接收的整数：
repeat(5) { println(channel.receive()) }
println("Done!")

4
9
16
25
Done!