scala学习之路：6.Map，Tuple，zip操作

Map分为可变Map与不可变的Map。

不可变的的Map直接就可以通过Map创建

  val map =Map ("book"->10 ,"gun"->18 ,"ipad"->1000)

                                                  //> map  : scala.collection.immutable.Map[String,Int] = Map(book -> 10, gun -> 1

                                                  //| 8,ipad -> 1000)

// value 由int变成double类型

  for((k,v) <-map )  yield (k,v*0.9)       //> res0: scala.collection.immutable.Map[String,Double] = Map(book -> 9.0, gun -

                                                  //| > 16.2,ipad -> 900.0)

  println(map)

//可变的Map则有专门的创建方法

  val scores = scala.collection.mutable.Map("Scala"->7,"Hadoop"->8,"spark"->10 )

                                                  //> scores  : scala.collection.mutable.Map[String,Int] = Map(spark -> 10,Hadoop

                                                  //|  -> 8,Scala -> 7)

// 这是Map的获取方法 ，如果不存在键的话就返回默认的值 

    valhadoopScore = scores.getOrElse("Hadoop",0)

                                                  //> hadoopScore  :Int = 8

// 这里的这种空操作只为了 能显示出此时的变量的值

    hadoopScore                                  //> res1: Int = 8

    //hadoopScore = scores.get("Hadoop")

//这是 Map的添加操作键值操作 与java中是有些不同 

   scores+= ("R"-> 9)                          //> res2: com.scala02.tuple.ScalaInAction.scores.type = Map(spark -> 10, Hadoop 

                                                  //| -> 8, R -> 9,Scala -> 7)

   scores                                        //> res3: scala.collection.mutable.Map[String,Int] = Map(spark -> 10,Hadoop -> 

                                                  //| 8, R -> 9,Scala -> 7)

// 这是根据键移除键值操作

   scores-="Hadoop"                             //> res4: com.scala02.tuple.ScalaInAction.scores.type = Map(spark -> 10, R -> 9,

                                                  //| Scala -> 7)

//不可变Map的排序 操作：按照key进行排序，字符串是可以排序的。

 val sortScore = scala.collection.immutable.SortedMap("Scala"->7,"Hadoop"->8,"spark"->10 )

                                                  //> sortScore  : scala.collection.immutable.SortedMap[String,Int] = Map(Hadoop -

                                                  //| > 8,Scala -> 7, spark -> 10) 

// 这是元组可以存储不同类型的值，数字，字符， Map都可以

   val tuple = (1,2,3.14,"Rocky","Spark","java"->7)

                                                  //> tuple  : (Int, Int, Double, String, String, (String, Int)) = (1,2,3.14,Rocky

                                                  //| ,Spark,(java,7))

      //val third = tuple._3  // 访问第三个元素

      //val third = tuple _3

//下划线代表占位符

 val tuple = (1,2, 3.14, "Rocky", "Spark", "java" -> 7)

                                                  //> tuple  : (Int, Int, Double, String, String, (String, Int)) = (1,2,3.14,Rocky

                                                  //| ,Spark,(java,7))

  val (first, second, third, _, fifth,six) = tuple//> first  : Int = 1

                                                  //| second  : Int = 2

                                                  //| third  : Double = 3.14

                                                  //| fifth  : String = Spark

                                                  //| six  : (String, Int) = (java,7)

// 是大写的就在一个集合，否则在另外一个集合

    "Rocky Spark".partition(_.isUpper)            //> res5: (String, String) = (RS,ocky park)

    

  valsymbols = Array("[","-","]")              //> symbols  : Array[String] = Array([, -, ])

    valcounts = Array(2,5,3)                     //> counts  : Array[Int] = Array(2, 5, 3)

    valpairs = symbols.zip(counts)              //> pairs  : Array[(String, Int)] = Array(([,2), (-,5), (],3))

    println("-------------------")

    for((x,y) <-pairs) Console.println(x + y)

    println("-------------------")

    for((x,y) <-pairs) Console.println(x * y)      

//结果是：

-------------------

[2

-5

]3

-------------------

[[

-----

]]]