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