Scala高阶函数

常见高阶函数

def main(args: Array[String]): Unit = {
    //list集合
      //空值list
  //  val list = Nil
    //因为list是一个抽象类，所以无法创建对象，需要借助伴生类实现
   // val list1=List[Int](1,1,2,3,4,5,6)
  //  println(list.isEmpty)
   // println(list1.isEmpty)
    //首元素
    //val first =list1.head
    //首元素之后的所有数
    //val tail = list1.tail
   // println(first)
   // println(tail)
    //练习：使用递归事项list的求和
    //def recursiveList(list: List[Int]): Int = {
    //    if (list.isEmpty)
    //      0
    //    else
    //    //将第一个元素后面的所有数递归拆除相加
    //      list.head + recursiveList(list.tail)
//
    //  }




 // println(test)
 //  test
 // funcOps2("匿名函数")
   // highLevel()
    //typeUse()
highEasy()

  }
  def test: Unit = {
    def a(name: String): Unit = {
      println("this is my one " + name)
    }

    val b = a _

    def c = a _

    b("变量")
    a("函数")
    c("函数")
    println(b)
    println(c)

  }
  def funcOps2(name:String): Unit ={
    val a = (name:String) =>{
      println("这个函数是"+name)
    }
    a(name)
  }
  //高阶函数
  def highLevel(): Unit ={
    def sayHi(name:String,work:(String) => Unit):Unit={
       work(name)
    }
    //函数一
    sayHi("刘诗诗",(name:String)=>{
      println("say hi to"+name)
    })
    //高阶函数，一二函数为基础
    sayHi("李师师",name => work(name,"打架"))
  }
  //h函数二
  def  work(str: String,a:String):Unit={
  println(str.reverse+"过来"+a)
  }
  //参数类型推断
  def typeUse(): Unit ={
    //定义一个匿名函数
    val money = (x:Double) => 100*x
    //应用
    println(money(10:Double))
    //简化:根据类型推断机制省却类型标注
    println(money(10))
    println("-----------------------------")
    //list集合推断
    val list = Array(1,2,3,4,5)
    //定义list集合的函数
    list.foreach((x:Int)=>println(x+"\t"))
    println("--------------------------")
    //list集合简写:省略类型
    list.foreach((x)=>println(x+"\t"))
    println("-------------------")
    //list一个参数简写
    list.foreach(x => println(x+"\t"))
    println("---------------")
    //通配符简写
    list.foreach(println(_))
    //最简写
    list.foreach(println)
  }
  def highEasy(): Unit ={
    //filter:作用过滤 特点：是一个新集合 判断：ture/false
    val list = List[Int](1,2,3,4,5,6)
    // var newlist = list.filter((num:Int) => num%2==0)
   // list.filter((num)=> num%2 == 0)
   // list.filter(num => num% 2 ==0)
   // list.filter(_ % 2 == 0)
   // println("这是filter"+newlist)


    //map:对元素进行运算 特点：一对一操作的mapping映射
    val newList= list.map((num: Int) => num * 5)
    //简化
    list.map((num) => num*5)
    list.map(num => num*5)
    list.map(_*5)
    println(newList)
    println("---------------------------")
    //flatmap:拆分元素 特点：一对多
    val arr = Array("hello you", "hello me", "hello shit")
    val word = arr.flatMap((arr:String) => arr.split(" "))
    println(word.mkString("[",",","]"))
     println("--------------")
    //reduce聚合操作 累加演示
    var arr1 = 1 to 10
   println( arr1.reduce((a1:Int,a2:Int) =>{
     println("a1: "+a1+" a2: "+a2)
     a1+a2}))
    println("-------------------------")
    //dropWhile :删除满足条件的元素，直达遇到不满足为止
    val list3= Array[Int](1,2,3,4,5,6,7)
    //循环删除其中的偶数
    val newlist=list3.dropWhile((num:Int)=>num != 6)
    newlist.foreach(println)
     println("-----------------------------------")
    //sortWith:排序 返回值：boulean
    val lists = Array(3,-6,2,7,8,0,12)
    lists.sortWith((x:Int,y:Int) => x>y).foreach(println)//降序
    lists.sortWith((x:Int,y:Int) => x< y ).foreach(println)//升序
    println("------------------------")
    //groupBy：分组  返回值是：map类型
    val arrayg = Array("hello you", "hello me", "hello shit")
    val words = arrayg.flatMap((a:String) => a.split(" "))
    println(words.groupBy(b => b).foreach(t => println(t._1+t._2)))
    println("-------------------------")
    words.groupBy(b => b).foreach(t => println(t._1 + t._2.mkString("[",",","]")))
    println("-------------------------")
    words.groupBy(c => c).foreach(t => println(t._1 + t._2.size))
    //partition分区
    val listPainter = Array(3,-6,-9,2,8,4,1,0,8)
    val tuple = listPainter.partition((a: Int) => a < 5)
   // val (left, right) = list.partition((num:Int) => num < 4)
   //println(left.mkString("[", ", ", "]"))
   // println(right.mkString("[", ", ", "]"))
    println(tuple._2.mkString("[", ", ", "]"))
    println(tuple._1.mkString("[", ", ", "]"))
  }

闭包和柯里化

1 闭包：是变量作用域在不同函数中无法调用的问题
2柯里化：是正好他的代码写法，可以解决闭包的问题
3代码的逻辑：是将一个两个参数的函数，转化成两个各有一个参数的函数，第一个函数返回第二个函数，第二个函数返回结果。（类似套娃，不过传递的不是结果而是参数）。