Scala--第三天

Posted 2021-03-11 cmxbky1314

一、列表

　　定义：是Scala中一种重要的容器

　　特点：1.可以存储同类型的重复数据

　　　　　2.是有序的（可以进行索引操作，有先来后到之分）

　　分类：1.不可变列表：内容与长度均不可变

　　　　　 2.可变列表：内容元素与长度均可变

　　1.不可变列表

　　定义：

 1     //第一种方式：List关键字 常用
 2     var l1 = List(1, 2, 3, 4)
 3     println(l1)
 4     //    List(1, 2, 3, 4)
 5     //创建一个空列表
 6     var l2 = Nil
 7     println(l2)
 8     //    List()
 9     //第二种方式： :: 符号 不常用
10     var l3 = 1 :: 2 :: Nil
11     println(l3)
12     //    List(1, 2)

　　2.可变列表

　　定义：需要先导入 ListBuffer

　import scala.collection.mutable.{ArrayBuffer, ListBuffer}

 1     // 定义带有初始化的可变列表
 2     var a = ListBuffer(1, 2, 3)
 3     println(a)
 4     //    ListBuffer(1, 2, 3)
 5     //定义一个空的可变列表
 6     var b = ListBuffer[Int]()
 7     println(b)
 8     //    ListBuffer()
 9 
10     //使用 += 进行添加操作
11     b += 1
12     b += 2
13     println(b)
14     //ListBuffer(1, 2)

　　列表的常见操作

　　1.查看列表的长度与元素

 1     var a = List(1, 2, 3)
 2     var b = ListBuffer(2, 3, 4)
 3     //查看列表的长度
 4     println(a.length)
 5     println(b.length)
 6     //结果
 7     //3
 8     //3
 9     //查看列表元素
10     println(a(0))
11     println(b(0))
12     //结果
13     //1
14     //2

　　2.列表的添加与删除 ###注意 ：只有可变的列表才有这些操作

 1     var a = List(1, 2, 3)
 2     var b = ListBuffer(2, 3, 4)
 3     //在可变列表后追加一个元素
 4     b += 5
 5     println(b)
 6     //结果
 7     //ListBuffer(2, 3, 4, 5)
 8     
 9     //在可变列表后，追加一个列表
10     b ++= a
11     println(b)
12     //结果
13     //ListBuffer(2, 3, 4, 5, 1, 2, 3)
14 
15     //可变列表删除指定的元素
16     b -= 2
17     println(b)
18     //结果  从结果看出来  删除的是第一个符合条件的元素
19     //ListBuffer(3, 4, 5, 1, 2, 3)

　　3.可变列表转为不可变列表，列表为空的判断

 1     var a = List(1, 2, 3)
 2     var b = ListBuffer(2, 3, 4)
 3 
 4     //可变列表转换成不可变列表
 5     var c = b.toList
 6     println(c)
 7     //结果
 8     //List(2, 3, 4)
 9 
10     //判断列表是否为空
11     println(c.isEmpty)
12     //结果
13     //false

　　4.列表的拼接

 1 //俩个不可变列表进行拼接，产生新的不可变列表，源列表保持不变
 2     var a = List(1, 2, 3)
 3     var b = List(4, 5)
 4     var c = a ++ b
 5     println(c)
 6     println(a)
 7     println(b)
 8     //结果
 9     //List(1, 2, 3, 4, 5)
10     //List(1, 2, 3)
11     //List(4, 5)
12 
13     //俩个可变的列表进行拼接 产生了一个新的可变列表，源列表保持不变
14     var d = ListBuffer(1, 2, 3)
15     var e = ListBuffer(4, 5)
16     var f = d ++ e
17     println(f)
18     println(d)
19     println(e)
20     //结果
21     //ListBuffer(1, 2, 3, 4, 5)
22     //ListBuffer(1, 2, 3)
23     //ListBuffer(4, 5)
24 
25     //一个不可变 和一个可变列表进行拼接
26     var x = List(1, 2, 3)
27     var y = ListBuffer(4, 5, 6)
28     var z1 = x ++ y
29     var z2 = y ++ x
30     println(z1)
31     println(z2)
32     //结果 最后的类型 由 拼接前者的类型决定
33     //List(1, 2, 3, 4, 5, 6)
34     //ListBuffer(4, 5, 6, 1, 2, 3)

　　5.其他常用操作

 1      var a = List(1,2,3,4)
 2 
 3       //取列表头和尾
 4       println(a.head)
 5       println(a.tail)
 6       //结果
 7       //1
 8       //List(2, 3, 4)
 9      
10      //前缀，后缀 返回的依旧是列表
11      println(a.take(3))
12      println(a.drop(3))
13      //结果
14      //List(1, 2, 3)
15      //List(4)　　　

　　6.扁平化/压平处理 （降维）

1     var a = List(List(1, 2, 3), List(4, 5))
2     var b= a.flatten
3     println(b)
4     //List(1, 2, 3, 4, 5)

　　7.拉链，拉开

 1     var a = List("ss", "vv")
 2     var b = List(1, 2)
 3     var c = a.zip(b)
 4     println(c)
 5     //结果 打包成一个由元组组成的列表
 6     //List((ss,1), (vv,2))
 7 
 8     //访问列表c的第一个元素的子元素
 9     println(c(0)._1)
10     //结果
11     //ss
12 
13     //解包
14     var d =c.unzip
15     println(d)
16     //结果  解包成一个由列表组成的元组
17     //(List(ss, vv),List(1, 2))

　　8.列表转字符串，拼接字符串（类似python中的join）

 1     //列表转字符串
 2     var a = List(1, 2, 3)
 3     println(a.toString)
 4     println(a.toString.getClass)
 5     //结果
 6     //List(1, 2, 3)
 7     //class java.lang.String
 8     
 9     //列表拼接字符串
10     var b = a.mkString("-")
11     println(b)
12     //结果
13     //1-2-3

　　9.并集，交集，差集

 1     var a = List(1, 2, 3, 4)
 2     var b = List(3, 4, 5, 6)
 3     
 4     //并集
 5     var c = a.union(b)
 6     println(c)
 7     //List(1, 2, 3, 4, 3, 4, 5, 6)
 8     
 9     //交集
10     var d = a.intersect(b)
11     println(d)
12     //List(3, 4)
13     
14     //差集
15     var e = a diff b
16     println(e)
17     //List(1, 2)

二、集合

　　特性：

　　　　1.元素不重复

　　　　2.无序

　　分类：

　　　　1.不可变集合

　　　　2.可变集合

　　注意：无论是不可变集合还是可变集合，都符合 集合俩个特性

　　1.不可变集合

　　　　定义

 1     //方式一：简单常用，会自动去重
 2     var s1 = Set(1, 2, 3, 4, 4)
 3     println(s1)
 4     //Set(1, 2, 3, 4)
 5     
 6     //方式二：注意()里面的是元素，而非集合的个数
 7     var s2 = Set[Int](1, 2)
 8     println(s2)
 9     //Set(1, 2)
10     
11     //空集合
12     var s3 = Set()
13     print(s3)
14     //Set()

　　　　基本操作

 1     var s1 = Set(1, 2, 3, 4)
 2     //查看集合的长度
 3     println(s1.size)
 4     //4
 5 
 6     //遍历集合
 7     for (i <- s1) println(i)
 8     //1
 9     //2
10     //3
11     //4
12 
13     //删除集合的指定元素，原集合不变，生成一个新的集合
14     var s2 = s1 - 1
15     println(s1)
16     //Set(1, 2, 3, 4)
17     println(s2)
18     //Set(2, 3, 4)
19 
20     //拼接 注意：保证俩个集合的类型相同
21     var s3 = s1 ++ s2
22     println(s3)
23     //Set(1, 2, 3, 4)
24 
25     //集合和列表拼接，但是不能和元组拼接,因为元组不可变
26     println(s1 ++ List(5, 6))
27     //Set(5, 1, 6, 2, 3, 4)
28 
29     //集合 转list  无序变有序
30     println(s1.toList)
31     //List(1, 2, 3, 4)

　　2.可变集合

 1     //方式一：()里面的是元素
 2     var s1 = Set[Int](1, 2)
 3     println(s1)
 4     //Set(1, 2)
 5     //添加元素
 6     s1 += 3
 7     println(s1)
 8     //Set(1, 2, 3)
 9     //方式二：常用
10     var s2 = Set(1, 2, 4, 5)
11     println(s2)
12     //Set(1, 5, 2, 4)

　　基本操作

 1     var s = Set(1, 2, 3, 4)
 2     s += 5
 3     println(s)
 4     s -= 1
 5     println(s)
 6     s ++= Set(6)
 7     println(s)
 8     //Set(1, 5, 2, 3, 4)
 9     //Set(5, 2, 3, 4)
10     //Set(5, 2, 6, 3, 4)

三、映射Map

　　分类：不可变映射；可变映射

　　1.不可变映射

　　　　定义：

1     //方式一
2     var m1 = Map("k1" -> 1, "k2" -> 2)
3     println(m1)
4     //Map(k1 -> 1, k2 -> 2)
5 
6     //方式二
7     var m2 = Map(("k1", "1"), ("k2", "2"))
8     println(m2)
9     //Map(k1 -> 1, k2 -> 2)

　　2.可变映射

　　　　定义方式与不可变相同，唯一的区别在于关键字需要导入

　　　　import scala.collection.mutable.Map

　　3.Map常规操作

 1     var m1 = Map(("k1", 1), ("k2", 2))
 2     //取值
 3     println(m1("k1"))
 4     //1
 5 
 6     //获取全部的key值 返回一个迭代器
 7     var a = m1.keys
 8     println(a)
 9     for (i <- a) println(i)
10     //Set(k1, k2)
11     //k1
12     //k2
13 
14     //获取全部的value值，返回一个迭代器
15     var b = m1.values
16     println(b)
17     //MapLike(1, 2)
18 
19     //遍历映射
20     for ((k, v) <- m1) {
21       println(s"${k}:${v}")
22     }
23     //k1:1
24     //k2:2
25 
26     //取值 没有的话给一个默认值
27     println(m1.getOrElse("k4", 4))
28     //4