Scala学习笔记(13)—集合(四)—Set和Map

一、Set集合

Set表示无序且无重复数据的集合，默认情况下，Scala 使用的是不可变集合，如果想使用可变集合，需要引用scala.collection.mutable.Set 包。

1.不可变Set

Set本身是一个trait，不能通过构造器直接创建对象实例，还是通过调用其伴生对象的apply方法创建

//1. 创建set，会自动去重
val set1 = Set(13, 23, 53, 12, 13, 23, 78)
println(set1)

//2. 添加元素，生成一个新的set，原set2并不改变，并且插入位置无序
val set2 = set1 + 129

// 3. 合并set
val set3 = Set(19, 13, 23, 53, 67, 99)
val set4 = set2 ++ set3

// 4. 删除元素，生成一个新的set，set3并不改变
val set5 = set3 - 13

2.可变 mutable.Set

// 1. 创建set
val set1: mutable.Set[Int] = mutable.Set(13, 23, 53, 12, 13, 23, 78)

// 2. 添加元素，mutable.Set可变
//add方法添加成功返回true,元素已存在返回false
set1.add(10)	

// 3. 删除元素
//remove方法删除成功返回true,元素不存在返回false
set1.remove(10)

3. mutable.HashSet

//直接初始化一个HashSet
val hashSet1 = mutable.HashSet(1,2,6,8) 
//其他类型集合转hashset
val hashSet2 = mutable.HashSet() ++ list

二、Map集合

Scala 中的 Map 和 Java 类似，也是一个散列表，它存储的内容也是键值对（key-value）映射，通过key计算hash得出value的存储地址

Map中键值对的元素类型实际上是元组Tuple

1.不可变Map

Map和Set一样本身也是个trait，要用伴生对象的apply方法创建对象

// 1. 创建map
val map1: Map[String, Int] = Map("a" -> 13, "b" -> 25, "hello" -> 3)
println(map1)

// 2. 遍历元素执行一个函数
map1.foreach(println)
//也可以自己传一个匿名函数
map1.foreach( (kv: (String, Int)) => println(kv) )

// 3. 取map中所有的key 或者 value
for (key <- map1.keys){
   println(s"$key ---> ${map1.get(key)}")
}

// 4. 访问某一个key的value
//为了避免空指针，get()方法返回的是一个Option类型对象，
//有值则返回Some类型对象，否则返回一个None对象
//调用Some中的get方法返回元素值
println("a: " + map1.get("a").get)
println("c: " + map1.get("c"))
//设置默认值，避免get时抛出None异常
println("c: " + map1.getOrElse("c", 0))

//通过MapLike的apply方法访问
println(map1("a"))

1.可变 mutable.Map

    // 1. 创建map
    val map1: mutable.Map[String, Int] = mutable.Map("a" -> 13, "b" -> 25, "hello" -> 3)
    println(map1)
	// 2. 添加元素
    map1.put("c", 5)
    //通过直接加入一个二元组的方式添加
    map1 += (("e", 7))
    // 3. 删除元素
    map1.remove("c")
    // 4. 修改元素
    map1.update("c", 5)
    // 5. 合并两个Map
    val map2: Map[String, Int] = Map("aaa" -> 11, "b" -> 29, "hello" -> 5)
    //	map2中的元素都添加到map1中，相同key则覆盖map1的value
    map1 ++= map2
    //	后面的map加入到前面的map，相同key则覆盖value
    val map3: Map[String, Int] = map2 ++ map1

如何创建一个空的可变map

import scala.collection.mutable.Map
val a = Map[Int, String]()
val a = Map.empty[Int, String]

三、元组

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

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

	// 1. 创建元组
    val tuple: (String, Int, Char, Boolean) = ("hello", 100, 'a', true)
    println(tuple)
    
    // 2. 访问数据
    println(tuple._1)
    println(tuple._2)
    //这个是根据从0开始的索引位置访问
    println(tuple.productElement(0))
    
    // 3. 遍历元组数据
    for (elem <- tuple.productIterator)
      println(elem)

    // 4. 嵌套元组
    val mulTuple = (12, 0.3, "hello", (23, "scala"), 29)
    println(mulTuple._4._2)

元组Tuple并不是集合类型，而是扩展自另一个独立的类型Product，从Tuple1到Tuple22一共支持22种