¿Qué conveniencia puede aportar la biblioteca oficial core-ktx al desarrollo de la serie SparseArray y Pair?

Este artículo es una investigación oficial core-ktx库的第三篇文章, con el objetivo de explorar qué clases de herramientas o métodos en la biblioteca pueden mejorar nuestra eficiencia de desarrollo.

Los enlaces de referencia para los dos primeros artículos son los siguientes:

¿Qué ventajas puede aportar la biblioteca oficial core-ktx al desarrollo que necesita saber?

¿Qué conveniencia puede aportar la biblioteca oficial core-ktx al desarrollo de tramos de texto enriquecido?

¡ Este artículo es principalmente para estudiar la conveniencia de core-ktxla biblioteca para SparseArrayseries y Paircódigo de desarrollo! !

`SparseArray`serie

SparseArray, LongSparseArrayla serie es un tipo de clase key-valuede encapsulación que admite lectura y escritura en forma de estructura de datos. En comparación con HashMapella, hay dos puntos:

El valor clave keyes un tipo de datos básico, no una clase contenedora correspondiente al tipo de datos básico, no es necesario装箱

Su estructura de datos es una matriz de valores clave keyy una matriz de valuevalores, a diferencia de HashMap, basada Entryen key-valueencapsulación y luego lectura y escritura .

PD: Hay otra serie de colecciones en Android SparseIntArray, estas colecciones son más poderosas, SparseBooleanArrayno necesitan boxeo, no las confundas con las colecciones anteriores. Sin embargo, los paquetes de extensión proporcionados por estas dos colecciones son casi iguales, por lo que no se explicarán individualmente.SparseLongArraykey和value都是基本数据类型core-ktx

SparseArray<T>.size()obtener el tamaño de la colección

Esto no es nada nuevo, simplemente encapsula la SparseArrayforma original de obtener el tamaño size(). Con la ayuda del azúcar sintáctico de kotlin, se puede 属性llamar como ( 本质上还是调用的方法):
```
private fun test5() {
    val sparseArray: SparseArray<String> = SparseArray<String>()
    val size = sparseArray.size
}
复制代码
```
SparseArray<T>.contains(key: Int)El juicio incluye especificarkey

Puede ver que este método operatorestá decorado, es un método de sobrecarga de operadores, sobrecargando el operador in, use lo siguiente:
```
@RequiresApi(Build.VERSION_CODES.R)
private fun test5() {
    val sparseArray: SparseArray<String> = SparseArray<String>()
    val isContain = 5 in sparseArray
}
复制代码
```
不过这个api要求SDK>=30才能使用，我们可以直接将源码copy到项目工具类库中使用即可。

SparseArray<T>.plus(other: SparseArray<T>)并合并两个集合为一个新集合

这也是一个运算符重载函数，重载了运算符+，项目中可以这样使用：

private fun test5() {
    val sparseArray1: SparseArray<String> = SparseArray<String>()
    val sparseArray2: SparseArray<String> = SparseArray<String>()
    val newArray = sparseArray1 + sparseArray2
}
复制代码

SparseArray<T>.containsValue(value: T)判断是否存在指定value

这个和上面的contains方法类似，不过这个是判断某个value值是否在该集合中，同样也是重载了运算符in

SparseArray<T>.set(key: Int, value: T)写入数据

重载了运算符[]的函数，可以这样向集合中写入数据：

private fun test5() {
    val sparseArray1: SparseArray<String> = SparseArray<String>()
    sparseArray1[10] = ""
}
复制代码

SparseArray<T>.getOrDefault(key: Int, defaultValue: T)带默认值的读值

这个方法和HashMap的getOrDefault()类似，当获取的值为null时，就返回默认值：
```
private fun test5() {
    val sparseArray1: SparseArray<String> = SparseArray<String>()
    sparseArray1.getOrDefault(10, "null")
}
复制代码
```
SparseArray<T>.getOrElse(key: Int, defaultValue: () -> T)带默认函数类型返回值的读值

这个和上面的getOrDefault()比较像，只不过提供默认值的不再是一个固定的具体类型的值，而是一个灵活的函数类型，我们可以在这个函数类型中进行额外的逻辑编写：
```
private fun test5() {
    val sparseArray1: SparseArray<String> = SparseArray<String>()
    sparseArray1.getOrElse(10) {
        val tmp = "哈哈哈${sparseArray1.size}"
        tmp
    }
} 
复制代码
```
SparseArray<T>.isEmpty()判断集合是否为空的
SparseArray<T>.remove(key: Int, value: T)移除指定key-value

SparseArray<T>.forEach(action: (key: Int, value: T) -> Unit)遍历

使用：


private fun test5() {
    val sparseArray1: SparseArray<String> = SparseArray<String>()
    sparseArray1.forEach { key, value ->
        //执行操作
    }
}
复制代码

SparseArray<T>.keyIterator()遍历键值key

这个方法会返回一个迭代器，这样我们就可以使用for in来遍历键值key了：
```
private fun test5() {
    val sparseArray1: SparseArray<String> = SparseArray<String>()
    for (key in sparseArray1.keyIterator()) {
        //执行操作
    }
}
复制代码
```
自定义迭代器就可以帮助我们实现通过for in关键字遍历，具体的可以参考我之前写的一篇文章：你需要懂的Kotlin开发技巧之八#运算符重载for in。
SparseArray<T>.valueIterator()遍历value

使用起来和上面的keyIterator()方法类似。

`Pair<F, S>`系列

componentX()解构

这也是一个operator修饰的运算符重载函数，关于这个解构，我不太该怎么去用语言来描述，大家直接看下使用吧：
```
private fun test6() {
    val pair = Pair(10, "ha")
    val (key, value) = pair
}
复制代码
```
就是可以直接将这个对象的内部属性赋值给局部声明的变量，如果你只使用key或value，可以将不想要解构的属性使用_代替： val (key , _) = pair //只使用key

El método de extensión de esta estructura se proporciona especialmente para objetos Java(incluidos los de los paquetes android y androidX) , y no es necesario implementarlo usted mismo , porque el objeto declarado es uno , y generará un método de desestructuración para nosotros de forma predeterminada :PairKotlinPairPairdata classdata class

Descompile en código Java para ver la componentX()serie de métodos generados.
javaconversión hacia y kotlindesdePair

toKotlinPairConvertir androidx包el Pairobjeto en Kotlinel Pairobjeto.
toAndroidXPairConvertir kotlinel Pairobjeto en androidx包el Pairobjeto.
toKotlinPairConvertir android包el Pairobjeto en Kotlinel Pairobjeto.
toAndroidPairConvertir kotlinel Pairobjeto en android包el Pairobjeto.

Resumir

Para obtener el código fuente detallado, consulte el código fuente de archivos como , , , etc. core-ktxen el paquete . A continuación, estoy listo para estudiar algunas herramientas de extensión para operaciones bajo el paquete (muchas, muchas categorías):SparseArray.ktPair.ktSparseXXXArray.ktcore-ktxgraphicsView

Eche un vistazo a la comodidad que puede aportar a nuestro Viewdesarrollo común, ¡esté atento! !

Estoy participando en el reclutamiento del programa de firma de creadores de la Comunidad Tecnológica de Nuggets, haga clic en el enlace para registrarse y enviar .