PricingLoginStart free
Kotlin Academy · Aula

filter, filterNot e partition

Divida e selecione elementos usando funções baseadas em predicados.

Aula 2 de 414 etapas

filter, filterNot e partition é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Operações de seleção

filter mantém os elementos que correspondem a um predicado. filterNot mantém os que NÃO correspondem. partition divide a coleção em duas listas de uma só vez.

filter básico

filter { ... } retorna uma nova lista contendo apenas os elementos para os quais o predicado é verdadeiro.

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 { ... } é o inverso: mantém os elementos para os quais o predicado é falso. O resultado é o mesmo de inverter o predicado, mas a intenção fica mais clara.

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 retorna um Pair: primeiro os elementos correspondentes e depois os não correspondentes. Isso evita duas passagens pelos dados.

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 com classe de dados

Divida uma lista de registros em dois grupos em uma única passagem.

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

O predicado recebe o índice e o valor — útil quando a posição é 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

Mantenha apenas os elementos de um tipo específico — as conversões inteligentes de tipo funcionam internamente.

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

filterNotNull

Remova as entradas nulas de uma lista de valores que podem ser nulos — retorna uma lista de elementos não nulos.

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

Encadeamento de filter e map

Combine filter e map para criar cadeias de seleção e transformação.

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]
}

Negação com filterNot para maior clareza

Às vezes, filterNot { it.isActive } é mais legível do 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 retorna listas

O Pair de partition contém duas listas comuns — desestruture-as ou acesse-as por meio de .first / .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 versus duas chamadas de filter

Se precisar dos dois subconjuntos, partition será mais rápido — uma passagem em vez de duas.

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")
}

Verificação rápida

Qual função retorna AMBOS os elementos correspondentes e não correspondentes em uma única passagem?

Responda na aula interativa

Recapitulação

filter seleciona correspondências; filterNot seleciona não correspondências; partition retorna os dois grupos em uma única passagem. Use filterIsInstance para manter elementos de um tipo e filterNotNull para descartar valores nulos. Encadeie com map para realizar seleção e transformação.

Grátis para começar

Aprenda Kotlin com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
51
Aulas
203
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “filter, filterNot e partition” é grátis?

Sim — o texto completo de “filter, filterNot e partition” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “filter, filterNot e partition”?

Divida e selecione elementos usando funções baseadas em predicados. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “filter, filterNot e partition”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. map e flatMap: transformando cada elemento
  2. filter, filterNot e partition
  3. fold, reduce e runningFold
  4. Encadeando pipelines e evitando listas intermediárias com Sequence
← Voltar para Kotlin Academy