Kotlin 遍历集合、控制流与伴生对象

转载请标明作者与出处：https://www.jianshu.com/p/91c6f28adb31

遍历集合、控制流、伴生对象

遍历集合

在 Java 中我们经常需要遍历一些数组或者集合时我们常用的操作是这样的：

List<String> list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
for (String item : list) {
    System.out.println(item);
}
list.forEach((s)-> System.out.println(s)); //Java8中我们可以使用 Lambda 表达式

最常用的应该还是增强 for 循环，在 Kotlin 中我们也可以使用这种增强 for 循环，只是格式不太一样：

var list:List<String> = listOf("1","2","3","4")
for (item in list) {
    println(item)
}
list.forEach { println(it) }

我们还可以这样来使用：

for (index in list.indices) {
    println(list[index])
}

调用集合的indices方法可以获得集合的范围，上述代码运行时等同于

for (index in 0..list.lastIndex) {
    println(list[index])
}

遍历一个 Map 以及字符串模板：

强大的判断

在第一篇文章中我们曾经提到过，在 Kotlin 中 if-else 不仅仅是判断语句，他更是一个有返回值的表达式，代码块的最后一行的值就是他的返回值。所以，在 Kotlin 中，我们可以写出这样的代码：

override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
    return if (keyCode == KeyEvent.KEYCODE_BACK && event.action == KeyEvent.ACTION_DOWN) {
        if (!acStateIsMap) {
            mLlMap.visibility = View.VISIBLE
            mLlSearch.visibility = View.GONE
            acStateIsMap = true
            false
        } else {
            this.setResult(Activity.RESULT_CANCELED)
            finish()
            true
        }
    } else {
        super.onKeyDown(keyCode, event)
    }
}

在 Kotlin 中还有一个强大的判断表达式：when，这是一个加强版的 if-else 表达式，Kotlin 中推荐我们使用 when 来代替 switch。如果 when 作为一个表达式使用，则必须有 else 分支，除非编译器检查出我们已经在其中覆盖了全部的情况。

var result = when (mutablemap.size){
    1-> 1
    2 ->{
        println("我是一个when中的代码块")
        "一共有两个"
    }
    3->"3"
    else -> println("大于3个")
}

可以参考 Kotlin中when表达式的使用：超强的switch（KAD 13）

伴生对象与静态成员

首先我们来看看 Kotlin 中对伴生对象的定义：

类内部的对象声明可以用 companion 关键字标记：

class MyClass {
companion object Factory {
    fun create(): MyClass = MyClass()
}
}

该伴生对象的成员可通过只使用类名作为限定符来调用：

val instance = MyClass.create()

可以省略伴生对象的名称，在这种情况下将使用名称 Companion：

class MyClass {
companion object {
}
}
val x = MyClass.Companion

请注意，即使伴生对象的成员看起来像其他语言的静态成员，在运行时他们仍然是真实对象的实例成员，而且，例如还可以实现接口：

interface Factory<T> {
fun create(): T
}

class MyClass {
companion object : Factory<MyClass> {
    override fun create(): MyClass = MyClass()
}
}

简单解释就是，伴生对象是与所在类共生的一个对象，请注意这个对象是个天然的单实例：

由于这个特性，我们可以在伴生对象中声明一个成员，这个成员的实际效果，将等同于在 Java 中创建的一个单例的实例。如果伴生对象没有命名我们将使用 类名.Companion 来访问，如果命名了则使用 类名.伴生对象命名 来访问，但这不是必须的，通常下是可以省略的。

我们在 Java 中申明一个全局能够使用的常量时，一般是这样的：

class Constants{
    public static final String SERVER = "xxxxxxxx";
}

利用伴生对象的属性特点我们可以这样声明一个常量：

class Constants{
    companion object {
        const val SERVER = "xxxxx"
    }
}

在调用时 Java 与 Kotlin 是完全一样的 ：Constants.SERVER，注意这里的 const 修饰符不是必须的，我们声明成 val 只读时，他就是一个单例模式的对象中成员变量。加修饰符的话，就是单例模式中的一个静态成员，根据我们自己的实际情况来决定。

如果我们只是要声明一个基本类型的静态常量，完全不用这么麻烦
在任意 Kotlin 文件的顶层声明冠以 const 的修饰符即可。

package com.moxigua.smarthome.test

const val SERVER = "XXXXXX"

但是这两者是不同的，前面我们已经说了，伴生对象是一个单例，所以我们访问的时候需要先写上类名，而在顶层的静态常量则不需要。
访问时：

需要注意的是，这俩者的 import 是不同的，伴生对象调用时，需要导入这个类，而顶层声明的静态常量直接导入该常量即可！