Scala学习四——映射和数组

一.本章要点

• Scala有十分易用的语言来创建，查询和遍历映射
• 你需要从可变和不可变的映射中做出选择
• 默认情况下，你得到的是一个哈希映射，不过你也可以指明要树形映射
• 你可以很容易地在Scala映射和Java映射之间来回切换
• 元祖可以用来聚集值

二.构造映射（哈希表）

　　构造不可变映射：

　　　　val scores=Map("Alice"->100,"Bob"->3,"Cindy"->8)

　　构造可变映射：

　　　　val scores=scala.collection.multable.Map("Alice"->10,"Bob"->3,"Cindy->8")　

　　构造空映射：　　　　

　　　　val scores=scala.collection.multable.Map(String,Int)

　　注：也可以使用()替换->　　　　　

三.获取映射中的值

　　使用（）获取，如果没有该键会抛出异常，使用contains方法检查是否包含某个键，可以使用getOrElse方法获取。

四.更新映射中的值

　　可变映射:

　　　　直接更新：scores("Bob")=20

　　　　没有该键则增加新的值：scores("LYQ")=100

　　　　通过+=添加多个关系：scores+=("Bob"->11,"Fed"->23)

　　　　通过-=移除：scores-="Bob"

　　不可变映射:

　　　　可以获取包含所需要的更新的新映射：val newScores=scores+("Bob"->10,"Fed"->22)

　　　　通过-获取一个新的去掉该键的值：scores-=scores-"Alice"　　　　　　

五.迭代映射

　　迭代键值：for((k,v)<-映射) 处理k，v;　　

　　只处理键：scores.keySet();

　　只处理值：scores.values

六.已排序映射

　　不可变树形映射：val scores=scala.collections.immutable.SortedMap("Alice"->10,"Fred"->6,"Bob"->9)

　　可变的树形结构（Scala目前没有）：可以用Java的TreeMap

　　按插入顺序访问所有键：val months=scala.collections.mutable.LinkedHashMap(.....)

七.与Java的互操作

 

 

 

 

 

 

 

 

 

 

八.元组

 　　元组是不对类型的值的聚集，如（1,3.14,”Fred“）类型为Tuple3(Int,Double,java.lang.String)，可以通过_1,_2,_3依次递增访问组元（如t._1,也可以把.替换为空格），也可以使用模式匹配获取元组组元（如:val （first,second,third）=t）。

九.拉链操作

　　如果有一个键的集合以及与之对应的值的集合，就可以使用拉链操作把它组合成一个映射：

　　　　keys.zip(values).toMap

十.练习

 

 

 　   1.

def main(args: Array[String]): Unit = {
    val map = Map("Mac" -> 12000, "Redmi k30" -> 1699)
    val discountMap = for ((k, v) <- map) yield (k, v * 0.9)
    discountMap.foreach(print)
  }

 

　　2.

 def main(args: Array[String]): Unit = {
  try {
    val in = new java.util.Scanner(new java.io.File("src/main/scala/Ch4/test.txt"))
    val map = new mutable.HashMap[String, Int]
    while (in.hasNext()) {
      val key = in.next()
      map(key) = map.getOrElse(key, 0) + 1
    }
    map.foreach(print)
  }
  catch {
    case ex:Exception=>{
      print(ex.getMessage)
    }
  }

}

 

　　3.

def main(args: Array[String]): Unit = {
    try {
      val in = new java.util.Scanner(new java.io.File("src/main/scala/Ch4/test.txt"))
      var map = Map[String, Int]()
      while (in.hasNext()) {
        val key = in.next()
        map += (key -> (map.getOrElse(key, 0) + 1))
      }
      map.foreach(print)
    }
    catch {
      case ex: Exception => {
        print(ex.getMessage)
      }
    }

  }

 

　　4.

def main(args: Array[String]): Unit = {
    try {
      val in = new java.util.Scanner(new java.io.File("src/main/scala/Ch4/test.txt"))
      var sortMap = SortedMap[String, Int]()
      while (in.hasNext()) {
        val key = in.next()
        sortMap += (key -> (sortMap.getOrElse(key, 0) + 1))
      }
      sortMap.foreach(print)
    }
    catch {
      case ex: Exception => {
        print(ex.getMessage)
      }
    }

  }

 

　　5.

 //隐式转换，asScala方法
  import scala.collection.JavaConverters._

  try {
    val in = new java.util.Scanner(new java.io.File("src/main/scala/Ch4/test.txt"))
    val treeMap = new java.util.TreeMap[String, Int].asScala
    while (in.hasNext()) {
      val key = in.next()
      treeMap(key) = treeMap.getOrElse(key, 0) + 1
    }
    treeMap.foreach(print)
  }
  catch {
    case ex: Exception => {
      print(ex.getMessage)
    }
  }

 

　　6.

 import java.util.Calendar

  import scala.collection.mutable

  def main(args: Array[String]): Unit = {

    val map = new mutable.LinkedHashMap[String, Int]

    map += ("Monday" -> Calendar.MONDAY)

    map += ("Tuesday" -> Calendar.TUESDAY)

    map += ("Thursday" -> Calendar.THURSDAY)

    map += ("Wednesday" -> Calendar.WEDNESDAY)

    map += ("Friday" -> Calendar.FRIDAY)

    map += ("Saturday" -> Calendar.SATURDAY)

    map += ("Sunday" -> Calendar.SUNDAY)

    map.foreach(print)
  }

　　7. 

def main(args: Array[String]): Unit = {
    import scala.collection.JavaConverters._

    val props = System.getProperties().asScala

    val maxlen = props.map(m => m._1.length).max
    props.foreach(x => println(x._1 + " " * (maxlen - x._1.length + 1) + "| " + x._2))
  }

 

　　8.

 def main(args: Array[String]): Unit = {
    val arr = Array(1, 2, 3, 4, 5, 6)
    var tup: (Int, Int) = minmax(arr)
    print(tup._1 + " " + tup._2)
  }

  def minmax(values: Array[Int]) = {
    (values.min, values.max)
  }

 

　　9.

 def main(args: Array[String]): Unit = {
    val array = Array(1, 1, 2, 2, 3, 3, 4, 5, 6)

    val tup: (Int, Int, Int) = lteqgt(array, 3)
    print("小：%d,等：%d,大:%d".format(tup._1, tup._2, tup._3))
  }

  def lteqgt(values: Array[Int], v: Int) = {
    (values.count(_ < v), values.count(_ == v), values.count(_ > v))
  }

 

　　10.

  def main(args: Array[String]): Unit = {
     println("Hello" zip "World")
  }