scala基础篇·Map

scala基础篇·Map

代码：

package base

import scala.collection.mutable

object TestMap {

  def main(args: Array[String]): Unit = {
    testBasic
    testTraverse
    testFunctions
    test
  }


  /**
    * 测试基础
    */
  def testBasic(): Unit = {
    println("---- testBasic  start ----")
    println("\n----define start----")
    //定义map
    //不可变map
    val map1 = Map("id" -> 1, "name" -> "Alice", "age" -> 22)
    println("map1:  " + map1)
    //可变map
    val map2 = scala.collection.mutable.Map("id" -> 1, "name" -> "Alice", "age" -> 22)
    println("map2:  " + map2)
    //可变指定类型map
    val map3 = new mutable.HashMap[String, Any]()
    println("map3:  " + map3)
    println("----define end----")

    //get value
    println("\n----getValue start----")
    println("map1:get(id)    =>   " + map1("id"))
    println("map2:get(name)    =>   " + map2("name"))
    println("map3:get(name)    =>   " + (if (map3.contains("name")) map3("name") else "null"))
    println("map3:getOrElse(name)    =>   " + map3.getOrElse("name", "null"))
    println("----getValue end----")

    //update value
    println("\n----updateValue start----")
    //map1("name") = "Bob" 不可变，因此不能更新,但是可以基于map1生成新的
    val map4 = map1 + ("name" -> "Neo", "grade" -> "12")
    println("map1:update(name)&add(grade) to map4   =>   " + map4)

    map2("name") = "Bob"
    println("map2:update(name)    =>   " + map2)
    println("----updateValue end----")

    //add value
    println("\n----addValue start----")
    //map1 += ("score" -> 95) 不可变，因此不能新增,但是可以基于不可变的map1生成map4，且二者共享map1的结构
    val map5 = map1 + ("score" -> 99)
    println("map1:add(score,grade) to map5   =>   " + map5)
    map2 += ("score" -> 95, "grade" -> "10")
    println("map2:add(score,grade)   =>   " + map2)
    println("----addValue end----")

    //remove value
    println("\n----removeValue start----")
    map2 -= "score"

    println("map2:remove(score)   =>   " + map2)
    println("----removeValue end----")

    println("---- testBasic  end ----")
  }

  /**
    * 测试遍历
    */
  def testTraverse(): Unit = {
    println("---- testTraverse  start ----")
    val map1 = Map("Alice" -> 10, "Bob" -> 12, "Candy" -> 15, "David" -> 18)

    print("遍历map1的key-value:  ")
    for ((k, v) <- map1) {
      printf("(%s,'%d')", k, v)
    }
    println()

    print("基于map1生成map2:  ")
    val map2 = for ((k, v) <- map1) yield (v * v, k)
    println(map2)


    print("遍历map1的key:  ")
    for (k <- map1.keys)
      printf("%s  ", k)
    println()

    print("遍历map1的value:  ")
    for (v <- map1.values)
      printf("%d  ", v)
    println()

    println("map1.keySet  =>  " + map1.keySet)

    println("---- testTraverse  end ----")
  }

  /**
    * 测试方法
    */
  def testFunctions(): Unit = {
    val map = Map("alice" -> 98, "Bob" -> 86, "Candy" -> 90, "david" -> 82, "Ellen" -> 78, "Harry" -> 78)

    println("---- filter start ----")
    println("filter  =>  " + map.filter(e => {
      e._2 > 90
    }))
    println("filterNot  =>  " + map.filterNot(e => {
      e._2 > 90
    }))
    println("filter  =>  " + map.filter(e => {
      Character.isLowerCase(e._1.charAt(0))
    }))
    println("filterKeys  =>  " + map.filterKeys(k => {
      Character.isLowerCase(k.charAt(0))
    }))
    println("---- filter end ----")
    println()
    println("---- find start ----")
    println("find(找到一个就返回)  =>  " + map.find(e => {
      Character.isLowerCase(e._1.charAt(0))
    }))
    println("---- find end ----")
    println()

    println("---- maxBy/minBy start ----")
    println("maxBy:key  =>  " + map.maxBy(_._1))
    println("maxBy:val  =>  " + map.maxBy(_._2))
    println("minBy:key  =>  " + map.minBy(_._1))
    println("minBy:val  =>  " + map.minBy(_._2))
    println("---- maxBy/minBy end ----")
  }

  def test(): Unit = {
    val set = scala.collection.JavaConversions.asScalaSet(System.getProperties.stringPropertyNames())
    var max = 0
    for (s <- set)
      max = math.max(max, s.length)
    //println(max)
    for (s <- set) {
      val len = max - s.length
      val sb = new mutable.StringBuilder(s)
      for (i <- 0 until len)
        sb.append(' ')
      printf("%s | %s\n", sb.toString(), System.getProperty(s))
    }
  }
}

执行结果:

---- testBasic  start ----

----define start----
map1:  Map(id -> 1, name -> Alice, age -> 22)
map2:  Map(age -> 22, name -> Alice, id -> 1)
map3:  Map()
----define end----

----getValue start----
map1:get(id)    =>   1
map2:get(name)    =>   Alice
map3:get(name)    =>   null
map3:getOrElse(name)    =>   null
----getValue end----

----updateValue start----
map1:update(name)&add(grade) to map4   =>   Map(id -> 1, name -> Neo, age -> 22, grade -> 12)
map2:update(name)    =>   Map(age -> 22, name -> Bob, id -> 1)
----updateValue end----

----addValue start----
map1:add(score,grade) to map5   =>   Map(id -> 1, name -> Alice, age -> 22, score -> 99)
map2:add(score,grade)   =>   Map(age -> 22, name -> Bob, grade -> 10, score -> 95, id -> 1)
----addValue end----

----removeValue start----
map2:remove(score)   =>   Map(age -> 22, name -> Bob, grade -> 10, id -> 1)
----removeValue end----
---- testBasic  end ----
---- testTraverse  start ----
遍历map1的key-value:  (Alice,'10')(Bob,'12')(Candy,'15')(David,'18')
基于map1生成map2:  Map(100 -> Alice, 144 -> Bob, 225 -> Candy, 324 -> David)
遍历map1的key:  Alice  Bob  Candy  David  
遍历map1的value:  10  12  15  18  
map1.keySet  =>  Set(Alice, Bob, Candy, David)
---- testTraverse  end ----
---- filter start ----
filter  =>  Map(alice -> 98)
filterNot  =>  Map(david -> 82, Harry -> 78, Bob -> 86, Candy -> 90, Ellen -> 78)
filter  =>  Map(david -> 82, alice -> 98)
filterKeys  =>  Map(david -> 82, alice -> 98)
---- filter end ----

---- find start ----
find(找到一个就返回)  =>  Some((david,82))
---- find end ----

---- maxBy/minBy start ----
maxBy:key  =>  (david,82)
maxBy:val  =>  (alice,98)
minBy:key  =>  (Bob,86)
minBy:val  =>  (Harry,78)
---- maxBy/minBy end ----
---- test start ---
java.runtime.name             | ****
sun.boot.library.path         | ****
java.vm.version               | ****
gopherProxySet                | ****
java.vm.vendor                | ****
java.vendor.url               | ****
path.separator                | ****
java.vm.name                  | ****
file.encoding.pkg             | ****
user.country                  | ****
sun.java.launcher             | ****
sun.os.patch.level            | ****
java.vm.specification.name    | ****
user.dir                      | ****
java.runtime.version          | ****
java.awt.graphicsenv          | ****
java.endorsed.dirs            | ****
os.arch                       | ****
java.io.tmpdir                | ****
line.separator                | ****
java.vm.specification.vendor  | ****
os.name                       | ****
sun.jnu.encoding              | ****
java.library.path             | ****
java.specification.name       | ****
java.class.version            | ****
sun.management.compiler       | ****
os.version                    | ****
http.nonProxyHosts            | ****
user.home                     | ****
user.timezone                 | ****
java.awt.printerjob           | ****
file.encoding                 | ****
java.specification.version    | ****
user.name                     | ****
java.class.path               | ****
java.vm.specification.version | ****
sun.arch.data.model           | ****
java.home                     | ****
sun.java.command              | ****
java.specification.vendor     | ****
user.language                 | ****
awt.toolkit                   | ****
java.vm.info                  | ****
java.version                  | ****
java.ext.dirs                 | ****
sun.boot.class.path           | ****
java.vendor                   | ****
file.separator                | ****
java.vendor.url.bug           | ****
sun.cpu.endian                | ****
sun.io.unicode.encoding       | ****
socksNonProxyHosts            | ****
ftp.nonProxyHosts             | ****
sun.cpu.isalist               | ****
---- test end ---