Scala 中的foreach和map方法比较

转自：https://www.cnblogs.com/1zhk/p/4710580.html      https://blog.csdn.net/u010454030/article/details/53899587

Scala中的集合对象都有foreach和map两个方法。两个方法的共同点在于：都是用于遍历集合对象，并对每一项执行指定的方法。而两者的差异在于：foreach无返回值（准确说返回void）,map返回集合对象。见如下代码及运行结果：b.getClass 得到的是void, 而c.getClass得到的是colletion 。再看代码的第9-11行，foreach和map的运行结果一致。结论就是：foreach 无法代替map. 而map方法却可以代替foreach。

问题：为什么scala提供foreach和map两个方法呢？本人看法是scala做为一种支持函数式编程范式的语言，必然要引入一种机制以支持数学中函数概念，而在数学中函数就是映射，所以scala中有map方法一点都不奇怪。而foreach只是用在不需要对集合执行映射操作，但需要遍历集合时才用到。总而言之，foreach用于遍历集合，而map用于映射（转换）集合到另一个集合。

 

 1 object arrayTest extends App{
 2   var increase=(x:Int)=>x+1
 3   val someNumbers = List ( -11, -10, - 5, 0, 5, 10)
 4   var b = someNumbers.foreach(increase)
 5   println(b.getClass)
 6   var c = someNumbers.map(increase)
 7   println(c.getClass)
 8 
 9   c.foreach((x:Int)=>print(x+" "))
10   println()
11   c.map((x:Int)=>print(x+" "))
12 
13 }

运行结果：

（1）不可变Map

特点：

api不太丰富

如果是var修饰，引用可变，支持读写

如果是val修饰，引用不可变，只能写入一次值，其后只读

var a:Map[String,Int]=Map("k1"->1,"k2"->2)//初始化构造函数
    a += ("k3"->3)//添加元素
    a += ("k4"->4)//添加元素
    a += ("k1"->100)//已经存在添加元素会覆盖
    a -= ("k2","k1")//删除元素
//    a("k1") = "foo"//不支持
    println(a.contains("k6"))//是否包含某元素
    println(a.size)//打印大小
    println(a.get("k1").getOrElse("default")) //根据key读取元素，不存在就替换成默认值
    a.foreach{case (e,i) => println(e,i)} //遍历打印1
    for( (k,v)<-a ) println(k,v) //遍历打印2
    println(a.isEmpty)//判断是否为空
    a.keys.foreach(println)//只打印key
    a.values.foreach(println)//只打印value
    a=Map()//数据清空使用再次new
    println(a.size)
    a.toSeq.sortBy(_._1)//升序排序 key
    a.toSeq.sortBy(_._2)//升序排序 value
    a.toSeq.sortWith(_._1>_._1) //降序排序 key
    a.toSeq.sortWith(_._2>_._2) //降序排序 value
    
    //下面自定义按英文字母或数字排序
    implicit  val KeyOrdering=new Ordering[String] {
      override def compare(x: String, y: String): Int = {
        x.compareTo(y)
      }
    }
    println(a.toSeq.sorted)

（2）可变Map例子

特点：

api丰富与Java中Map基本类似

如果是var修饰，引用可变，支持读写

如果是val修饰，引用不可变，支持读写

def map3(): Unit ={
  //不可变Map+var关键词修饰例子
  var a:scala.collection.mutable.Map[String,Int]=scala.collection.mutable.Map("k1"->1,"k2"->2)//初始化构造函数
  a += ("k3"->3)//添加元素
  a += ("k4"->4)//添加元素
  a += ("k1"->100)//已经存在添加元素会覆盖
  a += ("k1"->100,"k9"->9)//添加多个元素
  a -= ("k2","k1")//删除元素
  a ++= List("CA" -> 23, "CO" -> 25)//追加集合
  a --= List("AL", "AZ")//删除集合

  a.retain((k,v)=> k=="k1")//只保留等于k1元素，其他的删除
  a.put("put1",200)//put
  a.remove("k2")//remove
  a.clear()//清空
  a("k3")=100//支持

  println(a.contains("k6"))//是否包含某元素
  println(a.size)//打印大小
  println(a.get("k1").getOrElse("default")) //根据key读取元素，不存在就替换成默认值
  a.foreach{case (e,i) => println(e,i)} //遍历打印1
  for( (k,v)<-a ) println(k,v) //遍历打印2
  println(a.isEmpty)//判断是否为空
  a.keys.foreach(println)//只打印key
  a.values.foreach(println)//只打印value
  a=scala.collection.mutable.Map()//引用能变
  println(a.size)
  a.toSeq.sortBy(_._1)//排序 key
  a.toSeq.sortBy(_._2)//排序 value
  a.toSeq.sortWith(_._1>_._1) //降序排序 key
  a.toSeq.sortWith(_._2>_._2) //降序排序 value
  
      //下面自定义按英文字母或数字排序
  implicit  val KeyOrdering=new Ordering[String] {
    override def compare(x: String, y: String): Int = {
      x.compareTo(y)
    }
  }
  println(a.toSeq.sorted)
}