转载请标明作者与出处: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 以及字符串模板:
image.png强大的判断
在第一篇文章中我们曾经提到过,在 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"
但是这两者是不同的,前面我们已经说了,伴生对象是一个单例,所以我们访问的时候需要先写上类名,而在顶层的静态常量则不需要。
访问时:
image
需要注意的是,这俩者的 import 是不同的,伴生对象调用时,需要导入这个类,而顶层声明的静态常量直接导入该常量即可!
网友评论