Kotlin开发笔记之委托属性与区间（译）
前言
本文主要给大家介绍了关于Kotlin委托属性与区间的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。
委托属性
有一些常见的属性类型，虽然我们可以在每次需要的时候手动实现它们，但是如果能够为大家把他们只实现一次并放入一个库会更好。例如包括
- 延迟属性（lazyproperties）:其值只在首次访问时计算，
- 可观察属性（observableproperties）:监听器会收到有关此属性变更的通知，
- 把多个属性储存在一个映射（map）中，而不是每个存在单独的字段中。
为了涵盖这些（以及其他）情况，Kotlin支持委托属性:
classExample{
varp:StringbyDelegate()
}
委托属性是一种通过委托实现拥有getter和可选setter的属性，并允许实现可复用的自定义属性。例如：
classExample{
varp:StringbyDelegate()
}
委托对象必须实现一个拥有getValue()方法的操作符，以及setValue()方法来实现读/写属性。些方法将会接受包含对象实例以及属性元数据作为额外参数。当一个类声明委托属性时，编译器生成的代码会和如下Java代码相似。
publicfinalclassExample{
@NotNull
privatefinalDelegatep$delegate=newDelegate();
//$FF:syntheticfield
staticfinalKProperty[]$$delegatedProperties=newKProperty[]{(KProperty)Reflection.mutableProperty1(newMutablePropertyReference1Impl(Reflection.getOrCreateKotlinClass(Example.class),"p","getP()Ljava/lang/String;"))};
@NotNull
publicfinalStringgetP(){
returnthis.p$delegate.getValue(this,$$delegatedProperties[0]);
}
publicfinalvoidsetP(@NotNullStringvar1){
Intrinsics.checkParameterIsNotNull(var1,"");
this.p$delegate.setValue(this,$$delegatedProperties[0],var1);
}
}
一些静态属性元数据被加入到类中，委托在类的构造函数中初始化，并在每次读写属性时调用。
委托实例
在上面的例子中，创建了一个新的委托实例来实现属性。这就要求委托的实现是有状态的，例如，当其内部缓存计算结果时：
classStringDelegate{
privatevarcache:String?=null
operatorfungetValue(thisRef:Any?,property:KProperty<*>):String{
varresult=cache
if(result==null){
result=someOperation()
cache=result
}
returnresult
}
}
与此同时，当需要额外的参数时，需要建立新的委托实例，并将其传递到构造器中。
classExample{
privatevalnameViewbyBindViewDelegate(R.id.name)
}
但也有一些情况是只需要一个委托实例来实现任何属性的：当委托是无状态，并且它所需要的唯一变量就是已经提供好的包含对象实例和委托名称时，可以通过将其声明为object来替代class实现一个单例委托。
举个例子，下面的单例委托从AndroidActivity中取回与给定tag相匹配的Fragment。
objectFragmentDelegate{
operatorfungetValue(thisRef:Activity,property:KProperty<*>):Fragment?{
returnthisRef.fragmentManager.findFragmentByTag(property.name)
}
}
类似地，任何已有类都可以通过扩展变成委托。getValue()和setValue()也可以被声明成扩展方法来实现。Kotlin已经提供了内置的扩展方法来允许将MapandMutableMap实例用作委托，属性名作为其中的键。
如果你选择复用相同的局部委托实例来在一个类中实现多属性，你需要在构造函数中初始化实例。
注意：从Kotlin1.1开始，也可以声明方法局部变量声明为委托属性。在这种情况下，委托可以直到该变量在方法内部声明的时候才去初始化，而不必在构造函数中就执行初始化。
泛型委托
委托方法也可以被声明成泛型的，这样一来不同类型的属性就可以复用同一个委托类了。
privatevarmaxDelay:LongbySharedPreferencesDelegate()
然而，如果像上例那样对基本类型使用泛型委托的话，即便声明的基本类型非空，也会在每次读写属性的时候触发装箱和拆箱的操作。
说明：对于非空基本类型的委托属性来说，最好使用给定类型的特定委托类而不是泛型委托来避免每次访问属性时增加装箱的额外开销。
标准委托：lazy()
针对常见情形，Kotlin提供了一些标准委托，如Delegates.notNull()、Delegates.observable()和lazy()。
lazy()是一个在第一次读取时通过给定的lambda值来计算属性的初值，并返回只读属性的委托。
privatevaldateFormat:DateFormatbylazy{
SimpleDateFormat("dd-MM-yyyy",Locale.getDefault())
}
这是一种简洁的延迟高消耗的初始化至其真正需要时的方式，在保留代码可读性的同时提升了性能。
需要注意的是，lazy()并不是内联函数，传入的lambda参数也会被编译成一个额外的Function类，并且不会被内联到返回的委托对象中。
经常被忽略的一点是lazy()有可选的mode参数来决定应该返回3种委托的哪一种：
publicfunlazy(initializer:()->T):Lazy =SynchronizedLazyImpl(initializer) publicfun lazy(mode:LazyThreadSafetyMode,initializer:()->T):Lazy = when(mode){ LazyThreadSafetyMode.SYNCHRONIZED->SynchronizedLazyImpl(initializer) LazyThreadSafetyMode.PUBLICATION->SafePublicationLazyImpl(initializer) LazyThreadSafetyMode.NONE->UnsafeLazyImpl(initializer) }
默认模式LazyThreadSafetyMode.SYNCHRONIZED将提供相对耗费昂贵的双重检查锁来保证一旦属性可以从多线程读取时初始化块可以安全地执行。
如果你确信属性只会在单线程（如主线程）被访问，那么可以选择LazyThreadSafetyMode.NONE来代替，从而避免使用锁的额外开销。
valdateFormat:DateFormatbylazy(LazyThreadSafetyMode.NONE){
SimpleDateFormat("dd-MM-yyyy",Locale.getDefault())
}
区间
区间是Kotlin中用来代表一个有限的值集合的特殊表达式。值可以是任何Comparable类型。这些表达式的形式都是创建声明了ClosedRange接口的方法。创建区间的主要方法是..操作符方法。
包含
区间表达式的主要作用是使用in和!in操作符实现包含和不包含。
if(iin1..10){
println(i)
}
该实现针对非空基本类型的区间（包括Int、Long、Byte、Short、Float、Double以及Char的值）实现了优化，所以上面的代码可以被优化成这样：
if(1<=i&&i<=10){
System.out.println(i);
}
零额外支出并且没有额外对象开销。区间也可以被包含在when表达式中：
valmessage=when(statusCode){
in200..299->"OK"
in300..399->"Finditsomewhereelse"
else->"Oops"
}
相比一系列的if{…}elseif{…}代码块，这段代码在不降低效率的同时提高了代码的可读性。然而，如果在声明和使用之间有至少一次间接调用的话，range会有一些微小的额外开销。
比如下面的代码：
privatevalmyRangeget()=1..10
funrangeTest(i:Int){
if(iinmyRange){
println(i)
}
}
在编译后会创建一个额外的IntRange对象：
privatefinalIntRangegetMyRange(){
returnnewIntRange(1,10);
}
publicfinalvoidrangeTest(inti){
if(this.getMyRange().contains(i)){
System.out.println(i);
}
}
将属性的getter声明为inline的方法也无法避免这个对象的创建。这是Kotlin1.1编译器可以优化的一个点。至少通过这些特定的区间类避免了装箱操作。
说明：尽量在使用时直接声明非空基本类型的区间，不要间接调用，来避免额外区间类的创建。或者直接声明为常量来复用。
区间也可以用于其他实现了Comparable的非基本类型。
if(namein"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(iin1..10){
println(i)
}
经过编译器优化后的代码实现了零额外开销：
inti=1;
bytevar3=10;
if(i<=var3){
while(true){
System.out.println(i);
if(i==var3){
break;
}
++i;
}
}
如果要反向迭代，可以使用downTo()中缀方法来代替..：
for(iin10downTo1){
println(i)
}
编译之后，这也实现了零额外开销：
inti=10;
bytevar3=1;
if(i>=var3){
while(true){
System.out.println(i);
if(i==var3){
break;
}
--i;
}
}
然而，其他迭代器参数并没有如此好的优化。反向迭代还有一种结果相同的方式，使用reversed()方法结合区间：
for(iin(1..10).reversed()){
println(i)
}
编译后的代码并没有看起来那么少：
IntProgressionvar10000=RangesKt.reversed((IntProgression)(newIntRange(1,10)));
inti=var10000.getFirst();
intvar3=var10000.getLast();
intvar4=var10000.getStep();
if(var4>0){
if(i>var3){
return;
}
}elseif(i
会创建一个临时的IntRange对象来代表区间，然后创建另一个IntProgression对象来反转前者的值。
事实上，任何结合不止一个方法来创建递进都会生成类似的至少创建两个微小递进对象的代码。
这个规则也适用于使用step()中缀方法来操作递进的步骤，即使只有一步：
for(iin1..10step2){
println(i)
}
一个次要提示，当生成的代码读取IntProgression的last属性时会通过对边界和步长的小小计算来决定准确的最后值。在上面的代码中，最终值是9。
最后，until()中缀函数对于迭代也很有用，该函数（执行结果）不包含最大值。
for(iin0untilsize){
println(i)
}
遗憾的是，编译器并没有针对这个经典的包含区间围优化，迭代器依然会创建区间对象：
IntRangevar10000=RangesKt.until(0,size);
inti=var10000.getFirst();
intvar1=var10000.getLast();
if(i<=var1){
while(true){
System.out.println(i);
if(i==var1){
break;
}
++i;
}
}
这是Kotlin1.1可以提升的另一个点，与此同时，可以通过这样写来优化代码：
for(iin0..size-1){
println(i)
}
说明：
for循环内部的迭代，最好只用区间表达式的一个单独方法来调用..或downTo()来避免额外临时递进对象的创建。
迭代：forEach()
作为for循环的替代，使用区间内联的扩展方法forEach()来实现相似的效果可能更吸引人。
(1..10).forEach{
println(it)
}
但如果仔细观察这里使用的forEach()方法签名的话，你就会注意到并没有优化区间，而只是优化了Iterable，所以需要创建一个iterator。下面是编译后代码的Java形式：
Iterable$receiver$iv=(Iterable)(newIntRange(1,10));
Iteratorvar1=$receiver$iv.iterator();
while(var1.hasNext()){
intelement$iv=((IntIterator)var1).nextInt();
System.out.println(element$iv);
}
这段代码相比前者更为低效，原因是为了创建一个IntRange对象，还需要额外创建IntIterator。但至少它还是生成了基本类型的值。迭代区间时，最好只使用for循环而不是区间上的forEach()方法来避免额外创建一个迭代器。
迭代：集合
Kotlin标准库提供了内置的indices扩展属性来生成数组和Collection的区间。
vallist=listOf("A","B","C")
for(iinlist.indices){
println(list[i])
}
令人惊讶的是，对这个indices的迭代得到了编译器的优化：
Listlist=CollectionsKt.listOf(newString[]{"A","B","C"});
inti=0;
intvar2=((Collection)list).size()-1;
if(i<=var2){
while(true){
Objectvar3=list.get(i);
System.out.println(var3);
if(i==var2){
break;
}
++i;
}
}
从上面的代码中我们可以看到没有创建IntRange对象，列表的迭代是以最高效率的方式运行的。
这适用于数组和实现了Collection的类，所以你如果期望相同的迭代器性能的话，可以尝试在特定的类上使用自己的indices扩展属性。
inlinevalSparseArray<*>.indices:IntRange
get()=0..size()-1
funprintValues(map:SparseArray){
for(iinmap.indices){
println(map.valueAt(i))
}
}
但编译之后，我们可以发现这并没有那么高效率，因为编译器无法足够智能地避免区间对象的产生：
publicstaticfinalvoidprintValues(@NotNullSparseArraymap){
Intrinsics.checkParameterIsNotNull(map,"map");
IntRangevar10002=newIntRange(0,map.size()-1);
inti=var10002.getFirst();
intvar2=var10002.getLast();
if(i<=var2){
while(true){
Object$receiver$iv=map.valueAt(i);
System.out.println($receiver$iv);
if(i==var2){
break;
}
++i;
}
}
}
所以，我会建议你避免声明自定义的lastIndex扩展属性：
inlinevalSparseArray<*>.lastIndex:Int
get()=size()-1
funprintValues(map:SparseArray){
for(iin0..map.lastIndex){
println(map.valueAt(i))
}
}
说明：当迭代没有声明Collection的自定义集合时，直接在for循环中写自己的序列区间而不是依赖方法或属性来生成区间，从而避免区间对象的创建。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对毛票票的支持。