码迷,mamicode.com
首页 > 其他好文 > 详细

Scala--第三天

时间:2020-02-06 16:21:40      阅读:59      评论:0      收藏:0      [点我收藏+]

标签:去重   常用操作   添加   rop   常用   str   判断   常见   zip   

一、列表

  定义:是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

 

 

 

 

  

 

Scala--第三天

标签:去重   常用操作   添加   rop   常用   str   判断   常见   zip   

原文地址:https://www.cnblogs.com/cmxbky1314/p/12268472.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!