11.1 集合元素的映射-map映射操作 

　　11.1.1 看一个实际需求

　　　　　　要求：请将List(3,5,8)中所有的元素都*2，将其结果放到一个新的集合中返回，即返回一个新的List(6,10,16)，请编写程序实现

　　11.1.2 map映射操作 

　　　　   

　　11.1.3 使用传统方法

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    /*
    请将List(3,5,8) 中的所有元素都 * 2 ，
    将其结果放到一个新的集合中返回，即返回一个新的List(6,10,16), 请编写程序实现.

     */

    val list1 = List(3, 5, 8) //集合
    var list2 = List[Int]() //新的集合，准备放入新的内容
    for (item <- list1) { //遍历
      list2 = list2 :+ item * 2 // 对元素*2 ，然后加入list2集合
    }
    println("list2=" + list2) //List(6,10,16)

  }
}

　　　　　　－上述案例演示的分析和小结

　　　　　　　　1) 优点

　　　　　　　　　　处理方法比较直接，好理解

　　　　　　　　2) 缺点

　　　　　　　　　　不够简洁高效

　　　　　　　　　　没有体现函数式编程特点 集合 => 函数 => 新的集合 => 函数 ...

　　　　　　　　　　不利于处理复杂的数据处理业务

　　11.1.4 高阶函数基本使用案例1 

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    //使用高阶函数
    val res = test(sum2 _, 3.5)
    println("res=" + res)

    //在scala中，可以把一个函数直接赋给一个变量,但是不执行函数
    val f1 = myPrint _
    f1() //执行


  }

  def myPrint(): Unit = {
    println("hello,world!")
  }

  //说明
  //1. test就是一个高阶函数
  //2. f: Double => Double 表示一个函数， 该函数可以接受一个Double,返回Double
  //3. n1: Double 普通参数
  //4. f(n1) 在test函数中，执行 你传入的函数
  def test(f: Double => Double, n1: Double) = {
    f(n1)
  }

  //普通的函数, 可以接受一个Double,返回Double
  def sum2(d: Double): Double = {
    println("sum2被调用")
    d + d
  }

}

　　11.1.5 高阶函数应用案例2 

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    test2(sayOK)

  }

  //说明test2是一个高阶函数，可以接受一个 没有输入，返回为Unit的函数
  def test2(f: () => Unit) = {
    f()
  }

  def sayOK() = {
    println("sayOKKK...")
  }

  def sub(n1: Int): Unit = {

  }

}

　　11.1.6 使用map映射函数来解决  

//请将 List(3,5,8) 中的所有元素都 * 2 , 将其结果放到一个新的集合中返回,即返回一个新的 List(6,10,16), 请编写程序实现.

  val list = List(3, 5, 8)
  //说明 list.map(multiple) 做了什么
  //1. 将 list 这个集合的元素 依次遍历
  //2. 将各个元素传递给 multiple 函数 => 新 Int
  //3. 将得到新 Int ,放入到一个新的集合并返回
  //4. 因此 multiple 函数调用 3

  val list2 = list.map(multiple)
  println("list2=" + list2) //List(6,10,16)

  def multiple(n: Int): Int = {
    println("multiple 被调用~~")
    2 * n
  }

　　11.1.7 深刻理解map映射函数的机制-模拟实现 

//深刻理解 map 映射函数的机制-模拟实现
  class MyList {
    val list1 = List(3, 5, 8, 9) //新的集合
    var list2 = List[Int]()

    //写 map
    def map(f: Int => Int): List[Int] = {
      //遍历集合
      for (item <- this.list1) {
        //过滤,扁平化。。。
        list2 = list2 :+ f(item)
      }
      list2
    }
  }

  object MyList {
    def apply(): MyList = new MyList()
  }

　　11.1.9 flatmap映射: flat即压扁，压平，扁平化映射 

　　　　　　－扁平化说明

　　　　　　　　flatmap：flat即压扁，压平，扁平化，效果就是将集合中的每个元素的子元素映射到某个函数并返回新的集合

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    val names = List("Alice", "Tom", "Nick")

    //需求是将List集合中的所有元素，进行扁平化操作，即把所有元素打散
    val names2 = names.flatMap(upper)
    println("names2=" + names2)

  }

  def upper(s: String): String = {
    s.toUpperCase
  }
}

11.2 集合元素的过滤-filter 

　　　　　　－基本说明 

　　　　　　　　filter：将符合要求的数据(筛选)放置到新的集合中

　　　　　　－案例演示

　　　　　　　　应用案例：将 val names = List("Alice","Tom","Nick") 集合中首字母为'A'的筛选到新的集合

　　　　　　　　思考：如果这个使用传统的方法，如何完成？

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    /*
    选出首字母为A的元素
     */
    val names = List("Alice", "Tom", "Nick")
    val names2 = names.filter(startA)
    println("names=" + names)
    println("names2=" + names2)
  }

  def