Scala——4. Scala collection

最新推荐文章于 2023-04-05 10:13:07 发布

原创最新推荐文章于 2023-04-05 10:13:07 发布 · 379 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Scala

Scala 专栏收录该内容

6 篇文章

订阅专栏

本文详细介绍了Scala中的四种主要集合类型：Map（包括可变与不可变）、Tuple、List和Set。对于Map，讨论了如何创建、修改和遍历；Tuple部分介绍了元组的创建与取值；List则讲解了不可变与可变列表的操作，如添加、删除元素；Set部分阐述了其无序和唯一性的特点，并展示了相关操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

注意：通常我们在创建一个集合时会用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内容是不是可变，取决于这个引用指向的集合的类型。

1. 映射 Map

Map分为可变map和不可变Map 默认情况下是不可变Map
不可变Map不能添加、修改、删除键值对p

定义格式：
val m1 = Map(k1 -> v1,k2 -> v3,k3 -> v3)
val m2 = Map((k1,v1),(k2,v2),(k3,v3))

获取值：(可变Map和不可变Map都适用)
     m1(k1) = v1
     m1.get(k1) = v1
     m1.getOrElse(k1,默认值)     通过key获取value，有key对应的值则返回，没有就返回默认值
     m1.keySet
     m1.Keys

可变Map：
     手动导包**import scala.collection.mutable.Map
     元素值的修改：
          m1(k1) = 新k
          m1 += (键->新值, 键->新值, …)
     增加元素
          m1 += (k3->v3)
          m1 += ((k3,v3))
     删除元素：只需要指定key就可以
          m1 -= (k1)
          m1.remove(k1)

Map遍历：
     for(i <- m1.keys) println(i + “—” + m1(i))
     for(i <- m1.keySet) println(i + “—” + m1(i))
     for((x,y) <- m1) println(x + “—” + y) 模式匹配遍历重点掌握
     m1.foreach{case(x,y) => println(x + “—” + y)}

案例：

不可变 Map

scala> val m1 = Map("name"->"zoie","age"->20)
m1: scala.collection.immutable.Map[String,Any] = Map(name -> zoie, age -> 20)

scala> val m2 = Map(("name","zoie"),("age",20))
m2: scala.collection.immutable.Map[String,Any] = Map(name -> zoie, age -> 20)

scala> m1.get("age")
res112: Option[Any] = Some(20)

scala> m1("age")
res113: Any = 20

scala> m1("age")=30
<console>:14: error: value update is not a member of scala.collection.immutable.                                                                               Map[String,Any]
       m1("age")=30
       ^

scala> m1("id")
java.util.NoSuchElementException: key not found: id
  at scala.collection.MapLike$class.default(MapLike.scala:228)
  at scala.collection.AbstractMap.default(Map.scala:59)
  at scala.collection.MapLike$class.apply(MapLike.scala:141)
  at scala.collection.AbstractMap.apply(Map.scala:59)
  ... 32 elided

scala> m1.getOrElse("id",1)
res116: Any = 1

scala> m1
res117: scala.collection.immutable.Map[String,Any] = Map(name -> zoie, age -> 20                                                                               )

可变 Map

scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map

scala> val m3 = Map(("name","zoie"),("age",20))
m3: scala.collection.mutable.Map[String,Any] = Map(age -> 20, name -> zoie)

scala> m3("age")
res127: Any = 20

scala> m3("age")=18

scala> m3
res129: scala.collection.mutable.Map[String,Any] = Map(age -> 18, name -> zoie)

更新多个键值对
scala> m3 += ("name"->"amy","age"->20)
res159: m3.type = Map(age -> 20, name -> amy)


scala> m3 += ("id"->1)
res131: m3.type = Map(age -> 18, name -> zoie, id -> 1)

scala> m3 += (("city","shanghai"))
res132: m3.type = Map(city -> shanghai, age -> 18, name -> zoie, id -> 1)

scala> m3 -= ("city")
res133: m3.type = Map(age -> 18, name -> zoie, id -> 1)

scala> m3.remove("id")
res134: Option[Any] = Some(1)

scala> m3
res135: scala.collection.mutable.Map[String,Any] = Map(age -> 18, name -> zoie)

遍历Map

scala> m1
res145: scala.collection.immutable.Map[String,Any] = Map(name -> zoie, age -> 20)

scala> for(i <- m1.keys) println(i + "---" + m1(i))
name---zoie
age---20

scala> for(i <- m1.keySet) println(i + "---" + m1(i))
name---zoie
age---20

scala> for((x,y) <- m1) println(x + "---" + y)
name---zoie
age---20

scala> m1.foreach{case(x,y) => println(x + "---" + y)}
name---zoie
age---20

2. 元祖 Tuple

元组表示通过将不同的值用小括号括起来，是不同类型的值的聚集。可以装着多个不同类型的值。
对偶是最简单的元组（两个元素），映射是 K/V 对偶的集合。

创建元祖格式：val 元祖名称 = (元素1, 元素2,…)
定义元祖时用小括号将多个元素包起来，元素之间用逗号分隔，元素的类型可以不一样，元素个数可以任意多个

获取元祖中的值
格式：使用下划线加脚标，例如t1._2
注意：元组中的元素脚标是从 1 开始的
元祖中的值不能修改

元祖迭代
tuple.productIterator.foreach

对偶元祖

创建元祖

scala> val t1 = (12,"zoie",3.14,true)
t1: (Int, String, Double, Boolean) = (12,zoie,3.14,true)

Scala默认给了22个确定长度的元租对象
scala> val t2 = new Tuple
Tuple1    Tuple12   Tuple15   Tuple18   Tuple20   Tuple3   Tuple6   Tuple9
Tuple10   Tuple13   Tuple16   Tuple19   Tuple21   Tuple4   Tuple7
Tuple11   Tuple14   Tuple17   Tuple2    Tuple22   Tuple5   Tuple8

如果能确定元祖长度可以使用下面的定义
scala> val t2 = new Tuple4(12,"zoie",3.14,true)
t2: (Int, String, Double, Boolean) = (12,zoie,3.14,true)

获取元组中的值

scala> var t3 = (12,"zoie",3.14,true)
t3: (Int, String, Double, Boolean) = (12,zoie,3.14,true)

scala> t3._2
res85: String = zoie

scala> t3._2 = "hi"
<console>:13: error: reassignment to val
       t3._2 = "hi"
             ^

元祖迭代

tuple.productIterator 该方法返回一个迭代器

scala> t3
res95: (Int, String, Double, Boolean) = (12,zoie,3.14,true)

scala> t3.productIterator.foreach(i => print(i + " "))
12 zoie 3.14 true

scala> t3.productIterator.foreach(print(_ + " "))
<console>:14: error: missing parameter type for expanded function ((x$1) => x$1.$plus(" "))
       t3.productIterator.foreach(print(_ + " "))
                                        ^

scala> t3.productIterator.foreach(println(_))
12
zoie
3.14
true

对偶元祖
如果元祖只有两个元素，称之为对欧元组。
Map映射对应元祖的集合

scala> val aa = Array(("name","zoie"),("id",20))
aa: Array[(String, Any)] = Array((name,zoie), (id,20))

scala> val bb = aa.toMap
bb: scala.collection.immutable.Map[String,Any] = Map(name -> zoie, id -> 20)

scala> val cc = (("name","zoie"),("id",20))
cc: ((String, String), (String, Int)) = ((name,zoie),(id,20))

3. 列表 List

定义格式
- 不可变List
  val l1 = List(元素1，元素2)
- 可变listBuffer import scala.collection.mutable. ListBuffer
  val l2 = ListBufferInt
特殊符号
- head 返回集合的一个元素
- tail 返回的是除了第一个元素之外其他所有元素构成的集合
- Nil 表示的是一个空集合 List()
列表的操作
- 不可变List
       +: 在集合的头部添加元素
       .+:() 在集合的头部添加元素
       :: 在集合的头部添加元素
       :+ 在集合尾部添加元素
       .:+() 在集合尾部添加元素
- 可变listBuffer
       元素增加 += append
       元素删除 -= remove
       list1 ++ list2    list1尾部加list2返回新数组，list1不改变
       list1 ++= list2    list1尾部加list2赋给list1，list1改变
       list.toList      ListBuffer -> List
       list.toArray      ListBuffer -> Array

演示

不可变 List

scala> val l1 = List(4,5,6)
l1: List[Int] = List(4, 5, 6)

scala> l1.head
res188: Int = 4

scala> l1.tail
res189: List[Int] = List(5, 6)

scala> val l2 = List(7)
l2: List[Int] = List(7)

scala> l2.head
res190: Int = 7

scala> l2.tail
res191: List[Int] = List()

scala> val l3 = Nil
l3: scala.collection.immutable.Nil.type = List()

scala> l3.isEmpty
res192: Boolean = true

scala> 3 +: l1
res193: List[Int] = List(3, 4, 5, 6)

scala> l1
res194: List[Int] = List(4, 5, 6)

scala> l1.+:(3)
res195: List[Int] = List(3, 4, 5, 6)

scala> 3::l1
res196: List[Int] = List(3, 4, 5, 6)

scala> l1 :+ 7
res197: List[Int] = List(4, 5, 6, 7)

scala> l1.:+(7)
res198: List[Int] = List(4, 5, 6, 7)

scala> l1++l2
res199: List[Int] = List(4, 5, 6, 7)

scala> l2:::l1
res200: List[Int] = List(7, 4, 5, 6)

可变 List

scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer

scala> val l1 = ListBuffer[Int](4,5,6)
l1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(4, 5, 6)

scala> val l2 = new ListBuffer[Int]
l2: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

scala> l2 += 7
res201: l2.type = ListBuffer(7)

scala> l2.append(8)

scala> l2
res203: scala.collection.mutable.ListBuffer[Int] = ListBuffer(7, 8)

scala> l1 ++ l2
res204: scala.collection.mutable.ListBuffer[Int] = ListBuffer(4, 5, 6, 7, 8)

scala> l1
res205: scala.collection.mutable.ListBuffer[Int] = ListBuffer(4, 5, 6)

scala> l1 ++= l2
res206: l1.type = ListBuffer(4, 5, 6, 7, 8)

scala> l1
res207: scala.collection.mutable.ListBuffer[Int] = ListBuffer(4, 5, 6, 7, 8)

scala> l1 -= 4
res208: l1.type = ListBuffer(5, 6, 7, 8)

scala> l1.remove(2)
res209: Int = 7

scala> l1
res210: scala.collection.mutable.ListBuffer[Int] = ListBuffer(5, 6, 8)

scala> l1.toList
res211: List[Int] = List(5, 6, 8)


scala> l1
res212: scala.collection.mutable.ListBuffer[Int] = ListBuffer(5, 6, 8)

scala> l1.toArray
res213: Array[Int] = Array(5, 6, 8)

scala> l1
res214: scala.collection.mutable.ListBuffer[Int] = ListBuffer(5, 6, 8)

4. 集合Set

元素唯一且无序
Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。且Set是不保证插入顺序的，即Set中的元素是乱序的。默认情况下，是不可变集合。

定义格式：
     val s1 = Set(元素1，元素2)
特点：
     元素不重复（去重）元素无序（没有角标概念）
操作：
    s.size
    s.max
    s.min
    s + 元素
    s1 & s2 交集
    s1 ++ s2 并集
    s1 – s2 差集
    s1 &~ s2 差集
    s1.diff(s2) 差集
    s.slice(角标1,角标2) 取子set，角标从0开始，包头不包尾
    s.count(条件)
    s.subsets.foreach(…) 迭代所有的子set
    s2.subsets(n).foreach(…) 迭代所有的子set，取指定的个数组合

可变Set：
导包 import scala.collection.mutable.Set
     += add
     -= remove 注意remove是通过元素移除的
     ++
     ++=

遍历：
for(i <- s2) print(i + " ")

演示：

不可变 Set

scala> val s1 = Set(1,2,3,5,3,5,2,4)
s1: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

scala> s1.size
res215: Int = 5

scala> s1.max
res216: Int = 5

scala> s1.min
res217: Int = 1

scala> s1 + 6
res218: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

scala> s1
res219: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

scala> val s2 = Set(1,2,3,4)
s2: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

scala> val s3 = Set(3,4,5,6)
s3: scala.collection.immutable.Set[Int] = Set(3, 4, 5, 6)

scala> s2 & s3
res220: scala.collection.immutable.Set[Int] = Set(3, 4)

scala> s2 ++ s3
res221: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

scala> s2 -- s3
res222: scala.collection.immutable.Set[Int] = Set(1, 2)

scala> s2.diff(s3)
res223: scala.collection.immutable.Set[Int] = Set(1, 2)

scala> s3.diff(s2)
res224: scala.collection.immutable.Set[Int] = Set(5, 6)

scala> s2 &~ s3
res225: scala.collection.immutable.Set[Int] = Set(1, 2)

scala> s2.count(_>1)
res227: Int = 3

scala> s2
res228: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

scala> s2.slice(1,3)
res229: scala.collection.immutable.Set[Int] = Set(2, 3)

scala> for(i <- s2) print(i + " ")
1 2 3 4
scala> s2.subsets.foreach(println(_))
Set()
Set(1)
Set(2)
Set(3)
Set(4)
Set(1, 2)
Set(1, 3)
Set(1, 4)
Set(2, 3)
Set(2, 4)
Set(3, 4)
Set(1, 2, 3)
Set(1, 2, 4)
Set(1, 3, 4)
Set(2, 3, 4)
Set(1, 2, 3, 4)

scala> s2.subsets(2).foreach(println(_))
Set(1, 2)
Set(1, 3)
Set(1, 4)
Set(2, 3)
Set(2, 4)
Set(3, 4)

可变 Set

scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set

scala> val s1 = Set(1,2,3)
s1: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

scala> s1 += 4
res233: s1.type = Set(1, 2, 3, 4)

scala> s1.add(5)
res235: Boolean = true

scala> s1
res236: scala.collection.mutable.Set[Int] = Set(1, 5, 2, 3, 4)

scala> s1 -= 1
res237: s1.type = Set(5, 2, 3, 4)

scala> s1.remove(1)
res238: Boolean = false

scala> s1.remove(2)
res239: Boolean = true

scala> s1
res240: scala.collection.mutable.Set[Int] = Set(5, 3, 4)

scala> s1 ++ Set(1,2,3)
res241: scala.collection.mutable.Set[Int] = Set(1, 5, 2, 3, 4)

scala> s1
res243: scala.collection.mutable.Set[Int] = Set(5, 3, 4)

scala> s1 ++= Set(1,2,3)
res244: s1.type = Set(1, 5, 2, 3, 4)