Scala学习笔记3——函数式编程

Scala学习笔记3——函数式编程

• 值函数：val valFunName = funName _

  def add(x : Int, y : Int) = x + y
  val ohmygod = add _
  ohmygod(1,2)
  

• 嵌套函数：def套def

  def add3(x : Int,y : Int,z : Int) : Int = {
      def add2(x : Int, y : Int) : Int = {
          x + y
      }
      add2(add2(x,y),z)
  }
  

• 匿名函数

  • (参数名：参数类型) => 表达式
  • 可以将匿名函数赋给val或者var

  val fun = (x : Int) => x + 2
  fun(10) //res:12
  
  val l = List(1,2,3,4)
  l.map((x : Int) => 2 * x)
  //当然可以用placeholder l.map(2 * _) 表示对每一个元素操作
  

• 函数作为参数

  //case1
  def fun(f : (Int,Int) => Int) : Int = f(1,2)
  fun((x : Int, y : Int) => x + y) //res = 3
  //case2
  def mulBy(factor : Double) = (x : Double) => factor * x
  mulBy(2)//:代表2*x这个函数
  

• 闭包

  闭包 = 代码 + 用到的非局部变量（如上mulBy）

• 参数简化与类型推导

  • list.map((x : Int) => x + 1)
  • list.map(_ + 1)

• 偏函数

  def add(x : Int, y : Int, z : Int) = x + y + z
  //case1
  val a = add(2,3,_ : Int)
  //case2
  def _add = add(_ : Int, _ : Int,0)
  

• 颗粒化

  def add(x : Int)(y : Int) = x + y
  add(1)_//x确定了，y没有确定
  

• 重要高阶函数

  val a = Array(1,2,3,4,5,6,7,8)
  a.map(2 * _)
  a.filter(_ > 4)
  a.reduce((x : Int, y : Int) => x + y)//res = 36,(((1+2)+3)+...)
  a.reduce(_ + _)
  a.fold(100)(_ + _)//136 = 100 + 36
  

  

• By_Name Parameters 延迟计算

  //by_value
  def test(flag : Boolean){
      println(flag)
  } 
  //by_name
  def test(flag: => Boolean){
      println(flag)
  }
  test(3 > 1)
  

• 集合

  • spark操作的对象是rdd（分布式可弹性切割的集合）,scala的集合操作与spark的操作是平行的。

  • Seq

  • Set

  • Map

• 可变与不可变集合

  • scala.collection.mutable.Map
  • scala.collection.immutable.Map(不可变的，默认)

  import scala.collection.mutable
  Map(1->2, 3->4)    //不可变
  mutable.Map(1 -> 2)//可变
  

• Range(start : Int, end : Int, step : Int),定义了apply方法

• List

  • List由Nil(空的list)或head + tail构成，其中tail又是一个List

    val l = List(1,2,3,4,5)
    l.head //返回Int类型的1
    l.tail //返回List(2,3,4,5)
    

  • new-value :: list

    val l2 = 1 :: Nil //l2 = List(1)
    2 :: l2 //res = List(2,1)
    

  • 构建：List(1,2,3) 或 1::2::3::Nil

  • 基于List的模式匹配

  • 利用迭代或者递归来处理list

• ListBuffer

  val lb = mutable.ListBuffer()
  lb += 2 //res = ListBuffer(1,2)
  lb += (3,4,5)//加元组
  lb ++= List(6,7) //加整个list
  //用.toList或.toArray转换成list或者array
  

• Immutable Set

  val s = Set(1,2,3,4)
  s + 5 //返回一个新的set = Set(5,1,2,3,4) 
  s + (11,22,33)
  s ++ List(111,222,333)
  
  scala.collection.immutable.SortedSet(2,1,3,4)// res = TreeSet(1,2,3,4)
  

• mutable Set

  • ++/+/-/–都会产生一个新的set
  • +=/++=则不会产生新的set
  • scala.collection.mutable.SortedSet
  • TreeSet & BitSet

• 重要方法

  • map
  • foreach/take
  • filter
  • flatten/flatMap
  • reduce/reduceLeft/fold
  • sum/max/count
  • zip

  val l = List(1,2,3,4,5,6,7,8)
  l.map(_ * 2).filter(_ > 8)//res : List(10,12,14,16)
  l.map(_ * 2).filter(_ > 8).foreach(println(_))//其中(_)可省略
  l.take(4) //选出前四个的list:List(1,2,3,4)
  l.map(_ * 2).filter(_ > 8).reduce(_ + _)//res = 52
  l.max
  l.count(_ > 3)
  
  val l1 = List(1,2,3,4)
  val l2 = List("A","B","C","D")
  l1 zip l2//res = List((1,A),(2,B),(3,C),(4,D))
  
  val list = List(List(1,2),List(3,4),List(5,6))
  list.flatten //res = List(1,2,3,4,5,6),类似踩平
  list.flatMap(_.map(2 * _))//res = List(2,4,6,8,10,12)