Kotlin partition() 方法及示例

在本文中，我们将讨论如何将原始集合拆分为一对集合，因为有时在编码时，您希望可以将一个列表拆分为子列表，而无需进入 for 和 while 循环。 Kotlin 为您提供了一个专门用于这种场合的函数。在本文中，我们将了解如何根据某些标准拆分列表。假设有一个列表，您需要对其执行操作以将其项目分成两个列表，一个同意某些条件，另一个不同意。执行此操作的典型方法是在集合对象上运行一个循环，并在其中添加一个 if 条件并隔离该对象。

Kotlin

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

Kotlin 内置了一些东西，可以让你的生活更轻松。有一个运算符 caller partition()可以将列表分成两个列表，一个是条件匹配的项目，另一个是不匹配条件的项目，代码如下：

科特林

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

Kotlin 提供了一个分区函数。根据 partition 函数的文档，它执行以下操作，将原始数组拆分为一对列表，其中第一个列表包含谓词为真的元素，而第二个列表包含谓词为假的元素。

示例 1：

在本例中，我们将创建一个数字列表，并将此列表拆分为两个子列表：一个具有奇数，另一个具有偶数：

科特林

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

输出：

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

正如您在前面的示例中看到的，我们需要将条件放在分区块内的谓词中。返回的对象是一个 Pair 对象，包含两个子列表。分区函数也以类似的方式与集合一起工作：

科特林

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

输出：

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

解释：

我们来看看Kotlin中partition函数的实现：

科特林

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

如您所见， partition函数只是一种抽象，它使您免于编写长 for 循环，但在内部它以相同的旧方式执行。

示例 2：

分区函数也以类似的方式与数组一起工作。以下是它的不同用法。它们中的每一个都类似地工作，只是产生不同类型的列表：

科特林

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