Kotlin | Colecciones de filtrado

En Kotlin , el filtrado es una tarea destacada del procesamiento de colecciones. Las condiciones de filtrado se definen mediante predicados: funciones lambda que toman un elemento de colección y devuelven verdadero cuando el elemento dado coincide con el predicado, y falso significa que no coincide con el predicado. 
 

• Hay una biblioteca estándar que contiene varias funciones que le permiten filtrar las colecciones en una sola llamada.
• Estas funciones no cambian el contenido de la colección original ni están disponibles tanto para inmutables como para mutables.
• Podemos asignarlo a una variable o enstringr las funciones después del filtrado para operar el resultado del filtrado.

Filtrado por predicados –

• La función básica es filter() que se utilizará para filtrar.
• Cuando se llama a la función filter() con un predicado, devuelve los elementos de la colección que coinciden con el predicado.
• Para List y Set , la colección resultante también es List , pero para Map devolverá Map.

Programa Kotlin para usar la función de filtro en la lista y la colección de mapas: 
 

fun main(args: Array<String>)
{
    //declaring a list of elements
    val list = listOf("geeks","for","geeks","hello","world")
  
    //filtering all words with length > 4
    val longerThan4 = list.filter { it.length > 4 }
    println(longerThan4)
 
    //declaring a map of string to integers
    val numbersMap = mapOf("key13" to 10, "key25" to 20,
        "key34" to 30, "key45" to 40, "key55" to 50 )
 
    //filtering the map with some predicates
    val filteredMap = numbersMap.filter { (key, value) ->
        key.endsWith("5") && value > 20}
    println(filteredMap)
}

Producción: 
 

[geeks, geeks, hello, world]
{key45=40, key55=50}

Variaciones en filter()

• Si queremos filtrar usando el índice o la posición del elemento , tenemos que usar filterIndexed() .
• La función filterIndexed() toma un predicado con dos argumentos: índice y el valor de un elemento .
• Podemos filtrar las colecciones por condiciones negativas usando filterNot() .

Programa Kotlin de usar las funciones filterIndexed() y filterNot() – 
 

fun main(args: Array<String>) {
    val words = listOf("geek","for","geeks","all","world")
 
    //filtering a list by : words having length < 6 and index != 0
    val filteredIndex = words.filterIndexed { index, s ->
        (index != 0) && (s.length < 6)  }
 
    //filtering words having length >=3 using filterNot
    val filteredNot = words.filterNot { it.length <= 3 }
 
    println(filteredIndex)
    println(filteredNot)
}

Producción: 
 

[for, geeks, all, world]
[geek, geeks, world]

Fraccionamiento –

Hay otra función de filtrado de partición() que filtra una colección por un predicado y separa todos los elementos, que no coinciden con el predicado y se colocan en una lista diferente. 
Básicamente, devuelve un par de listas : la primera lista contiene los elementos que coinciden con el predicado y la segunda lista contiene todos los elementos de la colección original que no coinciden con el predicado.
Programa Kotlin de uso de particionamiento – 
 

fun main(args: Array<String>) {
 
    val words = listOf("geek","for","geeks","hello","world")
 
    //partitioning the words by length > 4 and length <= 4
    val (first, second) = words.partition { it.length > 4 }
 
    println(first)
    println(second)
}

Producción: 
 

[geeks, hello, world]
[geek, for]

Prueba de predicados –

Algunas de las funciones para probar un predicado contra los elementos de la colección son las siguientes: 
 

• any() : Devuelve verdadero si al menos un elemento coincide con el predicado dado.
• none() : Devuelve verdadero si ninguno de los elementos coincide con el predicado dado.
• all() : Devuelve verdadero si todos los elementos de la colección coinciden con el predicado dado.

Nota: all() devuelve verdadero cuando se llama con cualquier predicado válido en una colección vacía. Esto se conoce como verdad vacía . 
Podemos usar any() y none() sin un predicado, solo comprobará si la colección está vacía , es decir, any() devolverá verdadero si la colección tiene elementos y falso si está vacío ; none() hace justo lo contrario de any(). Programa Kotlin para usar las funciones any(), none() y all() –
 
 

fun main(args: Array<String>) {
    val words = listOf("geeks","for","geeeks","hello","world")
 
    //checking if atleast one word ends with s or not
    println("Any element matches? "+words.any { it.endsWith("s") })
 
    //checking if no word ends with a or not
    println("No element matches? "+words.none { it.endsWith("a") })
 
    println("All element match? "+words.all { it.endsWith("d") })
    //checking if all words end with d or not
 
    //when predicate is empty, it checks for emptiness
    println(words.any())
    println(words.none())
 
    //all function on an empty list
    println(emptyList<Int>().all { it > 5 })   // vacuous truth
 
    val empty = emptyList<String>()
 
    //any function on an empty list returns false
    println(empty.any())
    //none function on an empty list returns true
    println(empty.none())
}

Producción: 
 

Any element matches? true
No element matches? true
All element match? false
true
false
true
false
true