操作列表

压缩和展平是两种常见的操作，用于操作 List。

展平

flatten() 接受一个包含元素本身是 List 的元素的 List（即 List 的 List），并将其展平为包含单个元素的 List：

// ManipulatingLists/Flatten.kt
import atomictest.eq

fun main() {
  val list = listOf(
    listOf(1, 2),
    listOf(4, 5),
    listOf(7, 8),
  )
  list.flatten() eq "[1, 2, 4, 5, 7, 8]"
}

flatten() 帮助我们理解另一个在集合上执行的重要操作：flatMap()。让我们产生一个范围的所有可能的 Pair：

// ManipulatingLists/FlattenAndFlatMap.kt
import atomictest.eq

fun main() {
  val intRange = 1..3

  intRange.map { a ->          // [1]
    intRange.map { b -> a to b }
  } eq "[" +
    "[(1, 1), (1, 2), (1, 3)], " +
    "[(2,

 1), (2, 2), (2, 3)], " +
    "[(3, 1), (3, 2), (3, 3)]" +
    "]"

  intRange.map { a ->          // [2]
    intRange.map { b -> a to b }
  }.flatten() eq "[" +
    "(1, 1), (1, 2), (1, 3), " +
    "(2, 1), (2, 2), (2, 3), " +
    "(3, 1), (3, 2), (3, 3)" +
    "]"

  intRange.flatMap { a ->      // [3]
    intRange.map { b -> a to b }
  } eq "[" +
    "(1, 1), (1, 2), (1, 3), " +
    "(2, 1), (2, 2), (2, 3), " +
    "(3, 1), (3, 2), (3, 3)" +
    "]"
}

每种情况下的 lambda 都是相同的：将每个 intRange 元素与每个 intRange 元素结合，以生成所有可能的 a to b Pair。但是在 [1] 中，map() 有助于保留额外的信息，这里我们已经生成了三个 List，每个都对应于 intRange 中的一个元素。在某些情况下，这些额外的信息是必不可少的，但在这里我们不需要它 - 我们只需要一个单一的扁平 List，其中包含所有组合，没有额外的结构。

有两个选择。[2] 展示了将 flatten() 函数应用于移除这个额外结构并将结果展平为单个 List，这是可接受的方法。但是，这是一个非常常见的任务，Kotlin 提供了一个称为 flatMap() 的组合操作，它通过单个调用执行 map() 和 flatten()。[3] 展示了 flatMap() 的使用。在大多数支持函数式编程的语言中，您会发现 flatMap()。

下面是 flatMap() 的另一个示例：

// ManipulatingLists/WhyFlatMap.kt
package manipulatinglists
import atomictest.eq

class Book(
  val title: String,
  val authors: List<String>
)

fun main() {
  val books = listOf(
    Book("1984", listOf("George Orwell")),
    Book("Ulysses", listOf("James Joyce"))
  )
  books.map { it.authors }.flatten() eq
    listOf("George Orwell", "James Joyce")
  books.flatMap { it.authors } eq
    listOf("George Orwell", "James Joyce")
}

我们希望得到一个作者的 List。map() 生成了一个作者的 List 的 List，这并不是很方便。flatten() 将其接受并生成一个简单的 List。flatMap() 在单个步骤中生成相同的结果。

在此示例中，我们使用 map() 和 flatMap() 将 enum Suit 和 Rank 结合在一起，生成一副 Card：

// ManipulatingLists/PlayingCards.kt
package manipulatinglists
import kotlin.random.Random
import atomictest.*

enum class Suit {
  Spade, Club, Heart, Diamond
}

enum class Rank(val faceValue: Int) {
  Ace(1), Two(2), Three(3), Four(4), Five(5),
  Six(6), Seven(7), Eight(8), Nine(9),
  Ten(10), Jack(10), Queen(10), King(10)
}

class Card(val rank: Rank, val suit: Suit) {
  override fun toString() =
    "$rank of ${suit}s"
}

val deck: List<Card> =
  Suit.values().flatMap { suit ->
    Rank.values().map { rank ->
      Card(rank, suit)
    }
  }

fun main() {
  val rand = Random(26)
  repeat(7) {
    trace("'${deck.random(rand)}'")
  }
  trace eq """
    'Jack of Hearts' 'Four of Hearts'
    'Five of Clubs' 'Seven of Clubs'
    'Jack of Diamonds' 'Ten of Spades'
    'Seven of Spades'
  """
}

在初始化 deck 中，内部的 Rank.values().map 生成了四个 List，一个对应于每个 Suit，因此我们在外部循环上使用了 flatMap()，以生成一个

Card 的 List，用于 deck。

练习和解答可以在 www.AtomicKotlin.com 找到。

Atomic-Kotlin-中文版

操作列表

压缩

展平