scala(二)

一、映射

     1、Scala映射就是键值对的集合Map。默认情况下，Scala中使用不可变的映射。 如果想使用可变集合Map，必须导入scala.collection.mutable.Map    （导包时scala.collection.mutable._  为可变；scala.collection.immutable._ 为不可变）

        val  map =Map("a"->10,"b"->11,"c"->12)    或者  val  map =Map（（"a",10）,("b",11),("c",12)）

        创建可变map    val map =scala.collection.mutable.Map("a"->10,"b"->11,"c"->12)

        也可以创建hashmap      val map =new scala.collection.mutable.HashMap[String,Int]

         映射这种数据结构是一种将键映 射到值的函数。   区别在于通常的函数计算值， 而映射只是做查询。
    2、获取映射中的值

        val  map1=map("a")

        val  map1=if(map.contain("a")) map("a") else 0        和下面的意义相同，相当于Java的三元运算符

        val  map1=map.getOrElse("a",0)

         如果映射并不包含请求中使用的键， 则会抛出异常。     要检查映射中是否有某个指定的键， 可以用contains方法。   getOrElse方法， 若包含相应的键， 就返回这个键所对应的值， 否则返加0.
映射.get(键)这样的调用返回一个Option对象， 要么是Some(键对应的值)， 要么是None。  如果map 中有的话 返回Some,没有返回None

   3、修改map元素

        更新可变map集合

              更新map元素： map("a")=30   

              增加多个元素： map+=("d"->10,"e"->11)

              移除元素：map-="d"

        更新不可变map集合：

               添加不可变Map的元素， 产生一个新的集合Map， 原Map不变          val ages2 = ages + ("Mike" -> 36, "Tom" -> 40)
               移除不可变Map的元素， 产生一个新的集合Map， 原Map不变           val ages3 = ages - "Tom"          

   4、修改map的值

        score（"Bob"）=10    前提map score是可变的

   5、遍历map操作

         遍历map的entrySet      for ((key, value) <- ages) println(key + " " + value)
         遍历map的key              for (key <- ages.keySet) println(key)

         遍历map的value             for (value <- ages.values) println(value)
         生成新map， 反转key和value            for ((key, value) <- ages) yield (value, key)
         map的值是不能重复的，如果反转后，key值相同的，后面的覆盖前面的

   6、SortedMap和LinkedHashMap （上边的map不记插入的顺序，而且也不按key排序）

        SortedMap可以自动对Map的key的排序    val ages = scala.collection.immutable.SortedMap("leo" -> 30, "alice" -> 15, "jen" -> 25)
        LinkedHashMap可以记住插入entry的顺序

                  val ages = new scala.collection.mutable.LinkedHashMap[String, Int]

                   ages("leo") = 30

                  ages("alice") = 15

    7、Java Map与Scala Map的隐式转换

         Java Map 转换Scala Map

         

import scala.collection.JavaConversions.mapAsScalaMap;
class javaMapToScalaMap {
  
  def main(args: Array[String]): Unit = {
    //创建Java的Map
    val javaMap=new java.util.HashMap[String,Int]()
    javaMap.put("a", 1)
    javaMap.put("b", 2)
    javaMap.put("c", 3)
    
    //将JAVA 的map转换成Scala的Map
    val scalaMap: scala.collection.mutable.Map[String, Int] = javaMap
    for((k,v)<-scalaMap) println(k+" "+v)
  }
}

二、元组(tuple)

    1、元组是不同类型的值的聚集    对偶是元组的最简单形态      元组的索引从1开始，而不是0，切记！
       val  tuple =（1,2.3，"li",true）
       val a=tuple._2      结果为double类型的2.3

        Tuple拉链操作 ：Tuple拉链操作指的就是zip操作    zip操作， 是Array类的方法， 用于将两个Array， 合并为一个Array
         比如Array(v1)和Array(v2)， 使用zip操作合并后的格式为Array((v1,v2))      合并后的Array的元素类型为Tuple 
         例：

               val students = Array("Leo", "Jack", "Jen")
                val scores = Array(80, 100, 90)
                 val studentScores = students.zip(scores)

          如果取 值 例如    studentScores（1）._1           结果为"Jack"

           如果长度不等，直接删除多余的元素

          如果Array的元素类型是个Tuple， 调用Array的toMap方法， 可以将Array转换为Map   studentScores.toMap 

       

三、实例

        移除第一个负数之后的所有负数

         构建数组  

          val array = ArrayBuffer[Int]() 

          array += (1, 2, 3, 4, 5, -1, -3, -5, -9)

var foundFirstNegative = false
val keepIndexes = for (i <- 0 until a.length if !foundFirstNegative || array(i) >= 0)
yield {
if (array(i) < 0) foundFirstNegative = true
i
} 
for (i <- 0 until keepIndexes.length) { array(i) = array(keepIndexes(i)) }
array.trimEnd(a.length - keepIndexes.length)

四、补充

     1、Scala中的集合有三大类：序列（Seq）、集（Set）、映射（Map）

     2、对数组进行排序还有一种方法      scala.util.Sorting.quickSort(array)

     3、高阶数组