转载请标明作者与出处：https://www.jianshu.com/p/91c6f28adb31
遍历集合、控制流、伴生对象
遍历集合
在 Java 中我们经常需要遍历一些数组或者集合时我们常用的操作是这样的：
List 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 = 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{ fun create(): T } class MyClass { companion object : Factory { 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 是不同的，伴生对象调用时，需要导入这个类，而顶层声明的静态常量直接导入该常量即可！