Scala--第四天

一、迭代器 iterator

　　适合Scala中所有集合的遍历

    var a = List(1, 2, 3, 4)
    var b = a.iterator
    //hasNext:判断迭代器是否由下一个元素   next：获取下一个元素
    while (b.hasNext) {
      println(b.next)
    }
    //结果
    //1
    //2
    //3
    //4

二、函数式编程

　　用处：Scala 针对集合的操作，简化代码

　　1.遍历 froeach

    //完成写法  foreach 中传的是一个函数 ：x代表集合（容器）中的每一个元素
    //注意：foreach没有返回值 ，即为Unit
    a.foreach((x: Int) => {
      println(x)
    })
    //简化写法一：省去参数的类型指定 ，scala做类型推断
    a.foreach(x => println(x))
    //建议写法二：使用下划线 代替 集合中的每个元素
    a.foreach(println(_))

　　2.映射 Map

　　　　格式：原始集合.map(f:(A))  #A：代表集合中的每个元素  

　　　　　　返回值是一个新的集合

    var a = List(1, 2, 3, 4)
    //每个集合中的元素+1 得到新的集合
    var b = a.map(x => x + 1)
    println(b)
    var c = a.map(_ + 1)
    println(c)
    //List(2, 3, 4, 5)
    //List(2, 3, 4, 5)

　　3.映射扁平化（降维处理） flatmap

　　　　格式：原始集合.flatMap(f:(A))

　　　　返回值：一个新的集合

    var a = List("cmx01 cmx02", "cmx03 cmx04")
    //正常的思路与写法
    var b = a.map(_.split(" ")).flatten
    //    println(b)
    //List(cmx01, cmx02, cmx03, cmx04)
    //flatMap 简化
    var c = a.flatMap(x => {
      x.split(" ")
    })
    println(c)
    //List(cmx01, cmx02, cmx03, cmx04)
    var d = a.flatMap(_.split(" "))
    println(d)
    //List(cmx01, cmx02, cmx03, cmx04)

　　4.过滤 filter 按照一定的规则，对集合中的元素进行过滤

　　　　格式：原始集合.filter(p:(A))=>Boolean

　　　　返回值：一个新集合

    var a = List(1, 2, 3, 4, 5, 6, 7)
    //过滤偶数
    var b = a.filter(x => {
      x % 2 == 0
    })
    println(b)
    //过滤奇数，并使用简便的写法
    var c = a.filter(_ % 2 == 1)
    println(c)
    //List(2, 4, 6)
    //List(1, 3, 5, 7)

　　5.是否存在 exists

    var a = List(1, 2, 3, 4, 5, 6, 7)
    println(a.exists(_==3))
    //true

　　6.排序sorted sortBy sortWith

    var a = List(9, 6, 4, 3, 5, 2, 1)
    //默认排序 升序
    var b = a.sorted
    println(b)
    //List(1, 2, 3, 4, 5, 6, 9)

    //根据指定元素进行排序
    var c = List("cmx 1", "zzz 2", "uuu 3")
    var d = c.sortBy(_.split(" ")(0))
    println(d)
    //List(cmx 1, uuu 3, zzz 2)

    //自定义排序sortWith
    //降序排列 大于号 降序  小于号 升序
    var e = a.sortWith(_ > _)
    println(e)
    //List(9, 6, 5, 4, 3, 2, 1)

    //注意简写的 _  不能出现再 if 判断里
    var f = a.sortWith((x, y) => {
      if (x < y) true else false
    })
    println(f)
    //List(1, 2, 3, 4, 5, 6, 9)

　　关于 _ 的小结

　　1.下划线 不能出现在 if 判断中

　　2.当函数的参数，只在函数体中出现一次，并且函数体没有嵌套调用

　　7.分组 groupby

    var a = List(("cmx", 1), ("cmx01", 1), ("xxx", 0))
    //需求 分组统计 0，1 的个数
    var b = a.groupBy(_._2)
    println(b)
    //打印的结果为一个Map
    //Map(1 -> List((cmx,1), (cmx01,1)), 0 -> List((xxx,0)))
    for (i <- b) println(i)
    //循环打印的结果却是元组
    //(1,List((cmx,1), (cmx01,1)))
    //(0,List((xxx,0)))

    var c = b.map(x => x._1 -> x._2.length)
    println(c)
    //Map(1 -> 2, 0 -> 1)
    c.foreach(println(_))
    //(1,2)
    //(0,1)

 　　8.聚合 reduce，reduceLeft，reduceRight

　　　　格式：集合.reduce（op:(A1,A2)=>A1）

　　　　　　A1:截止当前位置的聚合结果

　　　　　　A2:当前需要聚合的元素

    var a = List(1, 2, 3)
    var b = a.reduce((x, y) => x + y)
    println(b)
    //6
    var c = a.reduce(_ + _)
    println(c)
    //6

    var d = a.reduceLeft(_ - _)
    var e = a.reduceRight(_ - _)
    println(d)
    println(e)
    //-4
    //2

　　注意：reduceLeft reduceRight 的区别

9.折叠 fold（相较于聚合，多了一个初始值）

　　　　格式：集合.fold(初始值)(op:(A1,A2)=>A1)  #A1,A2 与聚合含义相同

    var a = List(1, 2, 3)
    var b = a.fold(10)(_ - _)
    var c = a.foldRight(10)(_ - _)
    println(b)
    println(c)
    //4
    //-8