scala高阶函数练习(非常重要)

1、定义一个高阶函数，按照指定的规则对集合里面的每个元素进行操作
比如: val arr = ArrayString
对集合中每个元素进行操作，得到集合每个元素的长度
val result = ArrayInt

object $08_Map {

 def main(args: Array[String]): Unit = {

    val arr = Array[String]("spark","hello","java","python")

    val func = (x:String)=>{
      x.length
    }

    val result = map(arr,func)
    println(result.toBuffer)
  }

  def map(arr:Array[String],func:String=>Int)={
    for (element<- arr) yield {
      func(element)
    }
  }
｝

2、定义一个高阶函数，按照指定的规则对集合中的所有元素进行聚合
val arr =ArrayInt
求得集合中的所有元素的和
val result = xx

object $09_Reduce {

  def main(args: Array[String]): Unit = {

    val arr =Array[Int](10,2,4,6,1,8,10)

    var func = (agg:Int,curr:Int)=> agg+curr

    println(reduce(arr,func))
  }

  def reduce(arr:Array[Int],func:(Int,Int)=>Int): Int ={

    var tmp:Int = arr(0)

    for(i<- 1 until arr.length){
      tmp = func(tmp,arr(i))
    }

    tmp
  }
}

3、定义一个高阶函数，按照指定的规则获取指定元素
val arr = Array[String](“zhangsan 20 3000”,“lisi 30 4000”,“wangwu 15 3500”)
获取年龄最大的人的数据
val result = “lisi 30 4000”

object $10_MaxBy {

  /**
    * 3、定义一个高阶函数，按照指定的规则获取指定最大元素
    * val arr = Array[String]("zhangsan 20 3000","lisi 30 4000","wangwu 15 3500")
    * 获取年龄最大的人的数据
    * val result = "lisi 30 4000"
    *
    */
  def main(args: Array[String]): Unit = {
    val arr = Array[String]("zhangsan 20 3000","lisi 30 4000","wangwu 15 3500")

    val func = (x:String,y:String) => {
      val first = x.split(" ")(2).toInt
      val last = y.split(" ")(2).toInt
      if(first>last) {
        x
      }else{
        y
      }
    }
    println(maxBy1(arr, func))

    println(maxBy2(arr, (x: String) => x.split(" ")(2).toInt))
  }

  def maxBy1( arr:Array[String], func: (String,String)=> String)={

    var tmp = arr(0)

    for(i<- 1 until arr.length){
      tmp = func(tmp,arr(i))
    }

    tmp
  }

  def maxBy2( arr:Array[String],func: String=>Int) = {

    var tmp = func(arr(0))
    var result = arr(0)

    for(element<- arr){
      if(tmp<func(element)){
        tmp = func(element)
        result = element
      }
    }

    result
  }

}

4、定义一个高阶函数，按照指定的规则对数据进行分组
val arr = Array[String](“zhangsan 男 深圳”,“lisi 女 深圳”,“王五 男 北京”)
根据性别进行分组
val result = Map[String,List[String]](
“男”-> List(“zhangsan 男 深圳”,“王五 男 北京”),
“女” -> List(“lisi 女 深圳”)
)

import java.util

object $11_GroupBy {

  /**
    * 4、定义一个高阶函数，按照指定的规则对数据进行分组
    * val arr = Array[String]("zhangsan 男 深圳","lisi 女 深圳","王五 男 北京")
    * 根据性别进行分组
    * val result = Map[String,List[String]](
    * "男"-> List("zhangsan 男 深圳","王五 男 北京"),
    * "女" -> List("lisi 女 深圳")
    * )
    *
    */
  def main(args: Array[String]): Unit = {
    val arr = Array[String]("zhangsan 男 深圳","lisi 女 深圳","王五 男 北京")

    val func = (x:String) => x.split(" ")(1)
    println(groupBy(arr, func))
    println(groupBy(arr,(x:String) => x.split(" ")(1)))
    println(groupBy(arr,(x) => x.split(" ")(1)))
    println(groupBy(arr,x => x.split(" ")(1)))
    println(groupBy(arr,_.split(" ")(1)))
  }

  def groupBy( arr:Array[String],func: String=>String )={

    //1、创建一个分组的存储容器
    val result = new util.HashMap[String,util.List[String]]()
    //2、遍历集合所有元素
    for(element<- arr){
      //得到分组的key
      val key = func(element)
      //3、判断分组的key是否在容器中存在，如果不存在，则直接添加到容器中
      if(!result.containsKey(key)){
        val list = new util.ArrayList[String]()
        list.add(element)
        result.put(key,list)
      }else{
      //4、如果存在，此时应该取出key对应的List，将元素添加到List
       val list = result.get(key)
        list.add(element)
      }
    }
    //5、返回结果
    result
  }
}

5、定义一个高阶函数，按照指定的规则对数据进行过滤，保留符合要求的数据
val arr =ArrayInt
只保留偶数数据
val result = ArrayInt

object $12_Filter {

  /**
    * 5、定义一个高阶函数，按照指定的规则对数据进行过滤，保留符合要求的数据
    * val arr =Array[Int](10,2,4,6,1,8)
    * 只保留偶数数据
    * val result = Array[Int](10,2,4,6,8)
    */
  def main(args: Array[String]): Unit = {
    val arr =Array[Int](10,2,4,6,1,8)
    println(filter(arr, x => x % 2 == 0).toBuffer)
  }

  def filter( arr: Array[Int], func: Int => Boolean )={

    for(element<- arr if( func(element) )) yield {
       element
    }
  }
}