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

映射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,...)

操作实例

//创建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,...)

操作实例

//导包

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.元素无序，也即没有了索引的概念