scala学习笔记-Map、Set、List

1：Map

• Map可以称之为映射。它是由键值对组成的集合。scala当中的Map集合与java当中的Map类似，也是key，value对形式的
• • 在scala中，Map也分为不可变Map和可变 Map。

1.1： 不可变Map

• 定义语法

  val/var map = Map(键->值, 键->值, 键->值...)    // 推荐，可读性更好 
  val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)
  

• 示例

  scala> val map1 = Map("zhangsan"->30, "lisi"->40) 
  map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 40)
  
  scala> val map2 = Map(("zhangsan", 30), ("lisi", 30)) 
  map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 30)
  // 根据key获取value 
  scala> map1("zhangsan") 
  res10: Int = 30
  

1.2：可变Map

• 可变Map需要手动导入import scala.collection.mutable.Map, 定义语法与不可变Map一致。
• 示例

  //导包
  scala> import scala.collection.mutable.Map
  import scala.collection.mutable.Map
  
  //定义可变的map
  scala> val map3 = Map("zhangsan"->30, "lisi"->40)
  map3: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)
  
  //获取zhangsan这个key对应的value
  scala> map3("zhangsan")
  res26: Int = 30
  
  //给zhangsan这个key重新赋值value
  scala> map3("zhangsan")=50
  
  //显示map3
  scala> map3
  res28: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 50)
  

1.3：Map基本操作

• 创建一个可变的map

  //导包
  scala> import scala.collection.mutable.Map
  import scala.collection.mutable.Map
  
  scala> val map = Map("zhangsan"->30, "lisi"->40) 
  map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)
  

• 按照key获取value

  // 获取zhagnsan的年龄 
  scala> map("zhangsan")
  res10: Int = 30
  
  // 获取wangwu的年龄，如果wangwu不存在，则返回-1 比较友好，避免遇到不存在的key而报错
  scala> map.getOrElse("wangwu", -1) 
  res11: Int = -1
  

• 修改key对应的value
  java scala> map("lisi")=20

  • 添加key-value键值对

    scala> map+=("wangwu" ->35)
    res12: map.type = Map(lisi -> 50, zhangsan -> 30, wangwu -> 35)
    

  • 删除key-value键值对

    scala> map -="wangwu"
    res13: map.type = Map(lisi -> 50, zhangsan -> 30)
    

  • 获取所有的key和所有的value

  //获取所有的key
  scala> map.keys
  res36: Iterable[String] = Set(lisi, zhangsan)
  
  //获取所有的key
  scala> map.keySet
  res37: scala.collection.Set[String] = Set(lisi, zhangsan)
  
  //获取所有的value
  scala> map.values
  res38: Iterable[Int] = HashMap(50, 30)
  

• 遍历map

  //第一种遍历
  scala> for(k <- map.keys) println(k+" -> " +map(k))
  lisi -> 50
  zhangsan -> 30
  
  
  //第二种遍历
  scala> for((k,v) <- map) println(k+" -> "+v)
  lisi -> 50
  zhangsan -> 30
  

2：Set集合

• Set是代表没有重复元素的集合。
• Set特点：元素不重复 ，不保证插入顺序
• scala中的集也分为两种，一种是不可变集合，另一种是可变集合。

2.1：不可变Set集合

• 语法

  //创建一个空的不可变集
  val/var 变量名 = Set[类型]()
  
  //给定元素来创建一个不可变集
  val/var 变量名 = Set[类型](元素1, 元素2, 元素3...)
  

• 示例

  // 创建set集合 
  scala> val a = Set(1,1,2,3,4,5) 
  a: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)
  
  // 获取集合的大小 
  scala> a.size 
  res0: Int = 5
  
  // 遍历集合
  scala> for(i <- a) println(i)
  
  //添加元素生成新的集合
  scala> a + 6
  res1: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
  
  // 删除一个元素 
  scala> a - 1 
  res2: scala.collection.immutable.Set[Int] = Set(5, 2, 3, 4)
  
  // 删除set集合中存在的元素 
  scala> a -- Set(2,3) 
  res3: scala.collection.immutable.Set[Int] = Set(5, 1, 4)
  
  // 拼接两个集合 
  scala> a ++ Set(6,7,8) 
  res4: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
  
  //求2个Set集合的交集
  scala> a & Set(3,4,5,6)
  res5: scala.collection.immutable.Set[Int] = Set(5, 3, 4)
  

-注意：这里对不可变的set集合进行添加删除等操作，对于该集合来说是没有发生任何变化，这里是生成了新的集合，新的集合相比于原来的集合来说发生了变化。

2.2： 可变Set集合

• 要使用可变集，必须要手动导入： import scala.collection.mutable.Set
• 示例

  //导包
  scala> import scala.collection.mutable.Set
  import scala.collection.mutable.Set
  
  //定义可变的set集合
  scala> val set=Set(1,2,3,4,5)
  set: scala.collection.mutable.Set[Int] = Set(1, 5, 2, 3, 4)
  
  //添加单个元素
  scala> set +=6
  res10: set.type = Set(1, 5, 2, 6, 3, 4)
  
  //添加多个元素
  scala> set +=(6,7,8,9)
  res11: set.type = Set(9, 1, 5, 2, 6, 3, 7, 4, 8)
  
  //添加一个set集合中的元素
  scala> set ++=Set(10,11)
  res12: set.type = Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 11, 8)
  
  //删除一个元素
  scala> set -=11
  res13: set.type = Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 8)
  
  //删除多个元素
  scala> set -=(9,10)
  res15: set.type = Set(1, 5, 2, 6, 3, 7, 4, 8)
  
  //删除一个set子集
  scala> set --=Set(7,8)
  res19: set.type = Set(1,5, 2, 6, 3, 4)
  
  scala> set.remove(1)
  res17: Boolean = true
  
  scala> set
  res18: scala.collection.mutable.Set[Int] = Set(5, 2, 6, 3, 4)
  

3：列表 List

• List是scala中最重要的、也是最常用的数据结构。
• List具备以下性质 ： 可以保存重复的值 ，有先后顺序
• 在scala中，也有两种列表，一种是不可变列表、另一种是可变列表

3.1：不可变列表

• 不可变列表就是列表的元素、长度都是不可变的
• 语法

  val/var 变量名 = List(元素1, 元素2, 元素3...)
  
  //使用 Nil 创建一个不可变的空列表
  val/var 变量名 = Nil
  
  //使用 :: 方法创建一个不可变列表
  val/var 变量名 = 元素1 :: 元素2 :: Nil
  

• 示例

  //创建一个不可变列表，存放以下几个元素（1,2,3,4）
  scala> val  list1=List(1,2,3,4)
  list1: List[Int] = List(1, 2, 3, 4)
  
  //使用Nil创建一个不可变的空列表
  scala> val  list2=Nil
  list2: scala.collection.immutable.Nil.type = List()
  
  //使用 :: 方法创建列表，包含1、2、3三个元素
  scala> val list3=1::2::3::Nil
  list3: List[Int] = List(1, 2, 3)
  

3.2：可变列表

• 可变列表就是列表的元素、长度都是可变的
• 要使用可变列表，先要导入 mport scala.collection.mutable.ListBuffer
• 语法
  • 使用ListBuffer元素类型 创建空的可变列表，语法结构

    val/var 变量名 = ListBuffer[Int]()
    

  • val/var 变量名 = ListBuffer(元素1，元素2，元素3…)

    val/var 变量名 = ListBuffer(元素1，元素2，元素3...)
    

• 示例

  //导包
  scala> import scala.collection.mutable.ListBuffer
  import scala.collection.mutable.ListBuffer
  
  //定义一个空的可变列表
  scala> val a=ListBuffer[Int]()
  a: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
  
  //定义一个有初始元素的可变列表
  scala> val b=ListBuffer(1,2,3,4)
  b: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)
  

3.3：列表操作

• 示例

  //导包
  scala> import scala.collection.mutable.ListBuffer
  import scala.collection.mutable.ListBuffer
  
  //定义一个可变的列表
  scala> val list=ListBuffer(1,2,3,4)
  list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)
  
  //获取第一个元素
  scala> list(0)
  res4: Int = 1
  //获取第一个元素
  scala> list.head
  res5: Int = 1
  
  //获取除了第一个元素外其他元素组成的列表
  scala> list.tail
  res6: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3, 4)
  
  //添加单个元素
  scala> list +=5
  res7: list.type = ListBuffer(1, 2, 3, 4, 5)
  
  //添加一个不可变的列表
  scala> list ++=List(6,7)
  res8: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7)
  
  //添加一个可变的列表
  scala> list ++=ListBuffer(8,9)
  res9: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)
  
  //删除单个元素
  scala> list -=9
  res10: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8)
  
  //删除一个不可变的列表存在的元素
  scala> list --=List(7,8)
  res11: list.type = ListBuffer(1, 2, 3, 4, 5, 6)
  
  //删除一个可变的列表存在的元素
  scala> list --=ListBuffer(5,6)
  res12: list.type = ListBuffer(1, 2, 3, 4)
  
  //可变的列表转为不可变列表
  scala> list.toList
  res13: List[Int] = List(1, 2, 3, 4)
  
  //可变的列表转为不可变数组
  scala> list.toArray
  res14: Array[Int] = Array(1, 2, 3, 4)