Kotlin开发笔记之委托属性与区间(译)

前言

本文主要给大家介绍了关于Kotlin委托属性与区间的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧。

委托属性

有一些常见的属性类型,虽然我们可以在每次需要的时候手动实现它们, 但是如果能够为大家把他们只实现一次并放入一个库会更好。例如包括

  • 延迟属性(lazy properties): 其值只在首次访问时计算,
  • 可观察属性(observable properties): 监听器会收到有关此属性变更的通知,
  • 把多个属性储存在一个映射(map)中,而不是每个存在单独的字段中。

为了涵盖这些(以及其他)情况,Kotlin 支持 委托属性:

class Example {
var p: String by Delegate()
}

委托属性 是一种通过委托实现拥有 getter 和可选 setter 的 属性,并允许实现可复用的自定义属性。例如:

class Example {
 var p: String by Delegate()
}

委托对象必须实现一个拥有 getValue() 方法的操作符,以及 setValue() 方法来实现读/写属性。些方法将会接受包含对象实例以及属性元数据作为额外参数。当一个类声明委托属性时,编译器生成的代码会和如下 Java 代码相似。

public final class Example {
 @NotNull
 private final Delegate p$delegate = new Delegate();
 // $FF: synthetic field
 static final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.mutableProperty1(new MutablePropertyReference1Impl(Reflection.getOrCreateKotlinClass(Example.class), "p", "getP()Ljava/lang/String;"))};
 @NotNull
 public final String getP() {
 return this.p$delegate.getValue(this, $$delegatedProperties[0]);
 }
 public final void setP(@NotNull String var1) {
 Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
 this.p$delegate.setValue(this, $$delegatedProperties[0], var1);
 }
}

一些静态属性元数据被加入到类中,委托在类的构造函数中初始化,并在每次读写属性时调用。

委托实例

在上面的例子中,创建了一个新的委托实例来实现属性。这就要求委托的实现是有状态的,例如,当其内部缓存计算结果时:

class StringDelegate {
 private var cache: String? = null
 operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
 var result = cache
 if (result == null) {
 result = someOperation()
 cache = result
 }
 return result
 }
}

与此同时,当需要额外的参数时,需要建立新的委托实例,并将其传递到构造器中。

class Example {
 private val nameView by BindViewDelegate<TextView>(R.id.name)
}

但也有一些情况是只需要一个委托实例来实现任何属性的:当委托是无状态,并且它所需要的唯一变量就是已经提供好的包含对象实例和委托名称时,可以通过将其声明为 object 来替代 class 实现一个单例委托。

举个例子,下面的单例委托从 Android Activity 中取回与给定 tag 相匹配的 Fragment。

object FragmentDelegate {
 operator fun getValue(thisRef: Activity, property: KProperty<*>): Fragment? {
 return thisRef.fragmentManager.findFragmentByTag(property.name)
 }
}

类似地,任何已有类都可以通过扩展变成委托。getValue()setValue() 也可以被声明成 扩展方法 来实现。Kotlin 已经提供了内置的扩展方法来允许将 Map and MutableMap 实例用作委托,属性名作为其中的键。

如果你选择复用相同的局部委托实例来在一个类中实现多属性,你需要在构造函数中初始化实例。

注意:从 Kotlin 1.1 开始,也可以声明 方法局部变量声明为委托属性。在这种情况下,委托可以直到该变量在方法内部声明的时候才去初始化,而不必在构造函数中就执行初始化。

泛型委托

委托方法也可以被声明成泛型的,这样一来不同类型的属性就可以复用同一个委托类了。

private var maxDelay: Long by SharedPreferencesDelegate<Long>()

然而,如果像上例那样对基本类型使用泛型委托的话,即便声明的基本类型非空,也会在每次读写属性的时候触发装箱和拆箱的操作。

说明:对于非空基本类型的委托属性来说,最好使用给定类型的特定委托类而不是泛型委托来避免每次访问属性时增加装箱的额外开销。

标准委托:lazy()

针对常见情形,Kotlin 提供了一些标准委托,如 Delegates.notNull()Delegates.observable() lazy()

lazy() 是一个在第一次读取时通过给定的 lambda 值来计算属性的初值,并返回只读属性的委托。

private val dateFormat: DateFormat by lazy {
 SimpleDateFormat("dd-MM-yyyy", Locale.getDefault())
}

这是一种简洁的延迟高消耗的初始化至其真正需要时的方式,在保留代码可读性的同时提升了性能。

需要注意的是lazy() 并不是内联函数,传入的 lambda 参数也会被编译成一个额外的 Function 类,并且不会被内联到返回的委托对象中。

经常被忽略的一点是 lazy() 有可选的 mode 参数 来决定应该返回 3 种委托的哪一种:

public fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
public fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
 when (mode) {
 LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
 LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
 LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
 }

默认模式 LazyThreadSafetyMode.SYNCHRONIZED 将提供相对耗费昂贵的 双重检查锁 来保证一旦属性可以从多线程读取时初始化块可以安全地执行。

如果你确信属性只会在单线程(如主线程)被访问,那么可以选择 LazyThreadSafetyMode.NONE 来代替,从而避免使用锁的额外开销。

val dateFormat: DateFormat by lazy(LazyThreadSafetyMode.NONE) {
 SimpleDateFormat("dd-MM-yyyy", Locale.getDefault())
}

区间

区间 是 Kotlin 中用来代表一个有限的值集合的特殊表达式。值可以是任何 Comparable 类型。 这些表达式的形式都是创建声明了 ClosedRange 接口的方法。创建区间的主要方法是 .. 操作符方法。

包含

区间表达式的主要作用是使用 in 和 !in 操作符实现包含和不包含。

if (i in 1..10) {
 println(i)
}

该实现针对非空基本类型的区间(包括 Int、Long、Byte、Short、Float、Double 以及 Char 的值)实现了优化,所以上面的代码可以被优化成这样:

if(1 <= i && i <= 10) {
 System.out.println(i);
}

零额外支出并且没有额外对象开销。区间也可以被包含在 when 表达式中:

val message = when (statusCode) {
 in 200..299 -> "OK"
 in 300..399 -> "Find it somewhere else"
 else -> "Oops"
}

相比一系列的 if{…} else if{…} 代码块,这段代码在不降低效率的同时提高了代码的可读性。然而,如果在声明和使用之间有至少一次间接调用的话,range 会有一些微小的额外开销。

比如下面的代码:

private val myRange get() = 1..10
fun rangeTest(i: Int) {
 if (i in myRange) {
 println(i)
 }
}

在编译后会创建一个额外的 IntRange 对象:

private final IntRange getMyRange() {
 return new IntRange(1, 10);
}
public final void rangeTest(int i) {
 if(this.getMyRange().contains(i)) {
 System.out.println(i);
 }
}

将属性的 getter 声明为 inline 的方法也无法避免这个对象的创建。这是 Kotlin 1.1 编译器可以优化的一个点。至少通过这些特定的区间类避免了装箱操作。

说明:尽量在使用时直接声明非空基本类型的区间,不要间接调用,来避免额外区间类的创建。或者直接声明为常量来复用。

区间也可以用于其他实现了 Comparable 的非基本类型。

if (name in "Alfred".."Alicia") {
 println(name)
}

在这种情况下,最终实现并不会优化,而且总是会创建一个 ClosedRange 对象,如下面编译后的代码所示:

if(RangesKt.rangeTo((Comparable)"Alfred", (Comparable)"Alicia")
 .contains((Comparable)name)) {
 System.out.println(name);
}

迭代:for 循环

整型区间 (除了 Float 和 Double之外其他的基本类型)也是 级数:它们可以被迭代。这就可以将经典 Java 的 for 循环用一个更短的表达式替代。

for (i in 1..10) {
 println(i)
}

经过编译器优化后的代码实现了零额外开销:

int i = 1;
byte var3 = 10;
if(i <= var3) {
 while(true) {
 System.out.println(i);
 if(i == var3) {
 break;
 }
 ++i;
 }
}

如果要反向迭代,可以使用 downTo() 中缀方法来代替 ..:

for (i in 10 downTo 1) {
 println(i)
}

编译之后,这也实现了零额外开销:

int i = 10;
byte var3 = 1;
if(i >= var3) {
 while(true) {
 System.out.println(i);
 if(i == var3) {
 break;
 }
 --i;
 }
}

然而,其他迭代器参数并没有如此好的优化。反向迭代还有一种结果相同的方式,使用 reversed() 方法结合区间:

for (i in (1..10).reversed()) {
 println(i)
}

编译后的代码并没有看起来那么少:

IntProgression var10000 = RangesKt.reversed((IntProgression)(new IntRange(1, 10)));
int i = var10000.getFirst();
int var3 = var10000.getLast();
int var4 = var10000.getStep();
if(var4 > 0) {
 if(i > var3) {
 return;
 }
} else if(i < var3) {
 return;
}
while(true) {
 System.out.println(i);
 if(i == var3) {
 return;
 }

 i += var4;
}

会创建一个临时的 IntRange 对象来代表区间,然后创建另一个 IntProgression 对象来反转前者的值。

事实上,任何结合不止一个方法来创建递进都会生成类似的至少创建两个微小递进对象的代码。

这个规则也适用于使用 step() 中缀方法来操作递进的步骤,即使只有一步:

for (i in 1..10 step 2) {
 println(i)
}

一个次要提示,当生成的代码读取 IntProgression 的 last 属性时会通过对边界和步长的小小计算来决定准确的最后值。在上面的代码中,最终值是 9。

最后,until() 中缀函数对于迭代也很有用,该函数(执行结果)不包含最大值。

for (i in 0 until size) {
 println(i)
}

遗憾的是,编译器并没有针对这个经典的包含区间围优化,迭代器依然会创建区间对象:

IntRange var10000 = RangesKt.until(0, size);
int i = var10000.getFirst();
int var1 = var10000.getLast();
if(i <= var1) {
 while(true) {
 System.out.println(i);
 if(i == var1) {
  break;
 }
 ++i;
 }
}

这是 Kotlin 1.1 可以提升的另一个点,与此同时,可以通过这样写来优化代码:

for (i in 0..size - 1) {
 println(i)
}

说明:

for 循环内部的迭代,最好只用区间表达式的一个单独方法来调用 .. 或 downTo() 来避免额外临时递进对象的创建。

迭代:forEach()

作为 for 循环的替代,使用区间内联的扩展方法 forEach() 来实现相似的效果可能更吸引人。

(1..10).forEach {
 println(it)
}

但如果仔细观察这里使用的 forEach() 方法签名的话,你就会注意到并没有优化区间,而只是优化了 Iterable,所以需要创建一个 iterator。下面是编译后代码的 Java 形式:

Iterable $receiver$iv = (Iterable)(new IntRange(1, 10));
Iterator var1 = $receiver$iv.iterator();
while(var1.hasNext()) {
 int element$iv = ((IntIterator)var1).nextInt();
 System.out.println(element$iv);
}

这段代码相比前者更为低效,原因是为了创建一个 IntRange 对象,还需要额外创建 IntIterator。但至少它还是生成了基本类型的值。迭代区间时,最好只使用 for 循环而不是区间上的 forEach() 方法来避免额外创建一个迭代器。

迭代:集合

Kotlin 标准库提供了内置的 indices 扩展属性来生成数组和 Collection 的区间。

val list = listOf("A", "B", "C")
for (i in list.indices) {
 println(list[i])
}

令人惊讶的是,对这个 indices 的迭代得到了编译器的优化:

List list = CollectionsKt.listOf(new String[]{"A", "B", "C"});
int i = 0;
int var2 = ((Collection)list).size() - 1;
if(i <= var2) {
 while(true) {
 Object var3 = list.get(i);
 System.out.println(var3);
 if(i == var2) {
  break;
 }
 ++i;
 }
}

从上面的代码中我们可以看到没有创建 IntRange 对象,列表的迭代是以最高效率的方式运行的。

这适用于数组和实现了 Collection 的类,所以你如果期望相同的迭代器性能的话,可以尝试在特定的类上使用自己的 indices 扩展属性。

inline val SparseArray<*>.indices: IntRange
 get() = 0..size() - 1

fun printValues(map: SparseArray<String>) {
 for (i in map.indices) {
 println(map.valueAt(i))
 }
}

但编译之后,我们可以发现这并没有那么高效率,因为编译器无法足够智能地避免区间对象的产生:

public static final void printValues(@NotNull SparseArray map) {
 Intrinsics.checkParameterIsNotNull(map, "map");
 IntRange var10002 = new IntRange(0, map.size() - 1);
 int i = var10002.getFirst();
 int var2 = var10002.getLast();
 if(i <= var2) {
 while(true) {
  Object $receiver$iv = map.valueAt(i);
  System.out.println($receiver$iv);
  if(i == var2) {
  break;
  }
  ++i;
 }
 }
}

所以,我会建议你避免声明自定义的 lastIndex 扩展属性:

inline val SparseArray<*>.lastIndex: Int
 get() = size() - 1
fun printValues(map: SparseArray<String>) {
 for (i in 0..map.lastIndex) {
 println(map.valueAt(i))
 }
}

说明:当迭代没有声明 Collection 的自定义集合 时,直接在 for 循环中写自己的序列区间而不是依赖方法或属性来生成区间,从而避免区间对象的创建。

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对我们的支持。

(0)

相关推荐

  • Kotlin开发笔记之委托属性与区间(译)

    前言 本文主要给大家介绍了关于Kotlin委托属性与区间的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. 委托属性 有一些常见的属性类型,虽然我们可以在每次需要的时候手动实现它们, 但是如果能够为大家把他们只实现一次并放入一个库会更好.例如包括 延迟属性(lazy properties): 其值只在首次访问时计算, 可观察属性(observable properties): 监听器会收到有关此属性变更的通知, 把多个属性储存在一个映射(map)中,而不是每个存在单独的

  • Kotlin 开发环境详解及简单实例

    Hello Kotlin 在前段时间举办的Google I/O 2017上,Google宣布Kotlin成为Android官方的开发语言,这个最初发布于2011年的语言在短短的时间内就吸引了大量的开发者,而Google使得它进入了更多人的视线. Kotlin是一种开源的基于JVM的变成语言,由JetBeans公司开发(大概除了使用VS的.net开发者意外,都会或多或少听说或使用过IDEA吧),名字取自圣彼得堡附近的一个小岛(Koltin island). Kotlin是一种简单的语言,其主要目标

  • Kotlin开发Android应用实例详解

    Kotlin开发Android应用实例详解 相关文章:关于Kotlin语言的基础介绍: http://www.jb51.net/article/114086.htm 我们简单的知道了Kotlin这门新语言的优势,也接触了一些常见的语法及其简单的使用,相信你会对它有浓厚的兴趣,暂且理解为对它感兴趣吧,哈哈哈.那么,我们该如何在Android中应用这门新的语言呢?今天的这篇文章带你学习使用Kotlin开发Android应用,并对比我们传统语言Java,让你真真切切的感受到他的美和优雅. 配置 项目g

  • Kotlin开发的一些实用小技巧总结

    前言 随着Google I/O大会的召开,Google宣布将支持Kotlin作为Android的开发语言,最近关于Kotlin的文章.介绍就异常的活跃. 本文主要给大家介绍了关于Kotlin开发的一些实用小技巧,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. 1.Lazy Loading(懒加载) 延迟加载有几个好处.延迟加载能让程序启动时间更快,因为加载被推迟到访问变量时. 这在使用 Kotlin 的 Android 应用程序而不是服务器应用程序中特别有用.对于 Androi

  • .Net WInform开发笔记(三)谈谈自制控件(自定义控件)

    末日这天写篇博客吧,既然没来,那就纪念一下. 这次谈谈自制控件,也就是自定义控件,先上图,再说 1.扩展OpenFileDialog,在OpenFileDialog中添加各种文件(.txt,.jpg,.excel等等)的预览功能 2.重写ListBox,增加折叠.鼠标背影.分类等功能 -----------------------------分割线--------------------------------------------------------------一.扩展OpenFileD

  • Android开发笔记之:AsyncTask的应用详解

    AsyncTask的介绍及基本使用方法关于AsyncTask的介绍和基本使用方法可以参考官方文档和<Android开发笔记之:深入理解多线程AsyncTask>这里就不重复.AsyncTask引发的一个问题上周遇到了一个极其诡异的问题,一个小功能从网络上下载一个图片,然后放到ImageView中,是用AsyncTask来实现的,本身逻辑也很简单,仅是在doInBackground中用HTTP请求把图片的输入流取出,然后用BitmapFactory去解析,然后再把得到的Bitmap放到Image

  • 使用Kotlin开发Android应用的初体验

    昨晚,最近一届的谷歌IO大会正式将Kotlin确定为了官方开发语言,作为一名Android开发鸟,怎么能不及时尝尝鲜呢? Kotlin的简要介绍 在开发之前,很多同学一定有很多疑问,Kotlin到底有啥好处,怎么和现有的项目共存呢?Java那么些特性Kotlin都有吗?嗯,让我们一一来看. Kotlin 非常适合开发 Android 应用程序,将现代语言的所有优势带入 Android 平台而不会引入任何新的限制: 兼容性:Kotlin 与 JDK 6 完全兼容,保障了 Kotlin 应用程序可以

  • .Net Winform开发笔记(四)透过现象看本质

    写在前面: 从一个窗体的创建显示,再到与用户的交互,最后窗体关闭,这中间经历过了一系列复杂的过程,本文将从Winform应用程序中的Program.cs文件的第一行代码开始,逐步分析一个Winform应用程序到底是怎样从出生走向死亡,这其中包括Form.Show()和Form.ShowDialog()的区别.模式对话框形成的本质原因.消息循环.Windows事件与.net中事件(Event)的区别.System.Windows.Form.Application类的作用.以及我之前一篇博客中(.N

  • Android Kotlin开发实例(Hello World!)及语法详解

    Android Kotlin开发实例及语法详解 前言 Kotlin是一种在 Java虚拟机上执行的静态型别编程语言,它主要是由俄罗斯圣彼得堡的JetBrains开发团队所发展出来的编程语言.该语言有几个优势 1. 简洁 它大大减少你需要写的样板代码的数量. 2. 安全 避免空指针异常等整个类的错误. 3. 通用 构建服务器端程序.Android 应用程序或者在浏览器中运行的前端程序. 4. 互操作性 通过 100% Java 互操作性,利用 JVM 既有框架和库. 配置 在我们的AndroidS

  • Android开发笔记之Android中数据的存储方式(二)

    我们在实际开发中,有的时候需要储存或者备份比较复杂的数据.这些数据的特点是,内容多.结构大,比如短信备份等.我们知道SharedPreferences和Files(文本文件)储存这种数据会非常的没有效率.如果学过JavaWeb的朋友,首先可能想到的是数据库.当然了数据库是一个方案,那么是否还有其他的解决方案呢?今天我们在讲下Android开发笔记之Android中数据的存储方式(一)提到的除了SharedPreferences和Files(文本文件)以外的其他几种数据储存方式:xml文件.SQL

随机推荐