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")
  }  
posted @ 2019-11-27 17:28  biu嘟  阅读(254)  评论(0编辑  收藏  举报