Scala函数式编程

package com.yz6
import scala.collection.mutable.ArrayBuffer
object test {
  def main(args: Array[String]): Unit = {

    function1("小白")
    aa("比亚迪")


    val  arr=ArrayBuffer(4,6,1,-4,100,66,3)//伴生对象
    //匿名函数【只要灵魂的函数】作为参数传递
    // val result=arr.sortWith((x,y)=>x>y)//精简版
    val result=arr.sortWith(_>_)//函数签名也去掉，只剩函数体（灵魂中的灵魂） //超简版  看不出来是函数
    println(result)


    //调用高阶函数
    h1("肯德基",(name:String)=>println("你好"+name))

    val mm=h2("绿巨人")
    //mm最终被传递了一个灵魂，就是h2的返回值【匿名函数】
    //可以形成 def mm(x:String)=println("绿巨人"+"------------"+x)
    mm("钢铁侠")
    //结果     绿巨人------钢铁侠


    val myArray=ArrayBuffer(1,4,6,7,2)
    //map方法---映射方法---参数是一个匿名函数
    var r1=myArray.map((x:Int)=>x*100+10)//简化
    var r2=myArray.map((x)=>x*100+10)
    var r3=myArray.map(x=>x*100+10)
    var r4=myArray.map(_*100+10)

    //解析
    //y=x+1   y的值随着x的变化而变化

    //表达性--简洁     阅读性--差

    println(r1)
    println(r2)
    println(r3)
    println(r4)


  }

  //定义一个函数  躯壳+灵魂
  def function0(name:String): Unit = println("你好"+name)
    //将一个函数作为值传递给另一个函数[在被传递函数后写  空格_}
    //   函数签名       函数体
    //(name:String)=>println("你好"+name)

  def function1=function0 _
    //形成了如下的函数(相当于把一个函数灵魂(函数签名和函数体)给了另一个函数   名字只是躯壳)
    //def function1(name:String)=println("你好"+name)


  //匿名函数
  val aa = (x:String) => println(x+"他来了")
  //如果一个变量/不变量被赋予了一个灵魂(函数签名+函数体)，那么调用的时候应该把该变量/不变量当做函数一样调用



  //定义高阶函数case1   将函数作为参数
  def  h1(name:String,fun:(String)=>Unit): Unit ={
    fun(name)
  }
  //定义高阶函数case2          将函数作为返回值
  def h2(name:String)=(x:String)=>println(name+"------------"+x)

}

 

package com.yz7

import org.junit.Test

class test {
  @Test
  def test1(): Unit ={
    //快速生产0.1 0.2 0.3...
    //(1 to 9).map((x:Int)=>0.1*x).foreach(println(_))

    //字符串乘数字
    //(1 to 9).map("*"*_).foreach(println(_))
    //还原
    (1 to 9).map((x:Int)=>"*"*x).foreach(println(_))

    //取出1到9的偶数
    //(1 to 9).filter(_%2==0).foreach(println(_))//极简版【阅读性差--不方便和源码匹配】
    (1 to 9).filter((x:Int)=>x%2==0).foreach(println(_))//标准版【阅读性强-可以和源码匹配】


    //var i=(1 to 9).reduce(_+_)
    var i=(1 to 9).reduce((x:Int,y:Int)=>x+y)
    println(i)

    var i1=(1 to 9).reduceLeft((x:Int,y:Int)=>x+y)//方法体和左边类型一致
    println(i1)

    var i2=(1 to 9).reduceRight((x:Int,y:Int)=>x+y)//方法体和右边类型一致
    println(i2)


    // going left to right:
    //   *           {{{
    //   *             op( op( ... op(x_1, x_2) ..., x_{n-1}), x_n)
    //   *           }}}
    var i3=(1 to 5).reduceLeft((x:Int,y:Int)=>x-y)
    println(i3)//-13
    //1-2=-1 -1-3=-4 -4-4=-8 -8-5=-13

    var i4=(1 to 5).reduceRight((x:Int,y:Int)=>x-y)
    println(i4)//3
    //4-5=-1 3-(-1)=4 2-4=-2 1-(-2)=3




  }


  @Test
  def test2(): Unit ={
    var i3=(1 to 5).reduceLeft((x:Int,y:Int)=>x-y)
    println(i3)//-13


   val arr=Array(1,3.3,4,5,0.5)
    val d=arr.reduceLeft((x:Double,y:Double)=>x-y)
    println(d)
    //val d=arr.reduceLeft((x:Any,y:Any)=>x-y)   定义为Any不能识别减号

    //纠结类型(定义变量=类型推导【js叫弱类型】)   不写类型--自动推导
    val d2=arr.reduceLeft((x,y)=>x-y)
    println(d2)

  }


  @Test
  def test3(): Unit ={
    //从大到小
   // (1 to 9).sortWith(_>_).foreach(println(_))
    (1 to 9).sortWith((x,y)=>x>y).foreach(println(_))

  }


  @Test
  def test4(): Unit ={
    //每一个函数被称为闭包（closure）。

    def mulBy(factor:Double) = (x:Double) => factor * x
    //factor在mulBy中定义，在匿名函数中被引用

    val triple = mulBy(3)//运行完factor被弹出栈--出栈(内存)
    //想象：def triple(x:Double)=3*x

    val half = mulBy(0.5)
    //想象：def triple(x:Double)=0.5*x

    println(triple(14) +" " + half(14)) //42, 7



    //上边的高阶函数  mulBy   没发生闭包
    def mulBy2(factor:Double,x: Double) ={
      factor*x
    }

    //--和最初一样  （这是把大括号加上，这样看着更方便）
    def mulBy3(factor:Double)={
          println(factor)//直接在mulBy3函数内使用，这种是在其作用域内
      (x:Double)=>{
        //内层函数(匿名函数)引用了外层函数的变量，这种情况会出现闭包
        factor*x//factor在内层函数里使用，就发生了其"作用域外"被调用
      }
    }


    val doubleToDouble = mulBy3(4)
    val d=doubleToDouble(6)
    println(d)


  }


  @Test
  def test5(): Unit ={
    //柯里化

    def fun1(x:Int,y:Int):Unit={
      println(x+y)
    }

    //调用
    fun1(3,5)


    //变形
    def fun2(x:Int)=(y:Int)=>println(x+y)

    //调用
   // val in=fun2(6)
    //in(7)

    fun2(6)(7)
    //柯里化（只是一个变形）将两个参数的函数变成一个参数的函数的形态
  }



}