scala学习笔记（六）Map和Tuple

Java中没有Tuple，Python中有Tuple且与scala中的功能相似

package com.study

/**
 * 常用数据结构Map和Tuple
 * 1,默认情况下Map构造的是不可变的集合，里面的内容不可修改，一旦修改就变成新Map，原有的Map内容保持不变
 * 2，Map的实例是调用工厂方法模式apply来构造Map实例，而需要主要的是Map是接口，在apply中使用了具体的实现：
 * 3，如果想要直接new出Map实例，则需要使用HashMap等具体的子类；
 * 4,查询一个Map中的值一定是采用getOrElse的语法，避免key不存在时产生异常。并且提供默认值。Spark中大量采用getOrElse
 * 5,SortedMap 对Key进行排序的Map
 * 6，LinkedHashMap可以记住插入元素的顺序
 * 7,Tuple中可以有很多不同类型的数据
 * 8,在企业级开发大数据时，一定反复使用Tuple来表达数据结构，以及使用tuple来处理业务逻辑
 * 9，Tuple的另外一个非常重要的使用是作为函数的返回值，在Tuple中返回若干个值，以SparkContext源码为例来说明
 * 		Create and start the scheduler
 * 		val(sched,ts)=SparkContext.createTaskScheduler(this,master)
 * 		_schedulerBackend = sched
 * 		_taskScheduler = ts
 *
 */
object HelloMapTuple {
  def main(args: Array[String]): Unit = {
    val bigDatas = Map("Spark" -> 6, "Hadoop" -> 11) //调用工厂方法模式apply来构造Map实例，而需要主要的是Map是接口，在apply中使用了具体的实现
    //bigDatas不可修改

    val programingLanguage = scala.collection.mutable.Map("Scala" -> 13, "Java" -> 23)
    programingLanguage("Scala") = 15

    var persons = Map(("A", 10), ("B", 20))
    println(persons.getOrElse("Python", "default1")) //避免异常，提供默认值
    println(persons.getOrElse("A", "default2"))

    var personInformation = new scala.collection.mutable.HashMap[String, Int]
    personInformation += ("Scala" -> 13, "Java" -> 23) //增加元素
    //    personInformation -= ("Java") //减少元素
    for ((name, age) <- personInformation) println(name + ":" + age)
    for (key <- personInformation.keySet) println(key)
    for (value <- personInformation.values) println(value)
    println("---------生成新Map[int,string]-------------")
    val result = for ((name, age) <- personInformation) yield (age, name)
    println(result.keySet.mkString(" "))
    println(result.values.mkString(" "))
    println("---------SortedMap-------------")
    val sortedMap = scala.collection.mutable.SortedMap(("A", 10), ("C", 20), ("B", 30))
    println(sortedMap.keySet.mkString(" "))
    println(sortedMap.values.mkString(" "))
    //A B C
    //10 30 20
    println("---------LinkedHashMap-------------")
    val linkedHashMap = scala.collection.mutable.LinkedHashMap(("3", 10), ("1", 20), ("4", 30), ("5", 30), ("9", 30))
    linkedHashMap +=(("12",12),("001",1))
    linkedHashMap +=("Scala"->13,"python"->10)
    println(linkedHashMap.keySet.mkString(" "))
    println(linkedHashMap.values.mkString(" "))
     println("---------Tuple中可以有很多不同类型的数据-------------")
     val information=("Test","male",30,"String")
     //由于类型不同无法使用for(item<-xx)方式读取
     println(information._3)
     
     
     
  }
}

一种Map Reduce的计算示例

   
   

    
         val txt1="I am into Spark so much"
   
   
   
   

    
          val txt2="Scala is powerful"
   
   
   
   

    
          println(List(txt1,txt2).flatMap{x=>x.split(" ")}.map {x=>(x,1)}.map(x=>x._2).reduce(_+_) )
   
   
   
   

    
          println(List(txt1,txt2).flatMap{x=>x.split(" ")}.map {(_,1)}.map{(_._2)}.reduce(_+_)) // 简化语法，同上
   
   
   
   

    
          println(List(txt1,txt2).flatMap{x=>x.split(" ")}.map {(_,1)}.map{(_._2)}.reduce((x,y)=>x+y)) // 简化语法，同上
   
   
   
   

    
          /**
   
   
   
   

    
           * 计算过程
   
   
   
   

    
           * List("I am into Spark so much","Scala is powerful")  -> .flatMap{x=>x.split(" ")
   
   
   
   

    
           * List(I, am, into, Spark, so, much, Scala, is, powerful)  -> .map {x=>(x,1)}
   
   
   
   

    
           * List((I,1), (am,1), (into,1), (Spark,1), (so,1), (much,1), (Scala,1), (is,1), (powerful,1))  -> .map(x=>x._2)
   
   
   
   

    
           * List(1, 1, 1, 1, 1, 1, 1, 1, 1)  -> .reduce(_+_)
   
   
   
   

    
           * 9
   
   
   
   

    
           */
   
   
   
   

    
    

   
   
   
   

    
    

     
     占位符_用法演示     
    
    
    
    

     
           List(0,1,2,3,4,5).foreach{x=>print(x)}
    
    
    
    

     
           println
    
    
    
    

     
           List(0,1,2,3,4,5).foreach{print(_)} // 简化语法，同上
    
    
    
    

     
           println
    
    
    
    

     
           List(0,1,2,3,4,5).foreach{print _ } // 简化语法，同上
    
    
    
    

     
           println
    
    
    
    

     
           List(0,1,2,3,4,5).foreach{print} // 简化语法，同上
    
    
    
    

     
           println
    
    
    
    

     
           List(0,1,2,3,4,5).foreach(print) // 简化语法，同上
    
    
    
    

     
           println