Scala集合之Set与Map

一、Set

Set默认为不可变、无序、无重复项的集合；可变Set需要引入scala.collection.mutable.Set包
Set直接创建即可Set/scala.collection.mutable.Set()，也可以直接输出集合形式

1、不可变Set

object Main extends App {
    //创建，输出是无序的
    val set = Set(1,3,2,5)
    println("set：" + set)
    
    //添加，无序集合，所以添加元素的位置是可变的，不需要规定首位等位置
    val set1 = set + 6 + 8
    println("set1：" + set1)
    
    //删除
    val set2 = set - 3 - 1
    println("set2：" + set2)
    
    //合并集合
    val set3 = set ++ set1 //合并时会自动去重
    println("set3：" + set3) 
    
    val set4 = set3 -- set
    println("set4：" + set4) 
}
set：Set(1, 5, 2, 3)
set1：Set(1, 5, 2, 6, 3, 8)
set2：Set(5, 2)
set3：Set(1, 5, 2, 6, 3, 8)
set4：Set(6, 8)

2、可变Set

object Main extends App {
    import scala.collection.mutable._
    //创建可变集合
    val set1 = Set(0,6)
    println("set1：" + set1)
    val set = scala.collection.mutable.Set(1,3,2,5)
    println("set：" + set)
    
    //添加
    set += 6 += 8
    println("set新增：" + set)
    set.add(9)
    println("set新增：" + set)
    
    //删除
    set -= 3 -= 1
    println("set删除：" + set)
    set.remove(9)
    println("set删除：" + set)
    
    //合并集合
    set ++= set1
    println("set合并set1：" + set) 
    
    set --= set1 //set1里没有set的元素时，不减
    println("set合并set1：" + set) 
}
set1：Set(0, 6)
set：Set(1, 5, 2, 3)
set新增：Set(1, 5, 2, 6, 3, 8)
set新增：Set(9, 1, 5, 2, 6, 3, 8)
set删除：Set(9, 5, 2, 6, 8)
set删除：Set(5, 2, 6, 8)
set合并set1：Set(0, 5, 2, 6, 8)
set合并set1：Set(5, 2, 8)

二、Map

Map是键值对的集合，也分为不可变和可变。创建直接用 Map/scala.collection.mutable.Map() 即可。
Map.get(“key”) / Map(“key”) 访问Map里的某个键对应的值。这个返回有两个结果，若key存在，则返回Some()，否则返回None。若想要直接返回值，则需再调用一次get方法，Map.get(“key”).get。
但None是不能调用get函数的，所以建议直接返回值的话，使用Map.getOrElse(“key”,0)，即将key不存在的值返回为0。

1、不可变Map

object Main extends App {
    //创建不可变集合
    val map = Map("a" -> 1,"b" -> 2,"c" -> 3)
    println(map)
    println(map.getClass)
    
    //访问指定键对应的值
    println("a：" + map.get("a").get)
    println(map.get("b"))
    println("d：" + map.get("d")) //返回None
    println("d：" + map.getOrElse("d",0)) //返回0
    
    //访问所有键、值
    for (i <- map.keys){
        println(i + "：" + map.getOrElse(i,0))
        println(i + "：" + map.get(i))
    }
        
    //增加
    val map1 = map + (("d",4)) + (("e",5))
    println("map1：" + map1)
    
    //删除
    val map2 = map1 - "e"
    println("map2：" + map2)
    
    //合并
    val map3 = map ++ map1
    println("map合并map1：" + map3)
}
Map(a -> 1, b -> 2, c -> 3)
class scala.collection.immutable.Map$Map3
a：1
Some(2)
d：None
d：0
a：1
a：Some(1)
b：2
b：Some(2)
c：3
c：Some(3)
map1：Map(e -> 5, a -> 1, b -> 2, c -> 3, d -> 4)
map2：Map(a -> 1, b -> 2, c -> 3, d -> 4)
map合并map1：Map(e -> 5, a -> 1, b -> 2, c -> 3, d -> 4)

2、可变Map

object Main extends App {
    import scala.collection.mutable._
    //创建不可变集合
    val map = scala.collection.mutable.Map("a" -> 1,"b" -> 2,"c" -> 3)
    println(map)
    println(map.getClass)
    
    //新增
    map.put("d",4)
    println(map)
    map += (("e",5)) += (("f",6))
    println(map)
    
    //删除
    map -= "f" -= "d"
    println(map)
    map.remove("e")
    println(map)
    
    //修改
    map("a") = 8 //存在时修改
    println("修改a：" + map("a"))
    map("g") = 9 //不存在时新增
    println("新增g：" + map)
    map.update("c",7)
    println("修改c：" + map("c"))
    
    //集合合并
    val map1 = Map("ac" -> 2,"bc" -> 3,"c" -> 5)
    map ++= map1 //map1的键值对覆盖插入map中
    println("map合并map1：" + map)
    
    //访问指定键对应的值
    println("a：" + map.get("a").get)
    println("b：" + map.get("b"))
    println("c：" + map("c"))
    println("d：" + map.get("d")) //返回None
    println("d：" + map.getOrElse("d",0)) //返回0
    
    //访问所有键、值
    for (i <- map.keys){
        println(i + "：" + map.getOrElse(i,0))
        println(i + "：" + map.get(i))
    }
}
Map(b -> 2, a -> 1, c -> 3)
class scala.collection.mutable.HashMap
Map(b -> 2, d -> 4, a -> 1, c -> 3)
Map(e -> 5, b -> 2, d -> 4, a -> 1, c -> 3, f -> 6)
Map(e -> 5, b -> 2, a -> 1, c -> 3)
Map(b -> 2, a -> 1, c -> 3)
修改a：8
新增g：Map(b -> 2, g -> 9, a -> 8, c -> 3)
修改c：7
map合并map1：Map(b -> 2, ac -> 2, g -> 9, a -> 8, c -> 5, bc -> 3)
a：8
b：Some(2)
c：5
d：None
d：0
b：2
b：Some(2)
ac：2
ac：Some(2)
g：9
g：Some(9)
a：8
a：Some(8)
c：5
c：Some(5)
bc：3
bc：Some(3)