Scala 系列(五)—— 集合类型综述

一、集合简介

Scala中拥有多种集合类型,主要分为可变的和不可变的集合两大类:

  • 可变集合: 可以被修改。即可以更改,添加,删除集合中的元素;
  • 不可变集合类:不能被修改。对集合执行更改,添加或删除操作都会返回一个新的集合,而不是修改原来的集合。

二、集合结构

Scala中的大部分集合类都存在三类变体,分别位于scala.collection, scala.collection.immutable, scala.collection.mutable包中。还有部分集合类位于scala.collection.generic包下。

  • scala.collection.immutable :包是中的集合是不可变的;
  • scala.collection.mutable :包中的集合是可变的;
  • scala.collection :包中的集合,既可以是可变的,也可以是不可变的。
val sortSet = scala.collection.SortedSet(1, 2, 3, 4, 5)
val mutableSet = collection.mutable.SortedSet(1, 2, 3, 4, 5)
val immutableSet = collection.immutable.SortedSet(1, 2, 3, 4, 5)

如果你仅写了Set 而没有加任何前缀也没有进行任何import,则Scala默认采用不可变集合类。

scala> Set(1,2,3,4,5)
res0: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

3.1 scala.collection

scala.collection包中所有集合如下图:

3.2 scala.collection.mutable

scala.collection.mutable包中所有集合如下图:

3.2 scala.collection.immutable

scala.collection.immutable包中所有集合如下图:

三、Trait Traversable

Scala中所有集合的顶层实现是Traversable 。它唯一的抽象方法是foreach

def foreach[U](f: Elem => U)

实现Traversable的集合类只需要实现这个抽象方法,其他方法可以从Traversable继承。Traversable中的所有可用方法如下:

方法 作用
Abstract Method:
xs foreach f 为 xs 的每个元素执行函数 f
Addition:
xs ++ ys 一个包含 xs 和 ys 中所有元素的新的集合。 ys 是一个 Traversable 或 Iterator。
Maps:
xs map f 对 xs 中每一个元素应用函数 f,并返回一个新的集合
xs flatMap f 对 xs 中每一个元素应用函数 f,最后将结果合并成一个新的集合
xs collect f 对 xs 中每一个元素调用偏函数 f,并返回一个新的集合
Conversions:
xs.toArray 将集合转化为一个 Array
xs.toList 将集合转化为一个 List
xs.toIterable 将集合转化为一个 Iterable
xs.toSeq 将集合转化为一个 Seq
xs.toIndexedSeq 将集合转化为一个 IndexedSeq
xs.toStream 将集合转化为一个延迟计算的流
xs.toSet 将集合转化为一个 Set
xs.toMap 将一个(key, value)对的集合转化为一个Map。 如果当前集合的元素类型不是(key, value)对形式, 则报静态类型错误。
Copying:
xs copyToBuffer buf 拷贝集合中所有元素到缓存 buf
xs copyToArray(arr,s,n) 从索引 s 开始,将集合中最多 n 个元素复制到数组 arr。 最后两个参数是可选的。
Size info:
xs.isEmpty 判断集合是否为空
xs.nonEmpty 判断集合是否包含元素
xs.size 返回集合中元素的个数
xs.hasDefiniteSize 如果 xs 具有有限大小,则为真。
Element Retrieval:
xs.head 返回集合中的第一个元素(如果无序,则随机返回)
xs.headOption 以 Option 的方式返回集合中的第一个元素, 如果集合为空则返回 None
xs.last 返回集合中的最后一个元素(如果无序,则随机返回)
xs.lastOption 以 Option 的方式返回集合中的最后一个元素, 如果集合为空则返回 None
xs find p 以 Option 的方式返回满足条件 p 的第一个元素, 如果都不满足则返回 None
Subcollection:
xs.tail 除了第一个元素之外的其他元素组成的集合
xs.init 除了最后一个元素之外的其他元素组成的集合
xs slice (from, to) 返回给定索引范围之内的元素组成的集合 (包含 from 位置的元素但不包含 to 位置的元素)
xs take n 返回 xs 的前n个元素组成的集合(如果无序,则返回任意n个元素)
xs drop n 返回 xs 的后n个元素组成的集合(如果无序,则返回任意n个元素)
xs takeWhile p 从第一个元素开始查找满足条件 p 的元素, 直到遇到一个不满足条件的元素,返回所有遍历到的值。
xs dropWhile p 从第一个元素开始查找满足条件 p 的元素, 直到遇到一个不满足条件的元素,返回所有未遍历到的值。
xs filter p 返回满足条件 p 的所有元素的集合
xs withFilter p 集合的非严格的过滤器。后续对 xs 调用方法 map、flatMap 以及 withFilter 都只用作于满足条件 p 的元素,而忽略其他元素
xs filterNot p 返回不满足条件 p 的所有元素组成的集合
Subdivisions:
xs splitAt n 在给定位置拆分集合,返回一个集合对 (xs take n, xs drop n)
xs span p 根据给定条件拆分集合,返回一个集合对(xs takeWhile p, xs dropWhile p)。即遍历元素,直到遇到第一个不符合条件的值则结束遍历,将遍历到的值和未遍历到的值分别放入两个集合返回。
xs partition p 按照筛选条件对元素进行分组
xs groupBy f 根据鉴别器函数 f 将 xs 划分为集合映射
Element Conditions:
xs forall p 判断集合中所有的元素是否都满足条件 p
xs exists p 判断集合中是否存在一个元素满足条件 p
xs count p xs 中满足条件 p 的元素的个数
Folds:
(z /: xs) (op) 以 z 为初始值,从左到右对 xs 中的元素执行操作为 op 的归约操作
(xs :\ z) (op) 以 z 为初始值,从右到左对 xs 中的元素执行操作为 op 的归约操作
xs.foldLeft(z) (op) 同 (z /: xs) (op)
xs.foldRight(z) (op) 同 (xs :?z) (op)
xs reduceLeft op 从左到右对 xs 中的元素执行操作为 op 的归约操作
xs reduceRight op 从右到左对 xs 中的元素执行操作为 op 的归约操作
Specific Folds:
xs.sum 累计求和
xs.product 累计求积
xs.min xs 中的最小值
xs.max xs 中的最大值
String:
xs addString (b, start, sep, end) 向 StringBuilder b 中添加一个字符串, 该字符串包含 xs 的所有元素。start、seq 和 end 都是可选的,seq 为分隔符,start 为开始符号,end 为结束符号。
xs mkString (start, seq, end) 将集合转化为一个字符串。start、seq 和 end 都是可选的,seq 为分隔符,start 为开始符号,end 为结束符号。
xs.stringPrefix 返回 xs.toString 字符串开头的集合名称
Views:
xs.view 生成 xs 的视图
xs view (from, to) 生成 xs上指定索引范围内元素的视图

下面为部分方法的使用示例:

scala> List(1, 2, 3, 4, 5, 6).collect { case i if i % 2 == 0 => i * 10 }
res0: List[Int] = List(20, 40, 60)

scala> List(1, 2, 3, 4, 5, 6).withFilter(_ % 2 == 0).map(_ * 10)
res1: List[Int] = List(20, 40, 60)

scala> (10 /: List(1, 2, 3)) (_ + _)
res2: Int = 16

scala> List(1, 2, 3, -4, 5) takeWhile (_ > 0)
res3: List[Int] = List(1, 2, 3)

scala> List(1, 2, 3, -4, 5) span (_ > 0)
res4: (List[Int], List[Int]) = (List(1, 2, 3),List(-4, 5))

scala> List(1, 2, 3).mkString("[","-","]")
res5: String = [1-2-3]

四、Trait Iterable

Scala中所有的集合都直接或者间接实现了Iterable特质,Iterable拓展自Traversable,并额外定义了部分方法:

方法 作用
Abstract Method:
xs.iterator 返回一个迭代器,用于遍历 xs 中的元素, 与foreach遍历元素的顺序相同。
Other Iterators:
xs grouped size 返回一个固定大小的迭代器
xs sliding size 返回一个固定大小的滑动窗口的迭代器
Subcollections:
xs takeRigtht n 返回 xs 中最后 n 个元素组成的集合(如果无序,则返回任意 n 个元素组成的集合)
xs dropRight n 返回 xs 中除了最后 n 个元素外的部分
Zippers:
xs zip ys 返回 xs 和 ys 的对应位置上的元素对组成的集合
xs zipAll (ys, x, y) 返回 xs 和 ys 的对应位置上的元素对组成的集合。其中较短的序列通过附加元素 x 或 y 来扩展以匹配较长的序列。
xs.zipWithIndex 返回一个由 xs 中元素及其索引所组成的元素对的集合
Comparison:
xs sameElements ys 测试 xs 和 ys 是否包含相同顺序的相同元素

所有方法的使用示例如下:

scala> List(1, 2, 3).iterator.reduce(_ * _ * 10)
res0: Int = 600

scala> List("a","b","c","d","e") grouped 2 foreach println
List(a, b)
List(c, d)
List(e)

scala> List("a","b","c","d","e") sliding 2 foreach println
List(a, b)
List(b, c)
List(c, d)
List(d, e)

scala>  List("a","b","c","d","e").takeRight(3)
res1: List[String] = List(c, d, e)

scala> List("a","b","c","d","e").dropRight(3)
res2: List[String] = List(a, b)

scala> List("a","b","c").zip(List(1,2,3))
res3: List[(String, Int)] = List((a,1), (b,2), (c,3))

scala> List("a","b","c","d").zipAll(List(1,2,3),"",4)
res4: List[(String, Int)] = List((a,1), (b,2), (c,3), (d,4))

scala> List("a","b","c").zipAll(List(1,2,3,4),"d","")
res5: List[(String, Any)] = List((a,1), (b,2), (c,3), (d,4))

scala> List("a", "b", "c").zipWithIndex
res6: List[(String, Int)] = List((a,0), (b,1), (c,2))

scala> List("a", "b") sameElements List("a", "b")
res7: Boolean = true

scala> List("a", "b") sameElements List("b", "a")
res8: Boolean = false

五、修改集合

当你想对集合添加或者删除元素,需要根据不同的集合类型选择不同的操作符号:

操作符 描述 集合类型
coll(k)
即coll.apply(k)
获取指定位置的元素 Seq, Map
coll :+ elem
elem +: coll
向集合末尾或者集合头增加元素 Seq
coll + elem
coll + (e1, e2, ...)
追加元素 Seq, Map
coll - elem
coll - (e1, e2, ...)
删除元素 Set, Map, ArrayBuffer
coll ++ coll2
coll2 ++: coll
合并集合 Iterable
coll -- coll2 移除coll中包含的coll2中的元素 Set, Map, ArrayBuffer
elem :: lst
lst2 :: lst
把指定列表(lst2)或者元素(elem)添加到列表(lst)头部 List
list ::: list2 合并List List
set | set2
set & set2
set &~ set2
并集、交集、差集 Set
coll += elem
coll += (e1, e2, ...)
coll ++= coll2
coll -= elem
coll -= (e1, e2, ...)
coll --= coll2
添加或者删除元素,并将修改后的结果赋值给集合本身 可变集合
elem +=: coll
coll2 ++=: coll
在集合头部追加元素或集合 ArrayBuffer

参考资料

  1. https://docs.scala-lang.org/overviews/collections/overview.html
  2. https://docs.scala-lang.org/overviews/collections/trait-traversable.html
  3. https://docs.scala-lang.org/overviews/collections/trait-iterable.html

更多大数据系列文章可以参见个人 GitHub 开源项目: 程序员大数据入门指南

原文地址:https://www.cnblogs.com/heibaiying/p/11565846.html

时间: 2024-08-10 20:46:16

Scala 系列(五)—— 集合类型综述的相关文章

6.Swift教程翻译系列——Swift集合类型

英文版PDF下载地址http://download.csdn.net/detail/tsingheng/7480427 Swift提供数组和字典两种集合类型,用来存储许多值的情况.数组有序的存储一组相同类型的值.字典也存储一组相同类型的值但是是无序的,字典中存储的值可以通过一个唯一的标识(也就是Key)来查找. 在Swift中,数组和字典总是清楚自己能存储的值的类型和key的类型.也就是说你不会错误的把其他不对应的类型存进数组或者字典.所以你也能确定从数组或者字典中取出来的值的类型肯定也不会错了

好程序员大数据学习路线分享Scala系列之集合操作函数

好程序员大数据学习路线继续为大家分享Scala系列之集合操作函数4.6 集合的重要函数4.6.1sum/max/min/count在序列中查找最大或最小值是一个极常见的需求,如下:val numbers = Seq(11, 2, 5, 1, 6, 3, 9) numbers.max //11 numbers.min //1 更高级的例子,其中包含一个书的序列case class Book(title: String, pages: Int) val books = Seq( Book("Futu

Scala学习笔记--集合类型

队列Queue val emp = scala.collection.immutable.Queue[Int](); val has1 = emp.enqueue(1) val has123=has1.enqueue(List(2,3)) println(has1) //Queue(1) println(has123) //Queue(1,2,3) val emp2 = scala.collection.mutable.Queue[Int](); emp2.enqueue(1); emp2.en

Swift中的集合类型

一.引子: 在2014年10月TIOBE编程语言排行榜中,Swift位居第18位,从2014WWDC发布会首次公布至今不到半年时间,swift一直受到编程人员的追捧,其热衷程度并不亚于当红巨星Taylor Swift.相信在不远的将来,swift能够平稳发展,并逐步取代Objective-C. 二.swift的集合类型 下面回归主题.作为一名iOS开发者,我们已经非常熟悉诸如NSArray,NSDictionary,NSSet等常见集合类型,以及它们的可变同类NSMutableArray,NSM

scala集合类型与java的转换

scala集合与java集合类型相互转换: http://www.scala-lang.org/api/current/index.html#scala.collection.JavaConverters$ 您可以通过JavaConverters package轻松地在Java和Scala的集合类型之间转换.它用asScala 装饰常用的Java集合以和用asJava 方法装饰Scala集合.    import scala.collection.JavaConverters._    val 

Scala集合类型详解

Scala集合 Scala提供了一套很好的集合实现,提供了一些集合类型的抽象. Scala 集合分为可变的和不可变的集合. 可变集合可以在适当的地方被更新或扩展.这意味着你可以修改,添加,移除一个集合的元素.而不可变集合类永远不会改变.不过,你仍然可以模拟添加,移除或更新操作.但是这些操作将在每一种情况下都返回一个新的集合,同时使原来的集合不发生改变. 集合中基本结构: 几种常用集合类型示例: // 定义整型 List   val x = List(1, 2, 3, 4)     // 定义 S

第五章.集合类型

Swift提供了两种集合类型,分别是数组和字典(就是键值对). 数组 数组使用有序列表存储相同类型的多重数据.简单说就是可以存储重复的值. 数组构造语句 我们可以使用字面语句来进行数组构造,这是一种用一个或者多个数值构造数组的简单方法.字面语句是一系列由逗号分割并由方括号包含的数值. [value 1, value 2, value 3]. 下面这个例子创建了一个叫做shoppingList并且存储字符串的数组: var shoppingList: String[] = ["Eggs"

VSTO之旅系列(五):创建Outlook解决方案

原文:VSTO之旅系列(五):创建Outlook解决方案 本专题概要 引言 Outlook对象模型 自定义Outlook窗体 小结 一.引言 在上一个专题中,为大家简单介绍了下如何创建Word解决方案的,所以本专题中将为大家介绍下Outlook相关的内容.我们从Visual Studio 2010 中Office节点下的模板中我们可以看到,Outlook只有外接程序的模板,并没有提供像Word或Excel这样的文档级的模板,所以VSTO没有为Outlook解决方案创建宿主项和宿主控件(Excel

JS魔法堂:那些困扰你的DOM集合类型

一.前言 大家先看看下面的js,猜猜结果会怎样吧! 可选答案: ①. 获取id属性值为id的节点元素 ②. 抛namedItem is undefined的异常 var nodes = document.getElementsByName('dummyName'); var node = nodes.namedItem('id'); 答案是两种都有可能哦!document.getElementsByName在Chrome和FF30.0中返回NodeList(木有namedItem方法的),在IE