scala-map算子

scala-map算子

算子

算子(计算因子) 就是提前声明好的一个计算逻辑，其实就是集合的一些成员方法

map算子

map

• 方法声明
• 传入一个一元函数（f: A => B）f输入一个类型为 A 的变量，返回类型为 B 的返回值
• map函数将集合的值分别传入一元函数中，将f的返回值收集到一个与原集合类型相同的集合中
• map函数的返回泛型就是一元函数的返回值
• 源码方法

 def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {

 }

• 实例

	//map算子实例
    //需求:将数组内的值都加一后输出
    val arr1 = Array(1, 2, 3, 4)
    //全写
    var arr3=arr1.map(a => {
      a + 1
    })
    //简写
    val arr2 = arr1.map(_ + 1)
    print(arr3.toList)

flatmap

flatMap与map唯一不一样的地方就是传入的函数在处理完后返回值必须是List，其实这也不难理解，既然是flatMap，那除了map以外必然还有flat的操作，所以需要返回值是List才能执行flat这一步

• 方法声明
  final override def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[List[A], B, That]): That = {}

• flatMap的参数为一元函数 f（），函数的输入就是一元函数的输入，就是原集合的泛型，函数的返回值泛型为一元函数的返回值，返回值是原集合相同类型的集合

• flatMap与map的不同之处在于
  1.对于一阶集合flatMap和map返回与主对象相同的类型
  2.对于多阶集合，flatMap能扁平化一层的集合，如可以把双层list压扁为一层，如实例所示

 //flatMap算子实例
      //需求:将集合中字符串处理成为单个字符并输出
      val list1:List[String]=List("abc","def","ghi")
      //使用map处理
      val list2 = list1.map(_.split("").toList)
      println("list2="+list2)
      //使用flatMap处理，输入字符串的数组，输出字符的数组
      val list3 = list1.flatMap(_.split("").toList)
      println("list3="+list3)
      /*
      输出：
      list2=List(List(a, b, c), List(d, e, f), List(g, h, i))
	  list3=List(a, b, c, d, e, f, g, h, i)
      */

foreach

• 方法声明
  final override def foreach[U](f: A => U) {}

• 用来迭代集合等对象,无返回值，即返回值为UNit

• 实例

//foreach算子
    val list4 = List(0, 1, 2, 3)
    //ford迭代迭代
    for (i <- list4) {
      print(i + "\t")
    }
    //foreach迭代
    //全写
    list4.foreach((i: Int) => {
      print(i + "\t")
    })
    //简写
    list4.foreach(print(_))
    //再简写
    list4.foreach(print)

collect算子

• 方法声明
  def collect[B](pf: PartialFunction[A, B]): List[B]{}

• collect与map最大的不同就是接受的参数是偏函数（PartialFunction）

• 集合调用collect时，小括号collect（）换成collect { }

• 大括号里填写各项参数的顺序

参数名	守卫	boolean表达式	boolean表达式为true时执行的操作
case x	if	x%3==0	=> x+1

实例需求 将 余3=0 的元素 +1，余3=1 的元素 *2，余3=2 的元素删除

• map处理

val list1 = (1 to 10).toList
    // 将 余3=0 的元素 +1
    //   余3=1 的元素 *2
    //   余3=2 的元素删除
    //使用map处理
    val res1: List[AnyVal] = list1.map(x => {
      if (x % 3 == 0) x + 1
      else if (x % 3 == 1) x * 2
    })
    println(res1)
    /*
    List(2, (), 4, 8, (), 7, 14, (), 10, 20)
     */

如果使用map，map会为每一个原来的元素都创建一个映射，无法剔除不需要的数据

• 使用filter预过滤
• def filter(p: A => Boolean): List[A]

val list1 = (1 to 10).toList
    val res2 = list1.filter(_ % 3 != 2).map(x => {
      if (x % 3 == 0) x + 1
      else if (x % 3 == 1) x * 2
    })
    println(res2)
    /*
    List(2, 4, 8, 7, 14, 10, 20)
     */

** 将原集合的元素传入p中 返回True的元素保留**

• collect处理=filter+map

	//使用collect和偏函数
    //先过滤，再调用（把不符合偏函数中定义的类型的元素过滤掉）
    val res3=list1.collect {
      case x if x % 3 == 0 => x + 1
      case x if x % 3 == 1 => x * 2
    }
    print(res3)