sparkpythonlist_曾经以为Python中的List用法足够灵活，直至我遇到了Scala…

导读&＃xff1a;继续开工Scala系列专题&＃xff0c;虽然对自己来说这是一个全新的方向和足够的挑战&＃xff0c;阅读数也很是惨淡&＃xff0c;但选择了方向就要坚持下去——生活中的获得感不正是源于一个个挑战和抉择之间吗&＃xff01;

言归正传&＃xff0c;前期分别完成了Scala中的变量标识符和运算符的分享&＃xff0c;本文重点介绍Scala中的常用集合类数据结构(scala.collection)&＃xff0c;当完整了解这个包的构成以及各数据结构的常用方法后&＃xff0c;你会再次认识到Scala语法的强大和奔放&＃xff0c;以至于让我一度质疑“Python语法足够简洁”的论断。

开篇引题&＃xff1a;程序&＃61;数据结构&＃43;算法&＃xff0c;对于一个良好的编程实现来说二者缺一不可。而对于数据结构&＃xff0c;除了特定框架的特有数据结构外(例如Spark框架的RDD、DataFrame&＃xff0c;Pandas框架的DataFrame)&＃xff0c;其实更为通用的其实还是那些经典数据结构&＃xff0c;例如数组、链表、集合、字典等等&＃xff0c;这也是绝大多数编程语言的通用设计。当然&＃xff0c;还有很多其他数据结构&＃xff0c;例如栈、队列、树和图等&＃xff0c;其底层大多可以基于这些基础的数据结构进行表示和实现。

具体而言&＃xff0c;本文主要介绍Scala中的以下5种经典的集合类数据结构&＃xff1a;Array

List

Set

Map

Tuple

01 Array

Array&＃xff0c;原意即为数组&＃xff0c;应该是所有编程语言中都有的数据结构&＃xff0c;也是很多场景下常用的集合类型&＃xff0c;有编程语言的应该都有了解。那么&＃xff0c;Scala中的Array有什么特别之处吗&＃xff1f;一句话概括Scala中的Array就是&＃xff1a;同质、数据可变、长度不可变的集合。显然&＃xff0c;这其中包含了3个关键词&＃xff0c;也分别描述了Array的3个特点&＃xff1a;同质&＃xff1a;意味着Array中的所有元素类型(或者称之为泛型&＃xff0c;字面意就是广泛存在的通用类型)都是相同的&＃xff0c;例如都是Int整型、或者String字符串型。如果非要容纳不同的数据类型&＃xff0c;例如既有Int又有Double还有String&＃xff0c;那么这个Array的数据类型只能是这些数据类型的超类——Any型

数据可变&＃xff1a;数据可变意味着Array中的每个元素可以发生变化&＃xff0c;比如开始为0&＃xff0c;后来可以变为1等等。这里之所以强调Array中的数据可变&＃xff0c;是因为与之对应的是List数据不可变

长度不可变&＃xff1a;这与C和Java中的数组有一定相似之处&＃xff0c;即一旦初始指定了Array的数据个数(即Array的length)&＃xff0c;那么后续则不能再发生改变。那么如果一定想要发生改变怎么办呢&＃xff0c;那就只能调用Array的兄弟&＃xff0c;ArrayBuffer

了解了Array数据结构的这3大特点&＃xff0c;就相当于get到了Array的价值观。那么接下来自然就是方法论层面的问题&＃xff1a;即怎么创建和如何使用。

Array的创建有两种方式&＃xff0c;一种是直接指定元素完成初始化&＃xff0c;另一种是指定数据类型和长度&＃xff0c;而不提供初始数据。

scala> val arr1 &＃61; Array(1, 2, "string")

val arr1: Array[Any] &＃61; Array(1, 2, string)

scala> val arr2 &＃61; Array[Int](3)

val arr2: Array[Int] &＃61; Array(3)

scala> val arr3 &＃61; new Array[Int](3)

val arr3: Array[Int] &＃61; Array(0, 0, 0)

如上述示例代码所示&＃xff0c;arr1是一个直接指定初始元素的数组&＃xff0c;由于此时未指定泛型且实际包含的初始数据既有整型也有字符串&＃xff0c;所以相当于创建了一个泛型为Any、长度为3、初始元素为1、2、"string"的数组&＃xff1b;arr2的初始化过程类似于arr1&＃xff0c;但实际指定了泛型类型为Int型&＃xff0c;且实际只有1个初始化数据3&＃xff1b;arr3与arr2的唯一区别在于Array前多了一个new关键字&＃xff0c;这将直接导致创建了一个长度为3、泛型为Int的数组&＃xff0c;进一步地由于指定泛型为Int所以默认初始元素均为0。

这里&＃xff0c;对比arr2和arr3的创建过程&＃xff0c;可以发现当带有new关键字的初始化时采用的原原本本的由类创建对象的方式&＃xff1b;而不带new关键字时&＃xff0c;实际上是调用了Array类的伴生对象apply方法完成初始化&＃xff0c;在这种方法中可以省略new关键字&＃xff0c;从而简化由类创建对象的过程。这将在后续介绍类和对象时予以介绍&＃xff0c;此处只需了解两种不同初始化方式的具体实现即可。

在创建一个Array数组后&＃xff0c;还需了解基本的常用操作。这里&＃xff0c;由于Array数组是数据可变长度不可变的集合&＃xff0c;所以对该数组涉及的操作无非就是访问和修改值两类操作&＃xff1b;但同时&＃xff0c;虽然Array本身长度不可变&＃xff0c;但却可以添加新的元素或者与其他Array连接构成新的Array&＃xff0c;注意这里都是构成了新的Array&＃xff0c;而不是改变原有Array&＃xff0c;因为其长度不可变。

scala> arr1(0) // 用()&＃43;下标访问数组元素val res0: Any &＃61; 1

scala> arr1 :&＃43; 3 // :&＃43; 后面添加新元素val res1: Array[Any] &＃61; Array(1, 2, string, 3)

scala> 0 &＃43;: arr1 // &＃43;&＃xff1a;前面添加新元素val res2: Array[Any] &＃61; Array(0, 1, 2, string)

scala> arr1 &＃43;&＃43; Array(4, 5) // &＃43;&＃43; 连接其他数组val res3: Array[Any] &＃61; Array(1, 2, string, 4, 5)

如上的示例代码中分别执行了Array元素的访问、前后向添加元素构成新的Array以及与其他Array拼接构成新的Array&＃xff0c;基本上这几个操作也是最为常用的操作。除了以上访问和追加新的元素&＃xff0c;当然Array也提供了很多常用的接口&＃xff0c;例如&＃xff1a;

scala> arr1.length // 返回数组长度val res4: Int &＃61; 3

scala> arr1.indices // 返回数组下标列表val res7: scala.collection.immutable.Range &＃61; Range 0 until 3

scala> arr1.foreach(print) // 调用foreach方法 12string

其中foreach方法应该称之为是所有集合类数据结构的通用方法。另外&＃xff0c;除了length、indices等之外&＃xff0c;如果是Array泛型为数值型&＃xff0c;那么还有其他常用方法&＃xff0c;例如max、min等。

最后&＃xff0c;再补充关于Array的两个要点&＃xff1a;创建多维数值。实际上&＃xff0c;多维数组就是数组的多层嵌套&＃xff0c;所以自然可以用前述的数组初始化方式嵌套完成多维数组的创建&＃xff0c;当数组是一个整齐的维度例如m×n时&＃xff0c;那么可直接调用Array.ofDim(m, n)创建即可&＃xff1b;

前面提到&＃xff0c;Array是一个长度不可变的数据集合&＃xff0c;那么有时为了应用可变长度的数组&＃xff0c;此时需要引用ArrayBuffer类来创建&＃xff0c;其与Array的最大区别即在于它的长度是可以动态改变。

02 List

前述详细介绍了Array数据结构的特点、创建及常用方法&＃xff0c;与Array表现极为相近但又有重要不同的数据结构就是List&＃xff0c;即列表。List的特点可概括为&＃xff1a;同质、数据不可变且长度不可变的集合。也就是说&＃xff0c;相较于Array类型&＃xff0c;List的最大区别在于数据不可变&＃xff0c;即一旦初始化则其不可更改。更深层次的讲&＃xff0c;Array的底层是一块连续申请的内存&＃xff0c;而List则更符合链表的实现特性(实际上&＃xff0c;在scala2.11之前的版本&＃xff0c;确实存在一个LinkedList类)。

既然List与Array除了数据一旦完成初始即不再可变&＃xff0c;所以其很多特性都有相通之处&＃xff0c;当然也有很多不同。比如&＃xff0c;由于数据不可变&＃xff0c;所以其创建过程自然就不能仅指定长度而不提供初值&＃xff0c;也就是创建时必须提供所有初值。

scala> val list &＃61; new List[Int](3)

^ error: class List is abstract; cannot be instantiated

scala> val list &＃61; List(1, 2, 3)

val list: List[Int] &＃61; List(1, 2, 3)

除了创建过程中的区别&＃xff0c;Array中的数值访问、元素拼接、两个List拼接以及常用方法在List中也都适用。特别地&＃xff0c;长度为0的List是一个特殊对象&＃xff0c;表示为Nil。

scala> list(0)

val res9: Int &＃61; 1

scala> list :&＃43; 4

val res10: List[Int] &＃61; List(1, 2, 3, 4)

scala> 0 &＃43;: list

val res11: List[Int] &＃61; List(0, 1, 2, 3)

scala> list &＃43;&＃43; List(5, 6)

val res12: List[Int] &＃61; List(1, 2, 3, 5, 6)

scala> list.length

val res13: Int &＃61; 3

然而&＃xff0c;如果List的常用方法也仅仅如此的话&＃xff0c;那么其实好像是被Array完全碾压的节奏&＃xff0c;所以实际上List还有更多的语法糖骚操作&＃xff0c;即灵活运用::这个操作符&＃xff0c;读作cons&＃xff0c;即连接的意思。在前面介绍操作符一文时&＃xff0c;有提到过在Scala中但凡以&＃xff1a;结尾的操作符&＃xff0c;那么都将以右操作数来调用&＃xff0c;其实这里主要就是指的就是Array和List&＃xff0c;而尤以List含有&＃xff1a;方法居多。例如&＃xff0c;同样拼接元素&＃xff0c;下面的方法也可实现添加元素和拼接两个List&＃xff1a;

scala> 0 :: list // list调用::方法&＃xff0c;在前面添加元素0&＃xff0c;构成新Listval res14: List[Int] &＃61; List(0, 1, 2, 3)

scala> List(0, 1) ::: list // list调用:::方法&＃xff0c;与另一个List拼接成新Listval res15: List[Int] &＃61; List(0, 1, 1, 2, 3)

当然&＃xff0c;将::写在两个操作数中间是将其看做是操作符来执行计算&＃xff0c;而更为严谨的说其实质是调用的::方法&＃xff0c;即上面两句代码其底层执行的是如下逻辑&＃xff1a;

scala> list.::(0) // ::是List的方法接口val res16: List[Int] &＃61; List(0, 1, 2, 3)

scala> list.:::(List(0, 1)) // :::也是list的方法接口val res17: List[Int] &＃61; List(0, 1, 1, 2, 3)

怎么样&＃xff0c;是不是感觉Scala中List可比Python中List的骚操作更多呢&＃xff1f;

与此同时&＃xff0c;List由于更贴近与链表的实现特性&＃xff0c;所以具有更多的访问首尾方法&＃xff0c;即head和tail&＃xff0c;其中head为返回第一个元素&＃xff0c;而tail则是返回第一个元素以外的所有元素。

scala> list.head // 返回第一个元素&＃xff0c;结果是一个值val res18: Int &＃61; 1

scala> list.tail // 返回第一个以后的所有元素&＃xff0c;结果仍然是一个listval res19: List[Int] &＃61; List(2, 3)

另外需要补充的是&＃xff0c;与ArrayBuffer和Array的关系类似&＃xff0c;List也有其兄弟ListBuffer&＃xff0c;用于实现可变长的列表。

03 Set

与大多数语言中均提供了Set数据结构类似&＃xff0c;Scala中的Set也扮演了这一角色。Set的最大特点是&＃xff1a;同质、数据去重、长度不可变&＃xff0c;其中数据去重是所有集合的特性&＃xff0c;默认以哈希集实现。注&＃xff1a;Scala中的可变Set和不可变Set是同名类&＃xff0c;都叫做Set&＃xff0c;这与Array和List区分是否带Buffer是完全不同的命名设计。

在了解Array和List的基础上&＃xff0c;Set的创建也比较直观&＃xff0c;同时也支持添加元素和拼接两个Set构成新的Set方法。另外&＃xff0c;Set设计的定位是用于判断指定集合是否包含目标值&＃xff0c;所以contains是其常用方法。Set常用操作示例如下&＃xff1a;

scala> val set &＃61;Set(1, 2, 2, 3) // 创建Set&＃xff0c;会自动去重val set: scala.collection.immutable.Set[Int] &＃61; Set(1, 2, 3)

scala> set &＃43; 4 // 添加新元素返回新的Setval res20: scala.collection.immutable.Set[Int] &＃61; Set(1, 2, 3, 4)

scala> set &＃43;&＃43; Set(3, 4) // 拼接另一个Set&＃xff0c;返回新的Setval res21: scala.collection.immutable.Set[Int] &＃61; Set(1, 2, 3, 4)

scala> set.contains(2)

val res22: Boolean &＃61; true

当然&＃xff0c;既然是集合&＃xff0c;所以也提供了数学意义上的交集、并集和补集操作。另外&＃xff0c;如需使用可变长集合&＃xff0c;则需引用scala.collection.mutable.Set类&＃xff0c;其与不可变集合Set为同名类&＃xff0c;按照就近原则引用。

04 Map

与Set类似&＃xff0c;Map也是编程语言中的一种常用数据结构&＃xff0c;用于表达映射关系&＃xff0c;在Python中就是字典数据结构dict&＃xff0c;通过提供键值对的访问方式&＃xff0c;可以以O(1)的复杂度完成数据的访问和赋值。在Scala中&＃xff0c;Map也区分可变和不可变映射&＃xff0c;且为同名类&＃xff0c;如果需要创建可变Map&＃xff0c;则需在适当位置import相应类即可。

在Scala中&＃xff0c;Map的元素类型实际上是一个二值的元组类型(Tuple2)&＃xff0c;两个值分别为key和value&＃xff0c;而对于这个特殊的二值元组&＃xff0c;实际上则又有两种具体表达形式&＃xff0c;示例如下&＃xff1a;

scala> val map1 &＃61; Map((1, 2), (3, 4)) // 创建map方式1:(key, value)val map1: scala.collection.immutable.Map[Int,Int] &＃61; Map(1 -> 2, 3 -> 4)

scala> val map2 &＃61; Map(2->3, 3->5) // 创建map方式2:key->valueval map2: scala.collection.immutable.Map[Int,Int] &＃61; Map(2 -> 3, 3 -> 5)

类似于Python中的dict&＃xff0c;Scala中的Map也可通过keys和values获取所有的键和值&＃xff0c;且keys实际上就是一个Set&＃xff0c;因而不会存在重复值&＃xff1b;而values则不受这一限制&＃xff1a;

scala> map1.keys // 获取所有键&＃xff0c;返回结果是一个Set类型val res23: Iterable[Int] &＃61; Set(1, 3)

scala> map1.values // 获取所有值&＃xff0c;返回结果是一个迭代类型val res24: Iterable[Int] &＃61; Iterable(2, 4)

与Set类似&＃xff0c;Map也支持类似的添加新键值对和与其他Map拼接的方法&＃xff1a;

scala> map1 &＃43; (4->5)

val res27: scala.collection.immutable.Map[Int,Int] &＃61; Map(1 -> 2, 3 -> 4, 4 -> 5)

scala> map1 &＃43;&＃43; map2

val res28: scala.collection.immutable.Map[Int,Int] &＃61; Map(1 -> 2, 3 -> 5, 2 -> 3)

05 Tuple

前面介绍的4种数据结构&＃xff0c;实际上都有一个共性要求是所有元素必须是同质的&＃xff0c;即使是存在形式上的不同类型(例如一个数组既有整型&＃xff0c;又有字符串型)&＃xff0c;那么其实质上是定义了泛型为Any的数组。而Tuple元组则是一个实实在在的支持不同泛型的集合数据结构&＃xff0c;比如可以是第一个元素是整型&＃xff0c;第二个元素是字符串型等等。例如&＃xff0c;Map的每个键值对实际上都是一个二值元组&＃xff0c;而正因为二值元组可以支持两种不同的数据类型&＃xff0c;才保证了Map定义的多样性。

Tuple的创建与前面4种类型也略有不同&＃xff0c;其可以直接以圆括号进行初始化即可&＃xff0c;括号内的数据即为初始化值&＃xff0c;且一旦指定也不可改变。特别地&＃xff0c;这里Tuple最多可以支持22个元素的初始化&＃xff0c;分别对应Tuple1——Tuple22类型。

scala> val tuple1 &＃61; (1, "str") // 二值元组创建方式一&＃xff1a;()val tuple1: (Int, String) &＃61; (1,str)

scala> val tuple2 &＃61; Tuple2("str", 3) // 二值元组创建方式二&＃xff1a;Tuple2实例化val tuple2: (String, Int) &＃61; (str,3)

scala> val tuple3 &＃61; "str"->4 // 特殊地&＃xff0c;二值元组还可通过->创建&＃xff0c;如同Map中定义的那样val tuple3: (String, Int) &＃61; (str,4)

上面给出了三种二值元组的创建方式&＃xff0c;其中前两种是所有Tuple类型共有的&＃xff0c;且第一种更为简洁通用&＃xff1b;第三种属于二值元组所特有的&＃xff0c;毕竟二值元组是Map中的对象类型&＃xff0c;具有一定的特殊性。

那么&＃xff0c;既然Tuple最多仅支持22个元素&＃xff0c;那貌似好像挺受局限&＃xff0c;毕竟数量上较少&＃xff0c;但实则不然。单从多样性的角度讲&＃xff0c;由于元组的每个元素类型都可能不一样&＃xff0c;例如上面示例中tuple1是一个(Int, String)型二值元组&＃xff0c;而tuple2则是一个(String, Int)型二值元组&＃xff0c;虽然仅是类型调换了顺序&＃xff0c;却是实实在在的不同类型元组。照此计算&＃xff0c;以Scala中9种基本的数据类型为例进行计算&＃xff0c;那么Tuple中所有的元组类型总数应该是9&＃43;9^2&＃43;……&＃43;9^22&＃xff0c;这其实是一个非常庞大的数字。

另外值得指出的是&＃xff0c;得益于元组中支持不同类型的元素&＃xff0c;所以函数中需要返回多个不同类型结果时即可以Tuple类型进行交换。

最后给出Scala中所有集合类数据结构的继承关系图&＃xff0c;区分可变(mutable)和不可变(immutable)两种类型&＃xff0c;仅做延伸了解&＃xff0c;不具体展开。Scala中的不可变集合类数据结构继承关系Scala中的可变集合类数据结构继承关系