Método de partición de Kotlin() con ejemplos

En este artículo, vamos a discutir cómo dividir la colección original en un par de colecciones, porque a veces, mientras codificas, deseas poder dividir una lista en sublistas sin entrar en los bucles for y while. Kotlin te proporciona una función solo para esta ocasión. En este artículo, veremos cómo dividir una lista según algunos criterios. Suponga que hay una lista en la que necesita realizar una operación para segregar sus elementos en dos listas, una que cumple alguna condición y la otra que no. La forma típica de hacer esto es ejecutar un ciclo sobre el objeto de colección y agregar una condición if dentro y segregar el objeto.

val list = listOf(1 , 2, 3, 4, 5)
  
val evenList = mutableListOf<Int>()
val oddList = mutableListOf<Int>()
  
for(item in list){
    if(item % 2 == 0){
        evenList.add(item)
    } else {
        oddList.add(item)
    }
}
  
println(evenList)
println(oddList)

Kotlin tiene algo incorporado que puede hacer tu vida más fácil. Hay una partición de operador que llama() que puede segregar la lista en dos listas, una con los elementos que coinciden con la condición y otra con la condición que no coincide, y el código será así:

val list = listOf(1 , 2, 3, 4, 5)
val (even, odd) = list.partition { it % 2 == 0}
     
println(even)
println(odd)

Kotlin proporciona una función de partición. De acuerdo con la documentación de la función de partición, hace lo siguiente: divide la array original en un par de listas, donde la primera lista contiene elementos para los cuales el predicado arrojó verdadero, mientras que la segunda lista contiene elementos para los cuales el predicado arrojó falso.

Ejemplo 1:

En este ejemplo, crearemos una lista de números y queremos dividir esta lista en dos sublistas: una con números impares y otra con números pares:

fun main (args: Array<String>){
  val listA= listof (1, 2, 3, 4, 5, 6)
  val pair = listA.partition {
    it%2==0
  }
  println(pair)
}

Producción:

( [2, 4, 6], [1, 3, 5])

Como puede ver en el ejemplo anterior, necesitamos colocar la condición en el predicado dentro del bloque de partición . El objeto devuelto es un objeto Par, que contiene las dos sublistas. La función de partición también funciona con la colección de conjuntos de manera similar:

val setA= setof (1, 2, 3, 4, 5, 6)
val pair= setA.partition{
  it$2-=0
}
printin (pair)

Producción:

([2, 4, 6], [1, 3, 5])

Explicación:

Echemos un vistazo a la implementación de la función de partición en Kotlin:

public inline fun <T> Iterable<T> .partition (predicate: (T) -> Boolean) :
Pair<List<T>, List<T>>{
  val first = ArrayList<T>()
  val second = ArrayList <T> ()
  for (element in this) {
    if (predicate (element) ) {
      first.add (element)
    } else {
       second.add(element)
    }
  }
  return Pair (first, second)
}

Como puede ver, la función de partición es solo una abstracción, que le evita escribir bucles largos, pero internamente lo hace de la misma manera.

Ejemplo 2:

La función de partición también funciona de manera similar con arrays. Aquí están sus diferentes usos. Cada uno de ellos funciona de manera similar, simplemente produciendo listas de diferentes tipos:

// Produces two lists
inline fun <T> Array< out T>.partition(
  predicate: (T) -> Boolean
): Pair<List<T>, List<T>>
    
// Breaks original list of Byte 
// and produces two lists of Byte
inline fun ByteArray.partition(
  predicate: (Byte) -> Boolean
): Pair<List<Byte>, List<Byte>>
    
// Breaks original list of Short 
// and produces two lists of Short
inline fun ShortArray.partition(
  predicate: (Short) -> Boolean
): Pair<List<Short>, List<Short>>
  
// Breaks original list of Int 
// and produces two lists of Int
inline fun IntArray.partition(
  predicate: (Int) -> Boolean
): Pair<List<Int>, List<Int>>
  
// Breaks original list of Long 
// and produces two lists of Long
inline fun LongArray.partition(
  predicate: (Long) -> Boolean
): Pair<List<Long>, List<Long>>
    
// Breaks original list of Float 
// and produces two lists of Float
inline fun FloatArray.partition(
  predicate: (Float) -> Boolean
): Pair<List<Float>, List<Float>>
  
// Breaks original list of Double 
// and produces two lists of Double
inline fun DoubleArray.partition (
  predicate: (Double) -> Boolean
): Pair<List<Double>, List<Double>>
  
// Breaks original list of Boolean 
// and produces two lists of Boolean
inline fun BooleanArray.partition (
  predicate: (Boolean) -> Boolean
): Pair<List<Boolean>, List<Boolean>>
  
// Breaks original list of Char 
// and produces two lists of Char
inline fun CharArray.partition (
  predicate: (Char) -> Boolean
): Pair<List<Char>, List<Char>>