转载请标明作者与出处：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）](https://www.cnblogs.com/figozhg/p/6444312.html)
## 伴生对象与静态成员
首先我们来看看 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 是不同的，伴生对象调用时，需要导入这个类，而顶层声明的静态常量直接导入该常量即可！