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) //柯里化（只是一个变形）将两个参数的函数变成一个参数的函数的形态 } }