> For the complete documentation index, see [llms.txt](https://www.selinux.tech/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.selinux.tech/scala/function-operation/map.md).

# map

* [集合的Map操作](https://www.selinux.tech/scala/function-operation/pages/-LripEltSpwwIBvo7iM_#集合的map操作)
  * [Demo1 过程式实现](https://www.selinux.tech/scala/function-operation/pages/-LripEltSpwwIBvo7iM_#demo1-过程式实现)
  * [集合元素map映射操作](https://www.selinux.tech/scala/function-operation/pages/-LripEltSpwwIBvo7iM_#集合元素map映射操作)
  * [Demo2 函数式实现](https://www.selinux.tech/scala/function-operation/pages/-LripEltSpwwIBvo7iM_#demo2-函数式实现)
  * [Demo3 编程实现map操作](https://www.selinux.tech/scala/function-operation/pages/-LripEltSpwwIBvo7iM_#demo3-编程实现map操作)

## Demo1 过程式实现

给定一个 `List(1, 2, 3)` 将其中的每个元素都 乘以 2 ，并返回一个新的集合。

```scala
object MapOperateDemo1 {

  def main(args: Array[String]): Unit = {
    val list1 = List(1, 2, 3)
    var list2 = List[Int]()
    for (item <- list1) {
      list2 = list2 :+ item * 2
    }
    println("list2:" + list2)
  }

}
```

上面的Demo有几个问题:

1. 不够简洁、高效
2. 没有函数式编程
3. 不利于处理复杂的数据处理业务

由此我们引出下面的map映射操作。

## 集合元素map映射操作

将集合中的每一个元素通过指定功能(**函数**) 映射（**转换**）成新的结果集。

以 `Seq` 为例，可以看到它的map方法定义。

```scala
def map[B](f: (A) ⇒ B): Seq[B]
    [use case]
    Builds a new collection by applying a function to all elements of this sequence.

    B           the element type of the returned collection.

    f           the function to apply to each element.

    returns     a new sequence resulting from applying the given function f to each element of this sequence and collecting the results.
```

## Demo2 函数式实现

```scala
object MapOperateDemo2 {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3)

    val list2 = list.map(multiple)

    println(list2)

    // 简化写法
    val list3 = list.map(_ * 2)

    println(list3)

    val list4 = list.map(n => n * 2)

    println(list4)

  }

  def multiple(n: Int): Int = {
    println("被调用") //调用三次
    n * 2
  }
}
```

1. 将list中的元素全部遍历出来
2. 将遍历出来的元素传递给multiple
3. 将得到的值,放入到一个新的集合并返回

## Demo3 编程实现map操作

```scala
object MapOperateDemo2 {
  def main(args: Array[String]): Unit = {

    // 模拟 map 的实现机制
    val myList1 = DemoList()
    val myList2 = myList1.map(_ * 2)

    println(myList2)
  }
}

class DemoList {
  val list1 = List(1, 4, 5, 6)

  var list2 = List[Int]()

  def map(f: Int => Int): List[Int] = {
    // 遍历这个集合
    for (elem <- list1) {
      list2 = list2 :+ f(elem)
    }

    list2
  }

}

object DemoList {
  def apply(): DemoList = new DemoList()
}
```