Scala基础语法(集合操作)

scala—集合操作

本文介绍了Scala常用的集合主要有Set（无序不重复）、SortedSet（有序不重复）、List（可重复）

最后详细介绍了List的一些通用函数主要有
filter、teke、map、reduce、flatten、flatMap、zip、min、count、max、sum等常用的函数

无序不重复set集合操作

scala> val s=Set(1,2,3,4,5)
s: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)
去掉某个元素
scala> s -5
res0: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)
一次去掉多个元素操作
scala> s -(1,2,3)
res1: scala.collection.immutable.Set[Int] = Set(5, 4)
大家会发现刚才去掉的5怎么又会来了，是因为immutable是不可变集合
直接去掉一个集合
scala> s - List(4,5)
<console>:13: error: type mismatch;
 found   : List[Int]
 required: Int
       s - List(4,5)
               ^
如果去掉一个集合需要是用两个减号
scala> s -- List(4,5)
res3: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
scala> s +6
res4: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
scala> s +1
res5: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)
scala> s + (34,56)
res6: scala.collection.immutable.Set[Int] = Set(5, 56, 1, 2, 34, 3, 4)

有序不重复set集合操作 SortedSet

scala> SortedSet(1,2,3,4,500,4,6,89,56,5,3,1)
<console>:12: error: not found: value SortedSet
       SortedSet(1,2,3,4,500,4,6,89,56,5,3,1)
       ^
需要引入immutable.SortedSet
scala> scala.collection.immutable.SortedSet(21,45,1,2,5)
res10: scala.collection.immutable.SortedSet[Int] = TreeSet(1, 2, 5, 21, 45)
可变不重复集合mutable
scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set
scala> val set=Set(1,2,2,3)
set: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> set + 3
res11: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> set + 4
res12: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
scala> set
res13: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> set += 4
res14: set.type = Set(1, 2, 3, 4)
scala> set
res15: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
可以加多个
scala> set +5 +6 +7
res16: scala.collection.mutable.Set[Int] = Set(1, 5, 2, 6, 3, 7, 4)
scala> set
res17: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
scala> set +(10,22,34)
res18: scala.collection.mutable.Set[Int] = Set(1, 34, 2, 3, 10, 4, 22)
scala> set + List(55,66,77)
<console>:14: error: type mismatch;
 found   : List[Int]
 required: Int
       set + List(55,66,77)
                 ^
scala> set ++ List(55,66,77)
res20: scala.collection.mutable.Set[Int] = Set(66, 1, 2, 3, 4, 55, 77)
scala> set
res21: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

集合List的通用操作

scala> val list=List(1,1,2,3,4,5,6,7,8,9)
list: List[Int] = List(1, 1, 2, 3, 4, 5, 6, 7, 8, 9)
过滤大于5的元素
scala> list.filter(_>5)
res22: List[Int] = List(6, 7, 8, 9)
将集合中的元素乘以3
scala> list.map(_ * 3)
res23: List[Int] = List(3, 3, 6, 9, 12, 15, 18, 21, 24, 27)
先过滤大于5的数据在让每个元素乘以2，最后打印出来
scala> list.filter(_>5).map(_ * 2).foreach(println(_))
12
14
16
18
如果打印的数据只有一个元素的话可以这样写
scala> list.filter(_>5).map(_ * 2).foreach(println)
12
14
16
18
取出集合中前三个元素
scala> list.take(3)
res29: List[Int] = List(1, 1, 2)
reduce（_+_）操作每两个元素操作一次，操作后的元素在与第三个元素进行操作，循环迭代
scala> list.filter(_>5).map(_ * 2).reduce(_+_)
res30: Int = 60
求最大值
scala> list.max
res31: Int = 9
求最小值
scala> list.min
res32: Int = 1
统计个数（注意要跟filter）
scala> list.count(_>5)
res33: Int = 4

scala> list.sum
res34: Int = 46
zip操作将两个list集合配对
scala> val list1=List(1,2,3,4,5)
list1: List[Int] = List(1, 2, 3, 4, 5)
scala> val list2=List("A","B","C","D","E","F")
list2: List[String] = List(A, B, C, D, E, F)
scala> list1 zip list2
res35: List[(Int, String)] = List((1,A), (2,B), (3,C), (4,D), (5,E))

scala>
flatten操作将list集合压扁
scala> val list3=List(List(1,2),List(3,4),List(5,6))
list3: List[List[Int]] = List(List(1, 2), List(3, 4), List(5, 6))
scala> list3.flatten
res38: List[Int] = List(1, 2, 3, 4, 5, 6)

flatten一般是和map组合使用
scala> list3
res40: List[List[Int]] = List(List(1, 2), List(3, 4), List(5, 6))
scala> list3.flatMap(_.map(3*_))
res41: List[Int] = List(3, 6, 9, 12, 15, 18)
看一下只用map不用flatten的效果
scala> list3.map(_.map(_*3))
res42: List[List[Int]] = List(List(3, 6), List(9, 12), List(15, 18))