Scala 集合 (十一)

最新推荐文章于 2022-02-12 13:15:05 发布

夏夏夏果

最新推荐文章于 2022-02-12 13:15:05 发布

阅读量176

点赞数

文章标签： scala

本文链接：https://blog.csdn.net/qq_41797886/article/details/103931115

版权

Scala 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Scala 集合

元祖类型

Tuple：可以存放任意类型的特殊类型，类似于ArrayList<Object>

内置：Tuple1~Tuple22

使用Tuple2模拟K\V键值对

创建元组

# 创建2个元素元组
scala> val t2 = ("zs",18)
t2: (String, Int) = (zs,18)

scala> t2.getClass
res0: Class[_ <: (String, Int)] = class scala.Tuple2

# 创建4个元组元组
scala> val t4 = ("zs",18,true,10.0)
t4: (String, Int, Boolean, Double) = (zs,18,true,10.0)

scala> t4.getClass
res1: Class[_ <: (String, Int, Boolean, Double)] = class scala.Tuple4

使用元组

scala> t4._1
res2: String = zs

scala> t4._2
res3: Int = 18

scala> t4._3
res4: Boolean = true

scala> t4._4
res5: Double = 10.0
// 类似多维数组
scala> val t2 =(1,("zs",true,("bj","朝阳")))
t2: (Int, (String, Boolean, (String, String))) = (1,(zs,true,(bj,朝阳)))

scala> t2.getClass
res6: Class[_ <: (Int, (String, Boolean, (String, String)))] = class scala.Tuple2

scala> t2._1
res7: Int = 1

scala> t2._2._1
res8: String = zs

scala> t2._2._2
res9: Boolean = true
// 取出元组中的元组中的数据
scala> t2._2._3._1
res10: String = bj

scala> t2._2._3._2
res11: String = 朝阳

元组的遍历

val t2 = (1, ("zs", true, ("bj", "朝阳")))
val iterator = t2.productIterator
while (iterator.hasNext) {
    println(iterator.next())
}

集合

Scala提供了一套很好的集合实现,提供了一些集合类型的抽象。

Scala 集合分为可变的和不可变的集合：

可变集合(mutable) 可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。
不可变集合（默认 immutable）类永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。

集合中基本结构：
在这里插入图片描述

Seq （序列集合）

Range

数值区间范围对象，不可变集合

scala> 1 until 10
res14: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> 1 to 10 by 3
res15: scala.collection.immutable.Range = Range(1, 4, 7, 10)

scala> new Range(1,9,2)  // 等价于 1 until 9 by 2

Vector

向量集合，树形结构实现，效率高不可变集合

scala> Vector(1,2,3,4)
res21: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4)

scala> Vector[String]("a","b","c")
res22: scala.collection.immutable.Vector[String] = Vector(a, b, c)

// 遍历后返回一个新的集合
scala> val v1 = for(n <- 1 to 9) yield n*2
v1: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10, 12, 14,16, 18)

List

列表集合，元素有下标、可重复、有序；不可变集合


// 声明
scala> List(1,2,3,4,5)
res23: List[Int] = List(1, 2, 3, 4, 5)

// 获取元素
scala> res23(2)
res24: Int = 3

// 不可变集合 不允许修改元素
scala> res23(2) = 10
<console>:13: error: value update is not a member of List[Int]
       res23(2) = 10
       ^

// 不可变集合的模拟添加元素
// :+ 元素 在集合的末尾添加元素
scala> res0 :+ 6
res2: List[Int] = List(1, 2, 3, 4, 5, 6)

scala> res0.:+(7)
res6: List[Int] = List(1, 2, 3, 4, 5, 7)

// +: 元素 在集合的头添加元素
scala> 0 +: res0
res8: List[Int] = List(0, 1, 2, 3, 4, 5)

// drop  == dropLeft 删除前N个元素
scala> res0.drop(3)
res2: List[Int] = List(4, 5)

Nil

关键字，空集合等价于List()

scala> val l1 = Nil
l1: scala.collection.immutable.Nil.type = List()
// 从右向左添加
scala> 3::2::1::l1
res148: List[Int] = List(3, 2, 1)

`::` 和 `:::`

:: 如：A :: List 将A作为整体添加到List集合的头部

:：: 如：A ::： List 将A中的各个元素添加到List集合的头部

scala> 1 :: Nil
res0: List[Int] = List(1)

scala> Nil
res1: scala.collection.immutable.Nil.type = List()
// 从右向左添加
scala> 1 :: 2 :: 3:: Nil
res2: List[Int] = List(1, 2, 3)

scala> List(1,2,3) :: 4 :: 5 :: Nil
res3: List[Any] = List(List(1, 2, 3), 4, 5)

scala> List(1,2,3) ::: 4:: 5::Nil
res4: List[Int] = List(1, 2, 3, 4, 5)

ListBuffer

可变列表：List列表集合的可变形式；

scala.collection.mutable.ListBuffer

# 声明
scala> scala.collection.mutable.ListBuffer(1,2,3,4,5)
res11: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 5)

# 获取元素
scala> res11(2)
res12: Int = 3

# 修改元素内容
scala> res11(2) = 12

scala> res11
res14: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 12, 4, 5)

# 添加元素
scala> res11 += 6
res15: res11.type = ListBuffer(1, 2, 12, 4, 5, 6)

# 移除元素
scala> res11
res24: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 4, 5, 6)

# 删除元素
scala> res11 -= 4
res25: res11.type = ListBuffer(1, 5, 6)

scala> res11 == res25
res26: Boolean = true

scala> res11
res27: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 5, 6)

# 删除元素 新建集合
scala> res11 - 6
res28: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 5)

scala> res11
res29: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 5, 6)

# 添加元素到集合的头部
scala> -4 +=: res34
res37: res34.type = ListBuffer(-4, 1, 5, 6, 7, 8, 9, -1, -2, -3)

scala> res34
res38: scala.collection.mutable.ListBuffer[Int] = ListBuffer(-4, 1, 5, 6, 7, 8,
9, -1, -2, -3)

n注意：

操作符中不包含=号，通常会返回新集合
操作符中包含=号，通常是在原集合上的操作

遍历

.foreach
for循环
do...while
while

Set

特点：无序、无下标、不可重复

set 不可变

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

# 添加元素 返回新集合
scala> res41 + 5
res42: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

scala> res41 == res42
res43: Boolean = false

# 移除元素 返回新集合
scala> res41 - 3
res44: scala.collection.immutable.Set[Int] = Set(1, 2, 4)

Set（可变集合）

# 声明
scala> scala.collection.mutable.Set[Int](1,2,2,3,4,4)
res45: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

# 添加元素
scala> res45 += 5
res46: res45.type = Set(1, 5, 2, 3, 4)

scala> res46 == res45
res47: Boolean = true

# 移除元素
scala> res45 -= 3
res48: res45.type = Set(1, 5, 2, 4)

# 交集
scala> res48 & res49
res50: scala.collection.mutable.Set[Int] = Set(1, 2, 4)

# 并集
scala> res48 | res49
res51: scala.collection.mutable.Set[Int] = Set(1, 5, 2, 6, 3, 4)

# 差集
scala> res48 &~ res49
res52: scala.collection.mutable.Set[Int] = Set(5)

# 差集
scala> res49 &~ res48
res53: scala.collection.mutable.Set[Int] = Set(6, 3)

Map集合

K V 对

# 声明（可变）
scala> scala.collection.mutable.Map("k1" -> "v1","k2" -> "v2")
res56: scala.collection.mutable.Map[String,String] = Map(k2 -> v2, k1 -> v1)

scala> scala.collection.mutable.Map(("k1","v1"),("k2","v2"))
res57: scala.collection.mutable.Map[String,String] = Map(k2 -> v2, k1 -> v1)

# 声明（不可变）
scala> Map("k1"->"v1","k2"->"v2")
res58: scala.collection.immutable.Map[String,String] = Map(k1 -> v1, k2 -> v2)

scala> Map(("k1","v1"),("k2","v2"))
res59: scala.collection.immutable.Map[String,String] = Map(k1 -> v1, k2 -> v2)

# 操作
# 获取指定K的V
scala> res56("k1")
res60: String = v1

# 修改指定K的V
scala> res56("k1") = "vv1"

scala> res56
res62: scala.collection.mutable.Map[String,String] = Map(k2 -> v2, k1 -> vv1)

# 添加KV[可变]
scala> res56 +=(("k3","v3"))
res63: res56.type = Map(k2 -> v2, k1 -> vv1, k3 -> v3)

scala> res56 +=("k4" -> "v4")
res64: res56.type = Map(k2 -> v2, k4 -> v4, k1 -> vv1, k3 -> v3)

# 添加KV【不可变】
scala> res59 + ("k4" -> "v4")
res65: scala.collection.immutable.Map[String,String] = Map(k1 -> v1, k2 -> v2, k4 -> v4)

# 移除KV
scala> res56 -= ("k2")
res67: res56.type = Map(k4 -> v4, k1 -> vv1, k3 -> v3)

Map遍历

package array

import scala.collection.mutable

object MapTest extends App {

  private val hashmap: mutable.HashMap[String,Int] = mutable.HashMap("ks"->1)

  hashmap += ("k1"-> 2)

  // HashMap遍历一
  hashmap.foreach(t2 => println((t2._1,t2._2)))

  // HashMap遍历二
  private val set: Set[(String, Int)] = hashmap.toSet
  set.foreach(t2 => println((t2._1,t2._2)))




  val map: mutable.Map[String, String] = scala.collection.mutable.Map(("k1","v1"),("k2","v2"),("k3","v3"))

  // 遍历1
  /*private val set: collection.Set[String] = map.keySet
  set.foreach(n => println(n + "\t" + map(n)))*/

  // set.foreach(println(map(_))) // error

//遍历2
// map.foreach(t2 => println(t2._1 + "\t" + t2._2))

  // 遍历3
  /*private val values: Iterable[String] = map.values

  private val keys: Iterable[String] = map.keys

  for(n <- values) println(n)
  for(n <- keys) println(n)*/

  map += (("k4","v4"))


  // 遍历4
  private val set1: Set[(String, String)] = map.toSet

  set1.foreach(t2 => println(t2._1 + "\t" + t2._2))
}

夏夏夏果

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Scala 集合 (十一)

Scala 集合元祖类型Tuple：可以存放任意类型的特殊类型，类似于ArrayList<Object>内置：Tuple1~Tuple22使用Tuple2模拟K\V键值对创建元组# 创建2个元素元组scala> val t2 = ("zs",18)t2: (String, Int) = (zs,18)scala> t2.getClassres0:...
复制链接

扫一扫