Scala中的集合、不可变List、可变ListBuffer、不可变Set、可变HashSet、不可变Map、可变HashMap 08

朴灿烈づ我的快乐病毒、 2022-02-04 12:47 551阅读 0赞

# 前言 #

Scala的集合有三类：**序列Seq、Set、映射Map**，所有的集合都扩展自Iterable特质，在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后内容就不能改变了。

# 1. List #

## 1.1 不可变的序列 import scala.collection.immutable.\_ ##

在Scala中，列表要么为空（Nil表示空列表），要么是一个head元素加上一个tail列表。  
**List常用操作**

*  \+: (elem: A): List\[A\] 在列表的头部添加一个元素
 *  :: (x: A): List\[A\] 在列表的头部添加一个元素
 *  :+ (elem: A): List\[A\] 在列表的尾部添加一个元素
 *  \++\[B\](that: GenTraversableOnce\[B\]): List\[B\] 从列表的尾部添加另外一个列表
 *  ::: (prefix: List\[A\]): List\[A\] 在列表的头部添加另外一个列表  
    val left = List(1,2,3)  
    val right = List(4,5,6)
 *  以下操作等价  
    left ++ right // List(1,2,3,4,5,6)  
    right.:::(left) // List(1,2,3,4,5,6)
 *  以下操作等价  
    0 +: left //List(0,1,2,3)  
    left.+:(0) //List(0,1,2,3)
 *  以下操作等价  
    left :+ 4 //List(1,2,3,4)  
    left.:+(4) //List(1,2,3,4)
 *  以下操作等价  
    0 :: left //List(0,1,2,3)  
    left.::(0) //List(0,1,2,3)

/** * 不可变List集合操作 */
    object ImmutListDemo { 
      def main(args: Array[String]) { 
        //创建一个不可变的集合
        val lst1 = List(1,2,3)
        //补充：另一种定义list方法
        val other_lst=2::Nil
        //获取集合的第一个元素
        val first=lst1.head
        //获取集合中除第一个元素外的其他元素集合,
        val tail=lst1.tail
        //补充：其中如果 List 中只有一个元素，那么它的 head 就是这个元素，它的 tail 就是 Nil；
        println(other_lst.head+"----"+other_lst.tail)
        //将0插入到lst1的前面生成一个新的List
        val lst2 = 0 :: lst1
        val lst3 = lst1.::(0)
        val lst4 = 0 +: lst1
        val lst5 = lst1.+:(0)
        
    //将一个元素添加到lst1的后面产生一个新的集合
        val lst6 = lst1 :+ 3
        val lst0 = List(4,5,6)	
        //将2个list合并成一个新的List
        val lst7 = lst1 ++ lst0
        //将lst0插入到lst1前面生成一个新的集合
        val lst8 = lst1 ++: lst0
        //将lst0插入到lst1前面生成一个新的集合
        val lst9 = lst1.:::(lst0)
    
        println(other_lst)
        println(lst1)
        println(first)
        println(tail)
        println(lst2)
        println(lst3)
        println(lst4)
        println(lst5)
        println(lst6)
        println(lst7)
        println(lst8)
        println(lst9)
      }
    }

## 1.2 可变的序列 import scala.collection.mutable.\_ ##

import scala.collection.mutable.ListBuffer
    
    object MutListDemo extends App{ 
      //构建一个可变列表，初始有3个元素1,2,3
      val lst0 = ListBuffer[Int](1,2,3)
      //创建一个空的可变列表
      val lst1 = new ListBuffer[Int]
      //向lst1中追加元素，注意：没有生成新的集合
      lst1 += 4
      lst1.append(5)
    
      //将lst1中的元素最近到lst0中， 注意：没有生成新的集合
      lst0 ++= lst1
    
      //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
      val lst2= lst0 ++ lst1
    
      //将元素追加到lst0的后面生成一个新的集合
      val lst3 = lst0 :+ 5
    
      //删除元素,注意：没有生成新的集合
      val lst4 = ListBuffer[Int](1,2,3,4,5)
      lst4 -= 5
    
      //删除一个集合列表,生成了一个新的集合
      val lst5=lst4--List(1,2)
    
      //把可变list 转换成不可变的list 直接加上toList
      val lst6=lst5.toList
    
      //把可变list 转变数组用toArray
      val lst7=lst5.toArray
    
      println(lst0)
      println(lst1)
      println(lst2)
      println(lst3)
      println(lst4)
      println(lst5)
      println(lst6)
      println(lst7)
    
    }

# 2. Set #

## 2.1 不可变的Set import scala.collection.immutable.\_ ##

Set代表一个没有重复元素的集合；将重复元素加入Set是没有用的，而且 Set 是不保证插入顺序的，即 Set 中的元素是乱序的。  
定义：val set=Set(元素,元素,…)

//定义一个不可变的Set集合
    scala> val set =Set(1,2,3,4,5,6,7)
    set: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 4)
    
    //元素个数
    scala> set.size
    res0: Int = 7
    
    //取集合最小值
    scala> set.min
    res1: Int = 1
    
    //取集合最大值
    scala> set.max
    res2: Int = 7
    
    //将元素和set1合并生成一个新的set，原有set不变
    scala> set + 8
    res3: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
    
    scala> val set1=Set(7,8,9)
    set1: scala.collection.immutable.Set[Int] = Set(7, 8, 9)
    
    //两个集合的交集
    scala> set & set1
    res4: scala.collection.immutable.Set[Int] = Set(7)
    
    //两个集合的并集
    scala> set ++ set1
    res5: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)
    
    //在第一个set基础上去掉第二个set中存在的元素
    scala> set -- set1
    res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
    
    //返回第一个不同于第二个set的元素集合
    scala> set &~ set1
    res7: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
    
    
    //计算符合条件的元素个数
    scala> set.count(_ >5)
    res8: Int = 2
    
    /返回第一个不同于第二个的元素集合
    scala> set.diff(set1)
    res9: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
    
    /返回第一个不同于第二个的元素集合
    scala> set1.diff(set)
    res10: scala.collection.immutable.Set[Int] = Set(8, 9)
    
    //取子set(2,5为元素位置, 从0开始，包含头不包含尾)
    scala> set.slice(2,5)
    res11: scala.collection.immutable.Set[Int] = Set(6, 2, 7)
    
    //迭代所有的子set，取指定的个数组合
    scala> set1.subsets(2).foreach(x=>println(x))
    Set(7, 8)
    Set(7, 9)
    Set(8, 9)

## 2.2 可变的Set import scala.collection.mutable.\_ ##

//导入包
    scala> import scala.collection.mutable
    import scala.collection.mutable
    //定义一个可变的Set
    scala> val set1=new HashSet[Int]()
    set1: scala.collection.mutable.HashSet[Int] = Set()
    
    //添加元素
    scala> set1 += 1
    res1: set1.type = Set(1)
    
    //添加元素 add等价于+=
    scala> set1.add(2)
    res2: Boolean = true
    scala> set1
    res3: scala.collection.mutable.HashSet[Int] = Set(1, 2)
    
    //向集合中添加元素集合
    scala> set1 ++=Set(1,4,5)
    res5: set1.type = Set(1, 5, 2, 4)
    
    //删除一个元素
    scala> set1 -=5
    res6: set1.type = Set(1, 2, 4)
    
    //删除一个元素
    scala> set1.remove(1)
    res7: Boolean = true
    scala> set1
    res8: scala.collection.mutable.HashSet[Int] = Set(2, 4)

# 3. Map #

## 3.1 不可变的Map import scala.collection.immutable.\_ ##

定义Map集合
    1.val map=Map(键 -> 值 , 键 -> 值...)
    2.利用元组构建  val map=Map((键，值), (键，值) , (键，值)....)
    展现形式：
    val  map = Map(“zhangsan”->30,”lisi”->40)
    val  map = Map((“zhangsan”,30),(“lisi”,40))
    
    3.操作map集合
    获取值： 值=map(键)
    原则：通过先获取键，在获取键对应值。
    
    4.遍历map集合
    scala> val imap=Map("zhangsan" -> 20,"lisi" ->30)
    imap: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 20, lisi -> 30)
    //方法一：显示所有的key
    scala> imap.keys
    res0: Iterable[String] = Set(zhangsan, lisi)
    
    //方法二：显示所有的key
    scala> imap.keySet
    res1: scala.collection.immutable.Set[String] = Set(zhangsan, lisi)
    
    //通过key获取value
    scala> imap("lisi")
    res2: Int = 30
    
    //通过key获取value 有key对应的值则返回，没有就返回默认值0，
    scala> imap.getOrElse("zhangsan",0)
    res4: Int = 20
    
    //没有对应的key，返回默认0
    scala> imap.getOrElse("zhangsan1",0)
    res5: Int = 0
    //由于是不可变map,故不能向其添加、删除、修改键值对

## 3.2 可变的Map import scala.collection.mutable.\_ ##

//导包
    import scala.collection.mutable
    //声明一个可变集合
    scala> val user =mutable.HashMap("zhangsan"->50,"lisi" -> 100)
    user: scala.collection.mutable.HashMap[String,Int] = Map(lisi -> 100, zhangsan -> 50)
    
    //添加键值对
    scala> user +=("wangwu" -> 30)
    res0: user.type = Map(lisi -> 100, zhangsan -> 50, wangwu -> 30)
    
    //添加多个键值对
    scala> user += ("zhangsan0" -> 30,"lisi0" -> 20)
    res1: user.type = Map(zhangsan0 -> 30, lisi -> 100, zhangsan -> 50, lisi0 -> 20,wangwu -> 30)
    
    //方法一：显示所有的key
    scala> user.keys
    res2: Iterable[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)
    
    //方法二：显示所有的key
    scala> user.keySet
    res3: scala.collection.Set[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)
    
    //通过key获取value
    scala> user("zhangsan")
    res4: Int = 50
    
    //通过key获取value 有key对应的值则返回，没有就返回默认值0，
    scala> user.getOrElse("zhangsan",0)
    res5: Int = 50
    
    //没有对应的key，返回默认0
    scala> user.getOrElse("zhangsan1",0)
    res6: Int = 0
    
    //更新键值对
    scala> user("zhangsan") = 55
    scala> user("zhangsan")
    res8: Int = 55
    
    //更新多个键值对
    scala> user += ("zhangsan" -> 60, "lisi" -> 50)
    res9: user.type = Map(zhangsan0 -> 30, lisi -> 50, zhangsan -> 60, lisi0 -> 20,wangwu -> 30)
    
    //删除key
    scala> user -=("zhangsan")
    res14: user.type = Map(zhangsan0 -> 30, lisi -> 50, lisi0 -> 20, wangwu -> 30)
    
    //删除key
    scala>user.remove("zhangsan0")
    
    //遍历map 方法一：通过key值
    scala> for(x<- user.keys) println(x+" -> "+user(x))
    lisi -> 50
    lisi0 -> 20
    wangwu -> 30
    
    //遍历map 方法二：模式匹配
    scala> for((x,y) <- user) println(x+" -> "+y)
    lisi -> 50
    lisi0 -> 20
    wangwu -> 30
    
    //遍历map 方法三：通过foreach
    scala>  user.foreach{ case (x,y) => println(x+" -> "+y)}
    lisi -> 50
    lisi0 -> 20
    wangwu -> 30