Scala编程小记02

最新推荐文章于 2020-01-16 18:16:17 发布

转载最新推荐文章于 2020-01-16 18:16:17 发布 · 164 阅读

scala小记专栏收录该内容

3 篇文章

订阅专栏

构建映射

1 val map=Map(键->值,键->值,键->值,,,)

2 利用元组构建 val map=Map((键,值),(键,值),(键,值),,,)

val map1=Map("tom"->90,"jerry"->99,"doggy"->80)
println(map1("tom"))
//元组
val map2=Map(("tom",90),("jerry",99),("doggy",80))
println(map2("tom"))

scala中的Map有imutable,mutable两种即可变和不可变。

默认是不可变的，导入,import scala.collection.mutable.Map之后

可以改变。

val map1=Map("tom"->98,"jerry"->99)
    map1("tom")=99
    println(map1)

元组是scala中重要的一个概念。

元组是不同类型的值的聚集；对偶是最简单的元组。
元组表示通过将不同的值用小括号括起来，即表示元组。

元组使用._数字获取元素

元组的下标从1开始

val tuple=("hello",123,3.14)
println(tuple._1)  //hello

将对偶集合转变成元组

toMap

    val score=Array(88,99,90)
    val name=Array("tom","jerry","bob")
    val newname=name.zip(score)
    for(i<-(0 until name.length)){
      println(newname(i))
    }
  }

注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的
元素个数.

集合

Scala 的集合有三大类：序列 Seq、Set、映射 Map，所有的集合都扩展自 Iterable
特质，在 Scala 中集合有可变（mutable）和不可变（immutable）两种类型，immutable
类型的集合初始化后就不能改变了（注意与 val 修饰的变量进行区别）。

//创建个不可变的集合
val lst1 = List(1,2,3)
//补充：另一种定义 list 方法
val other_lst=2::Nil
//获取集合的第一个元素
val first=lst1.head
//获取集合中除第一个元素外的其他元素集合,
val tail=lst1.tail
//补充：其中如果 List 中只有一个元素，那么它的 head 就是这个元素，它的 tail 就是 Nil；
println(other_lst.head+"----"+other_lst.tail)
//将 0 插入到 lst1 的前面生成一个新的 List
val lst2 = 0 :: lst1
val lst3 = lst1.::(0)
val lst4 = 0 +: lst1
val lst5 = lst1.+:(0)
/将一个元素添加到 lst1 的后面产生一个新的集合
val lst6 = lst1 :+ 3
val lst0 = List(4,5,6)
//将 2 个 list 合并成一个新的 List
val lst7 = lst1 ++ lst0
//将 lst0 插入到 lst1 前面生成一个新的集合
val lst8 = lst1 ++: lst0
//将 lst0 插入到 lst1 前面生成一个新的集合
val lst9 = lst1.:::(lst0)
println(other_lst)
println(lst1)
println(first)
println(tail)
println(lst2)
println(lst3)
println(lst4)
println(lst5)
println(lst6)
println(lst7)
println(lst8)
println(lst9)

Set

Set 代表一个没有重复元素的集合；将重复元素加入 Set 是没有用的，而且 Set 是不保证插
入顺序的，即 Set 中的元素是乱序的。
定义：val set=Set(元素元素)

//定义一个不可变的 Set 集合
scala> val set =Set(1,2,3,4,5,6,7)
set: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 4)
//元素个数
scala> set.size
res0: Int = 7
//取集合最小值
scala> set.min
res1: Int = 1
//取集合最大值
scala> set.max
res2: Int = 7
//将元素和 set1 合并生成一个新的 set，原有 set 不变
scala> set + 8
res3: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
scala> val set1=Set(7,8,9)
set1: scala.collection.immutable.Set[Int] = Set(7, 8, 9)
//两个集合的交集
scala> set & set1
res4: scala.collection.immutable.Set[Int] = Set(7)
//两个集合的并集
scala> set ++ set1
res5: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)
//在第一个 set 基础上去掉第二个 set 中存在的元素

scala> set -- set1
res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
//返回第一个不同于第二个 set 的元素集合
scala> set &~ set1
res7: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
//计算符合条件的元素个数
scala> set.count(_ >5)
res8: Int = 2
/返回第一个不同于第二个的元素集合
scala> set.diff(set1)
res9: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
/返回第一个不同于第二个的元素集合
scala> set1.diff(set)
res10: scala.collection.immutable.Set[Int] = Set(8, 9)
//取子 set(2,5 为元素位置, 从 0 开始，包含头不包含尾)
scala> set.slice(2,5)
res11: scala.collection.immutable.Set[Int] = Set(6, 2, 7)
//迭代所有的子 set，取指定的个数组合
scala> set1.subsets(2).foreach(x=>println(x))
Set(7, 8)
Set(7, 9)
Set(8, 9)

可变的 Set import scalacollectionmutable

//导入包
scala> import scala.collection.mu
import scala.collection.mutable
//定义一个可变的 Set
scala> val set1=new HashSet[Int]
set1: scala.collection.mutable.Ha
//添加元素
scala> set1 += 1

res1: set1.type = Set(1)
//添加元素 add 等价于+=
scala> set1.add(2)
res2: Boolean = true
scala> set1
res3: scala.collection.mutable.HashSet[Int] = Set(1, 2)
//向集合中添加元素集合
scala> set1 ++=Set(1,4,5)
res5: set1.type = Set(1, 5, 2, 4)
//删除一个元素
scala> set1 -=5
res6: set1.type = Set(1, 2, 4)
//删除一个元素
scala> set1.remove(1)
res7: Boolean = true
scala> set1
res8: scala.collection.mutable.HashSet[Int] = Set(2, 4)

Map

定义 Map 集合
1.val map=Map(键 -> 值 , 键 -> 值...)
2.利用元组构建 val map=Map((键，值), (键，值) , (键，值)....)
展现形式：
val map = Map(“zhangsan”->30,”lisi”->40)
val map = Map((“zhangsan”,30),(“lisi”,40))
3.操作 map 集合
获取值：值=map(键)
原则：通过先获取键，在获取键对应值。
4.遍历 map 集合
scala> val imap=Map("zhangsan" -> 20,"lisi" ->30)
imap: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 20, lisi -> 30)
//方法一：显示所有的 key
scala> imap.keys

res0: Iterable[String] = Set(zhangsan, lisi)
//方法二：显示所有的 key
scala> imap.keySet
res1: scala.collection.immutable.Set[String] = Set(zhangsan, lisi)
//通过 key 获取 value
scala> imap("lisi")
res2: Int = 30
//通过 key 获取 value 有 key 对应的值则返回，没有就返回默认值 0，
scala> imap.getOrElse("zhangsan",0)
res4: Int = 20
//没有对应的 key，返回默认 0
scala> imap.getOrElse("zhangsan1",0)
res5: Int = 0
//由于是不可变 map,故不能向其添加、删除、修改键值对

可变的 Map import scala.collection.mutable._

//导包
import scala.collection.mutable
//声明一个可变集合
scala> val user =mutable.HashMap("zhangsan"->50,"lisi" -> 100)
user: scala.collection.mutable.HashMap[String,Int] = Map(lisi -> 100, zhangsan ->
50)
//添加键值对
scala> user +=("wangwu" -> 30)
res0: user.type = Map(lisi -> 100, zhangsan -> 50, wangwu -> 30)
//添加多个键值对
scala> user += ("zhangsan0" -> 30,"lisi0" -> 20)
res1: user.type = Map(zhangsan0 -> 30, lisi -> 100, zhangsan -> 50, lisi0 -> 20,wangwu
-> 30)
//方法一：显示所有的 key
scala> user.keys
res2: Iterable[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)
//方法二：显示所有的 key
scala> user.keySet

res3: scala.collection.Set[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu
//通过 key 获取 value
scala> user("zhangsan")
res4: Int = 50
//通过 key 获取 value 有 key 对应的值则返回，没有就返回默认值 0，
scala> user.getOrElse("zhangsan",0)
res5: Int = 50
//没有对应的 key，返回默认 0
scala> user.getOrElse("zhangsan1",0)
res6: Int = 0
//更新键值对
scala> user("zhangsan") = 55
scala> user("zhangsan")
res8: Int = 55
//更新多个键值对
scala> user += ("zhangsan" -> 60, "lisi" -> 50)
res9: user.type = Map(zhangsan0 -> 30, lisi -> 50, zhangsan -> 60, lisi0 -> 20,wangw
-> 30)
//删除 key
scala> user -=("zhangsan")
res14: user.type = Map(zhangsan0 -> 30, lisi -> 50, lisi0 -> 20, wangwu -> 30)
//删除 key

scala>user.remove("zhangsan0")
//遍历 map 方法一：通过 key 值
scala> for(x<- user.keys) println(x+" -> "+user(x))
lisi -> 50
lisi0 -> 20
wangwu -> 30
//遍历 map 方法二：模式匹配
scala> for((x,y) <- user) println(x+" -> "+y)
lisi -> 50
lisi0 -> 20
wangwu -> 30

//遍历 map 方法三：通过 foreach

scala> user.foreach{case (x,y) => println(x+-> +y)}
lisi -> 50
lisi0 -> 20
wangwu -> 30