【Scala】关于集合的各种知识点

目录

• 映射Map
• 不可变Map
• 概述
• 操作实例
• 可变Map
• 概述
• 操作实例
• Map的遍历
• for循环遍历
• 格式
• 操作实例
• 模式匹配遍历
• 格式
• 操作实例
• Tuple 元祖
• 概述
• 定义格式
• 获取元素方法
• 元祖遍历
• 操作实例
• List 列表
• 不可变List
• 概述
• 相关方法
• 相关操作
• 操作实例
• 可变List
• 概述
• 相关方法
• 相关操作
• 操作实例
• Set 集合
• 格式
• 特点
• 相关操作
• 操作实例

---

映射Map

Map可以分为可变Map和不可变Map，默认情况是不可变Map。两者之间的定义格式完全相同，区别在于导包
 

不可变Map

概述

有两种定义格式：
1.val m1 = Map(k1 -> v1,k2 -> v2,k3 -> v3)
2.val m2 = Map((k1 , v1),(k2 , v2),(k3 , v3))

可以进行的操作：
1.获取值 —— m1(k1) = v1 m1.get(k1) = v1 m1.getOrElse(k1,默认值) (最后一种比较推荐，如果查询的key有value，就输出value，如果没有，则输出给定的默认值)
2.查看指定的key是否存在 —— m1.key(k1) 输出结果为布尔类型，存在则为true，不存在则为false
3.查看Map集合中所有的key —— m1.keys

操作实例

//两种定义格式
scala> val m1 = Map("name" -> "zhangsan","age" -> 20,"sex" -> "女")
m1: scala.collection.immutable.Map[String,Any] = Map(name -> zhangsan, age -> 20, sex -> 女)

scala> val m2 = Map(("name","haha"),("age",18),("sex","男"))
m2: scala.collection.immutable.Map[String,Any] = Map(name -> haha, age -> 18, sex -> 男)

//value查询
scala> m1("name")
res9: Any = zhangsan

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

scala> m1.getOrElse("sex","男")
res12: Any = 女

//key查询
scala> m1.keySet("name")
res13: Boolean = true

scala> m1.keySet("height")
res15: Boolean = false

scala> m1.keys
res18: Iterable[String] = Set(name, age, sex)

可变Map

概述

首先要手动导包 —— import scala.collection.mutable.Map
剩下定义格式和查看操作与不可变Map一样

多于可变Map的操作：
修改value —— m1(k1) = 新的value
增加元素 —— m1 += (k3 -> v3) m1 += ((k3 , v3)) (和定义格式一样有两种)
删除元素 —— m1 -= (k1) m1.remove(k1)

操作实例

scala> val m2 = Map(("name","haha"),("age",18),("sex","男"))
m2: scala.collection.mutable.Map[String,Any] = Map(age -> 18, name -> haha, sex -> 男)

//修改value
scala> m2("name")="alias"

scala> m2("name")
res24: Any = alias

//增加元素
scala> m2 += ("height" -> 180.5)
res25: m2.type = Map(age -> 18, name -> alias, height -> 180.5, sex -> 男)

scala> m2 += (("city","beijing"))
res26: m2.type = Map(city -> beijing, age -> 18, name -> alias, height -> 180.5, sex -> 男)

//删除元素
scala> m2 -= ("height")
res27: m2.type = Map(city -> beijing, age -> 18, name -> alias, sex -> 男)

scala> m2.remove("city")
res28: Option[Any] = Some(beijing)

Map的遍历

遍历方法有两种：for循环遍历、模式匹配遍历
 

for循环遍历

格式

for(i <- m1.keys) println (m1(i))

操作实例

scala> for(i <- m1.keys) println(m1(i))
zhangsan
20
女

模式匹配遍历

格式

for((x,y) <- m1) println(x+"——"+y)

操作实例

scala> for((x,y) <- m1) println(x+"——"+y)
name——zhangsan
age——20
sex——女

---

Tuple 元祖

概述

由()括起来的，不同类型数据的聚集称为元祖。
当元祖中只有两个元素时，就和Map极其相似，称为对偶元祖。
元祖中的元素值无法修改。

定义格式

//第一种格式
val t1 = (元素1,元素2,元素3,...)

//第二种格式
scala内置了22个TupleN对象，需要时可以直接new Tuple来创建元祖
scala> val t2 = new Tuple
Tuple1   Tuple10   Tuple11   Tuple12   Tuple13   Tuple14   Tuple15   Tuple16   Tuple17   Tuple18   Tuple19
Tuple2   Tuple20   Tuple21   Tuple22   Tuple3   Tuple4   Tuple5   Tuple6   Tuple7   Tuple8   Tuple9

val t2 = new Tuple3(元素1,元素2,元素3)


//显而易见，第一种格式更为简便，一般情况下都是用第一种格式

获取元素方法

scala> t1._
_1   _2   _3   _4

想要获取元素时，用_1,_2,_3,...即可

元祖遍历

t1.productIterator()	//该方法会返回一个迭代器
t1.producrIterator.foreach(println(_))		//遍历格式

操作实例

//创建元祖
scala> val t1 = (123,"hello",true,3.14)
t1: (Int, String, Boolean, Double) = (123,hello,true,3.14)

scala> val t2 = new Tuple4(456,"AMDyes","false",7.777)
t2: (Int, String, String, Double) = (456,AMDyes,false,7.777)

//获取元素
scala> t1._2
res32: String = hello

scala> t2._2
res33: String = AMDyes

//元祖遍历（看着是两种形式，其实是一种方法，第一种更简便）
scala> t1.productIterator.foreach(println(_))
123
hello
true
3.14

scala> t2.productIterator.foreach(i => println(i))
456
AMDyes
false
7.777

---

List 列表

List分为可变List和不可变List，默认情况是不可变List，区别不仅仅在于导包。
 

不可变List

概述

格式 —— val l1 = List(元素1,元素2,...)

相关方法

l1.head —— 返回集合的第一个元素
l1.tail —— 返回除了第一个元素外，其他元素组成的集合
val l1 = Nil —— Nil表示的是一个空集合，List()

相关操作

10 +: l1 —— 在集合头部添加元素
10 :: l1 —— 在集合头部添加元素
l1 :+ 10 —— 在集合尾部添加元素

操作实例

//创建List
scala> val l1 = List(12,34,56,78)
l1: List[Int] = List(12, 34, 56, 78)

//返回集合第一个元素
scala> l1.head
res38: Int = 12

//返回集合除了第一个元素的其他元素组成的集合
scala> l1.tail
res40: List[Int] = List(34, 56, 78)

//在集合头部添加元素
scala> 10 +: l1
res41: List[Int] = List(10, 12, 34, 56, 78)
//相当于l1调用了+:方法，10是参数
scala> l1.+:(10)
res42: List[Int] = List(10, 12, 34, 56, 78)
//因为l1为不可变List，所以+:的操作并没有修改l1，而是形成了一个新的集合
scala> l1
res43: List[Int] = List(12, 34, 56, 78)

scala> val l2 = 10 +: l1
l2: List[Int] = List(10, 12, 34, 56, 78)

scala> l2
res44: List[Int] = List(10, 12, 34, 56, 78)

//同样是在头部添加一个元素，和+:一样
scala> 10 :: l1
res45: List[Int] = List(10, 12, 34, 56, 78)

//在尾部添加一个元素
scala> l1 :+ 10
res46: List[Int] = List(12, 34, 56, 78, 10)

可变List

概述

第一步要先导包：import scala.collection.mutable.ListBuffer
格式 —— val l2 = ListBuffer[元素类型](元素1,元素2,...)

相关方法

和不可变List相同

相关操作

上述不可变List的操作同样可以使用在可变List
l2.append(元素值) —— 增加元素
l2 += 元素值 —— 增加元素
l2.remove(元素索引) —— 删除元素
l2 -= 元素值 —— 删除元素

操作实例

//导包
scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
//创建可变List
scala> val l2 = ListBuffer[Int](11,22,33,44)
l2: scala.collection.mutable.ListBuffer[Int] = ListBuffer(11, 22, 33, 44)

//增加元素
scala> l2 += 10
res51: l2.type = ListBuffer(11, 22, 33, 44, 10)

scala> l2.append(20)
//因为是可变List，所以增加元素的操作是改变了l2的元素值
scala> l2
res53: scala.collection.mutable.ListBuffer[Int] = ListBuffer(11, 22, 33, 44, 10, 20)

//删除元素
scala> l2 -= 20
res54: l2.type = ListBuffer(11, 22, 33, 44, 10)

scala> l2.remove(4)
res55: Int = 10

scala> l2
res56: scala.collection.mutable.ListBuffer[Int] = ListBuffer(11, 22, 33, 44)

---

Set 集合

Set集合也分为可变Set和不可变Set，默认为不可变Set，创建使用可变Set要导包
可变Set和不可变Set的格式、特点都相同，差别只在于可变与否
 

格式

val s1 = Set(元素1,元素2,...)

特点

1.元素不重复，即使创建时输入相同的元素，scala也会进行一个去重的操作
2.元素无序，也即没有了索引的概念

相关操作

只对可变Set可用：
增加元素 —— s1 += 元素值 s1.add(元素值)
删除元素 —— s1 -= 元素值 s1.remove(元素值)（因为Set没有索引，所以此处的remove方法和其他集合不同，只能填入元素值）

操作实例

//既体现了元素的不重复特点，又体现了元素的无序性
scala> val s1 = Set(1,1,2,2,4,4,6,6,6,7)
s1: scala.collection.immutable.Set[Int] = Set(1, 6, 2, 7, 4)

//是集合，所以查看集合长度，求和，求最大最小值的方法都可以
scala> s1.size
res57: Int = 5

scala> s1.sum
res58: Int = 20

scala> s1.min
res59: Int = 1

/**
 *两个集合求交集、并集、差集
 **/
//两个Set集合如下
scala> s1
res60: scala.collection.immutable.Set[Int] = Set(1, 6, 2, 7, 4)

scala> s2
res61: scala.collection.immutable.Set[Int] = Set(2, 7, 3, 8, 4)
//交集
scala> s1.&(s2)
res62: scala.collection.immutable.Set[Int] = Set(2, 7, 4)

scala> s1 & s2
res63: scala.collection.immutable.Set[Int] = Set(2, 7, 4)
//并集
scala> s1.++(s2)
res67: scala.collection.immutable.Set[Int] = Set(1, 6, 2, 7, 3, 8, 4)

scala> s1 ++ s2
res65: scala.collection.immutable.Set[Int] = Set(1, 6, 2, 7, 3, 8, 4)
//差集
scala> s1.--(s2)
res68: scala.collection.immutable.Set[Int] = Set(1, 6)

scala> s1 -- s2
res69: scala.collection.immutable.Set[Int] = Set(1, 6)

scala> s2 -- s1
res70: scala.collection.immutable.Set[Int] = Set(3, 8)

scala> s2.diff(s1)
res71: scala.collection.immutable.Set[Int] = Set(3, 8)