Scala-Set集合、Map集合、元组

Set集合

Map集合 

元组

---

Set集合

默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包。

不可变 Set

• Set 默认是不可变集合，数据无序
• 数据不可重复
• 遍历集合

//创建不可变Set集合
    val set1 = Set(1,2,3,4,5,6,7,8,9,10)
    println(set1)

    //添加元素
    val set2 = set1.+(20)
    println(set2)

    //合并Set集合
    val  set3 = set1 ++ set2 //相同数据去重
    println(set3)

    //删除元素
    val set4 = set3 - 20 //删除元素20
    println(set4) 

可变 Set集合

1. 创建可变集合 mutable.Set
2. 打印集合
3. 集合添加元素、
4. 向集合中添加元素，返回一个新的 Set
5. 删除数据

//创建可变Set集合
    val set1 = mutable.Set[Int](1,2,3,4,5,6,7,8,9,10)
    val set2 = mutable.Set[Int](0)
    println(set1)

    //添加元素
    set1 += 11 //添加元素11
    set1.add(12)//添加元素12
    println(set1)

    //删除元素
    set1 -= 1 //删除元素1
    set1.remove(2)//删除元素2
    println(set1)

    //合并集合
    val set3 = set1 ++ set2
    println(set3)
    set1 ++= set3
    println(set1)

Map集合 

Scala 中的 Map 和 Java 类似，也是一个散列表，它存储的内容也是键值对（key-value） 映射 

不可变Map集合  

1. 创建不可变集合 Map
2. 循环打印
3. 访问数据
4. 如果 key 不存在，返回 0

//创建不可变Map集合
    val map1: Map[String , Int] = Map("a" -> 13 , "b" -> 14 , "c" -> 15 ,"d" -> 16)
    println(map1)

    //遍历元素
    map1.foreach(((kv : (String,Int)) => println(kv)))
      //简写
    map1.foreach(println)

    //访问元素
      //方法一
    println(map1.getOrElse("a",0)) //getOrElse(键,若没有值则返回该处的默认值))
      //  方法二
    println(map1.get("b").get)
      //方法三
    println(map1("c"))

    //取key、value
    for (key <- map1.keys){
      println("key:"+key+" , vaule:"+map1.getOrElse(key,0))
    }

可变 Map 

1. 创建可变集合
2. 打印集合
3. 向集合增加数据
4. 删除数据
5. 修改数据

//创建可变Map集合
    val map1: mutable.Map[String , Int] = mutable.Map("a" -> 13 , "b" -> 14 , "c" -> 15 ,"d" -> 16)
    val map2: mutable.Map[String , Int] = mutable.Map("z" -> 3 , "x" -> 4 , "v" -> 5 ,"m" -> 6)
    println(map1)

    //添加元素
    map1.put("e",17) //方法1
    map1 += (("f",18)) //方法2
    println(map1)

    //删除
    map1.remove("a") //方法1remove(key)
    map1 -= "b" //方法2 -= key
    println(map1)

    //修改元素
    map1.update("c",20) //修改值为20

    //合并Map集合
    val map3 = map1 ++ map2
    map1 ++= map2
    println(map3)
    println(map1)

元组

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据，是将多个无关的数据封装为一个整体，称为元组。

注意：元组中最大只能有 22 个元素。

1. 声明元组的方式：(元素 1，元素 2，元素 3) 
2. 访问元组
3. Map 中的键值对其实就是元组,只不过元组的元素个数为 2，称之为对偶 

//创建元组
    val tuple :(String,Int,Int,String,Int,Boolean) = ("a",12,14,"name",65,true)
    println(tuple)

    //访问数据
    println(tuple._1) // _1表示元组第一个元素
    println(tuple._2)
    println(tuple.productElement(1)) //索引方式访问

    //遍历
    for(i <- tuple.productIterator) { //.productIterator迭代器方法
      println(i)
    }

    //嵌套
    val mulTuple = (12,"aa",10,("bb",6,"cc"))
      //访问
    println(mulTuple._4._1)//第4个元素是嵌套元组 访问嵌套元组中第一个值 bb