0Pricing
Kotlin Academy · Lección

filter, filterNot y partition

Divida y seleccione elementos mediante funciones basadas en predicados.

filter, filterNot y partition es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Operaciones de selección

filter conserva los elementos que coinciden con un predicado. filterNot conserva los que NO coinciden. partition divide la colección en dos listas de una sola vez.

filter básico

filter { ... } devuelve una lista nueva que contiene únicamente los elementos cuyo predicado es verdadero.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5, 6)
    val evens = nums.filter { it % 2 == 0 }
    println(evens) // [2, 4, 6]
}

filterNot

filterNot { ... } es la inversa: conserva los elementos cuyo predicado es falso. Produce el mismo resultado que invertir el predicado, pero expresa la intención con mayor claridad.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5, 6)
    val odds = nums.filterNot { it % 2 == 0 }
    println(odds) // [1, 3, 5]
}

partition

partition devuelve un Pair: primero los elementos coincidentes y después los que no coinciden. Evita recorrer los datos dos veces.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5, 6)
    val (evens, odds) = nums.partition { it % 2 == 0 }
    println("evens=$evens odds=$odds")
}

partition con una clase de datos

Divida una lista de registros en dos grupos en una sola pasada.

data class User(val name: String, val active: Boolean)
fun main() {
    val users = listOf(User("Ada", true), User("Ben", false), User("Cal", true))
    val (active, inactive) = users.partition { it.active }
    println("active=${active.map { it.name }}")
    println("inactive=${inactive.map { it.name }}")
}

filterIndexed

El predicado recibe tanto el índice como el valor; resulta útil cuando la posición es importante.

fun main() {
    val nums = listOf(10, 20, 30, 40, 50)
    val every2nd = nums.filterIndexed { i, _ -> i % 2 == 0 }
    println(every2nd) // [10, 30, 50]
}

filterIsInstance

Conserve únicamente los elementos de un tipo específico; dentro se aplican conversiones inteligentes de tipo.

fun main() {
    val mixed: List<Any> = listOf(1, "hello", 2.0, "world", 3)
    val onlyStrings = mixed.filterIsInstance<String>()
    println(onlyStrings) // [hello, world]
}

filterNotNull

Elimine las entradas nulas de una lista de elementos anulables; devuelve una lista de elementos no nulos.

fun main() {
    val mixed: List<String?> = listOf("a", null, "b", null, "c")
    val nonNull = mixed.filterNotNull()
    println(nonNull) // [a, b, c]
}

Encadenamiento de filter y map

Combine filter y map para crear pipelines de selección y transformación.

data class Product(val name: String, val price: Double, val inStock: Boolean)
fun main() {
    val products = listOf(
        Product("Pen", 1.0, true),
        Product("Book", 12.0, false),
        Product("Lamp", 25.0, true)
    )
    val availableNames = products.filter { it.inStock }.map { it.name }
    println(availableNames) // [Pen, Lamp]
}

Negación con filterNot para mayor claridad

A veces filterNot { it.isActive } se lee mejor que filter { !it.isActive }.

data class Task(val title: String, val done: Boolean)
fun main() {
    val tasks = listOf(Task("Email", true), Task("Lunch", false), Task("Code", true))
    val pending = tasks.filterNot { it.done }
    println(pending) // [Task(title=Lunch, done=false)]
}

partition devuelve listas

El Pair de partition contiene dos Lists normales; puede desestructurarlas o acceder a ellas mediante .first y .second.

fun main() {
    val nums = (1..10).toList()
    val result = nums.partition { it > 5 }
    println("above 5: ${result.first}")
    println("below 6: ${result.second}")
}

partition frente a dos llamadas a filter

Si necesita ambos subconjuntos, partition es más rápido: realiza una pasada en lugar de dos.

fun main() {
    val nums = (1..10).toList()
    // Two passes:
    val a = nums.filter { it > 5 }
    val b = nums.filter { it <= 5 }
    // One pass:
    val (c, d) = nums.partition { it > 5 }
    println("$a $b")
    println("$c $d")
}

Comprobación rápida

¿Qué función devuelve los elementos coincidentes Y los que no coinciden en una sola pasada?

Resumen

filter selecciona las coincidencias; filterNot selecciona las no coincidencias; partition devuelve ambos grupos en una sola pasada. Utilice filterIsInstance para conservar elementos de un tipo y filterNotNull para descartar valores nulos. Encadene estas funciones con map para combinar selección y transformación.

Preguntas frecuentes

¿La lección «filter, filterNot y partition» es gratis?

Sí — el texto completo de «filter, filterNot y partition» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «filter, filterNot y partition»?

Divida y seleccione elementos mediante funciones basadas en predicados. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «filter, filterNot y partition»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. map y flatMap: transformar cada elemento
  2. filter, filterNot y partition
  3. fold, reduce y runningFold
  4. Encadenar pipelines y evitar listas intermedias con Sequence
← Volver a Kotlin Academy