[comment]: # Scala Collection简介
Traversable vs Iterable
Traversable, Iterable 都是trait。
Iterable 继承 Traversable。
Traversable: 支持foreach.
Iterable: 支持Interator方法。
Immutable vs mutable
Scala的Collection有Immutable和mutable两个大家族。
Immutable: 不可变。初始化后不会发生变化。scala的默认collections。性能更好。
Mutable： 可变。初始化后，可以发生变化。在多线程的访问时，会使用到锁。
可以定义event，来监视数值的变化。
// Immutable vs mutable
println("--- Immutable vs mutable ---")
val listImm = 1 to 5
println("Immutable list: cannot do: listImm(0) = 100")
println("Immutable list: " + listImm)
val listMutable = scala.collection.mutable.MutableList[Int](1,2,3,4,5)
listMutable(0) = 100
println("Mutable list: " + listMutable)
输出：
--- Immutable vs mutable ---
Immutable list: cannot do: listImm(0) = 100
Immutable list: Range(1, 2, 3, 4, 5)
Mutable list: MutableList(100, 2, 3, 4, 5)
Seq vs Set vs Map
Seq, Set, Map都是trait。
Seq: 对象可以重复。
Set: 对象不能重复。
Map: 是一个key-value实现，key不能重复。
LinearSeq vs IndexedSeq
LinearSeq, IndexedSeq都是trait。
LinearSeq: 提供高效head and tail的分割.
IndexedSeq: 提供高效的随机访问。
// Support head and tail
println("--- head and tail ---")
val list1 = Seq(1, 2, 3)
println(list1)
println("head and tail: split head and tail.")
list1 match {
case h::t => println("head: " + h + "
tail: " + t)
}
输出：
--- head and tail ---
List(1, 2, 3)
head and tail: split head and tail.
head: 1
tail: List(2, 3)
TreeSet vs HashSet vs BitSet
TreeSet, HashSet, BitSet都是class。
TreeSet: 一个树的Set实现。通过值的大小判断，需要一个implicit Ordering的实现。
HashSet: 一个Set实现, 使用Hash值来确定对象的唯一性。
BitSet: 一个只存储Long的Set实现，返回boolean值。用于管理大量的标志位。
// BitSet
println("--- BitSet ---")
println("BitSet: Used to store and access a large amount of flags.")
val bitSet = scala.collection.mutable.BitSet(1,3,4)
bitSet.remove(4)
bitSet.add(5)
println(bitSet)
for(i <- (1 to 5)) println("BitSet: " + i + ": " + bitSet(i))
输出：
--- BitSet ---
BitSet: Used to store and access a large amount of flags.
BitSet(1, 3, 5)
BitSet: 1: true
BitSet: 2: false
BitSet: 3: true
BitSet: 4: false
BitSet: 5: true
TreeMaps vs HashMaps
TreeMaps, HashMaps都是class。
TreeMaps: 一个Tree的Map实现。
HashMaps: 一个Hash key的Map实现。
Vector vs List vs Stream
Vector, List, Stream都是immutable。
Vector: 对于随机访问性能最好。推荐使用。
List: 对于head/tail的访问性能最好。
Stream: lazy估值，主要用于无限数列(infinite sequences)。
// Stream
println("--- Stream ---")
val fibs: Stream[Int] = {
def f(a: Int, b: Int): Stream[Int] = a #:: f(b, a + b)
f(0, 1)
}
println("Stream: is lazy: " + fibs)
fibs(5)
println("Stream: after get 5: " + fibs)
println("--- ")
println("Stream: an infinite stream of incrementing numbers starting from 1 ")
println(List("a", "b", "c") zip (Stream from 1))
输出：
--- Stream ---
Stream: is lazy: Stream(0, ?)
Stream: after get 5: Stream(0, 1, 1, 2, 3, 5, ?)
---
Stream: an infinite stream of incrementing numbers starting from 1
List((a,1), (b,2), (c,3))
Views
Views类似于数据库的view，lasy，性能很好。
map vs zip vs drop/take vs filter vs group vs sliding
map 每个元素到一个函数，把所有函数的结果组成一个新的collection
println("Map: " + listMap + " to: " + listMap.map(x => x * x))
println(listMap map (x => x * x))
输出：
--- map ---
Map: Range(1, 2, 3, 4, 5) to: Vector(1, 4, 9, 16, 25)
Vector(1, 4, 9, 16, 25)
filter：生成一个条件过滤后的Range
// filter
println("--- filter ---")
val listFilter = (1 to 10)
println("filter: " + listFilter + " to: " + listFilter.filter(x => x % 2 == 0))
println(listFilter filter (x => x % 2 == 0))
输出：
--- filter ---
filter: Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) to: Vector(2, 4, 6, 8, 10)
Vector(2, 4, 6, 8, 10)
drop & filter：从当前的List中选取一段，生成一个Range
// drop and take
println("--- drop and take ---")
val listTake = (1 to 10)
println("take: " + listTake + " to: " + listTake.drop(5).take(3))
println(listTake drop(5) take(3))
输出：
--- drop and take ---
take: Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) to: Range(6, 7, 8)
Range(6, 7, 8)
zip: 将两个List做列合并。
// zip
println("--- zip ---")
val listZip1 = (1 to 5)
val listZip2 = List("A", "B", "C", "D", "E")
println("Zip: " + listZip1 + " and " + listZip1 + " to: " + listZip1.zip(listZip2))
println(listZip1 zip listZip2)
输出：
--- zip ---
Zip: Range(1, 2, 3, 4, 5) and Range(1, 2, 3, 4, 5) to: Vector((1,A), (2,B), (3,C), (4,D), (5,E))
Vector((1,A), (2,B), (3,C), (4,D), (5,E))
grouped: 将collection按照指定的size组合成多个Vector，返回这个List的iterator。
// grouped
println("--- grouped ---")
val listgroup = (1 to 10)
val listgroupIterator = listgroup.grouped(3)
println("grouped: " + listgroup + " with size 3 to: " + listgroupIterator)
listgroupIterator foreach println
输出：
--- grouped ---
grouped: Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) with size 3 to: non-empty iterator
Vector(1, 2, 3)
Vector(4, 5, 6)
Vector(7, 8, 9)
Vector(10)
sliding: 将collection按照指定的size组合成一个滑动的块，返回这个块的iterator。
// sliding
println("--- sliding ---")
val listSliding = (2 to 10 by 2)
val listSlidingIterator = listSliding.sliding(3)
println("sliding: " + listSliding + " with size 3 to: " + listSlidingIterator)
listSlidingIterator foreach println
println("----")
println("sliding: tails")
listSliding.tails foreach println
输出：
--- sliding ---
sliding: Vector(2, 4, 6, 8, 10) with size 3 to: non-empty iterator
Vector(2, 4, 6)
Vector(4, 6, 8)
Vector(6, 8, 10)
----
sliding: tails
Vector(2, 4, 6, 8, 10)
Vector(4, 6, 8, 10)
Vector(6, 8, 10)
Vector(8, 10)
Vector(10)
Vector()
reduce vs reduceLeft vs reduceRigh vs fold vs foldLeft vs foldRight vs scan vs scanLeft vs scanRight
都适用于cumulate计算。
reduce, reduceLeft, reduceRight: 计算一个单独的累计结果。
fold, foldLeft, foldRight: 计算一个单独的累计结果，带一个起始值。
scan, scanLeft, scanRight: 得到的是一个List。List的长度和以前一样，分别是对应的单步累计结果。有一个起始种子。
reduce, fold, scan: 用于并行计算。
reduceLeft, foldLeft, scanLeft: 从前到后线性计算。
reduceRight, foldRight, scanRight: 从后到前线性计算。
foldLeft是线性计算。
// fold & reduce & scan
println("--- fold & reduce & scan ---")
val listAdd = List(1,2,3,4,5)
def addOp(a: Int, b: Int): Int = {
println(a + ":" + b)
a + b
}
println("--- reduce")
println("reduce: " + listAdd + " to: " + listAdd.par.reduce(addOp(_, _)))
println("--- reduceLeft")
println("reduceLeft: " + listAdd + " to: " + listAdd.reduceLeft(addOp(_, _)))
println("--- reduceRight")
println("reduceRight: " + listAdd + " to: " + listAdd.reduceRight(addOp(_, _)))
输出：
--- fold & reduce & scan ---
--- reduce
1:2
4:5
3:9
3:12
reduce: List(1, 2, 3, 4, 5) to: 15
--- reduceLeft
1:2
3:3
6:4
10:5
reduceLeft: List(1, 2, 3, 4, 5) to: 15
--- reduceRight
4:5
3:9
2:12
1:14
reduceRight: List(1, 2, 3, 4, 5) to: 15
println("--- fold")
println("fold: " + listAdd + " to: " + listAdd.par.fold(100)(addOp(_, _)))
println("--- foldLeft")
println("foldLeft: " + listAdd + " to: " + listAdd.foldLeft(100)(addOp(_, _)))
println("--- foldRight")
println("foldRight: " + listAdd + " to: " + listAdd.foldRight(100)(addOp(_, _)))
输出：
--- fold
100:1
100:2
100:5
100:3
100:4
101:102
104:105
103:209
203:312
fold: List(1, 2, 3, 4, 5) to: 515
--- foldLeft
100:1
101:2
103:3
106:4
110:5
foldLeft: List(1, 2, 3, 4, 5) to: 115
--- foldRight
5:100
4:105
3:109
2:112
1:114
foldRight: List(1, 2, 3, 4, 5) to: 115
println("--- scan")
println("scan: " + listAdd + " to: " + listAdd.par.scan(100)(addOp(_, _)))
println("--- scanLeft")
println("scanLeft: " + listAdd + " to: " + listAdd.scanLeft(100)(addOp(_, _)))
println("--- scanRight")
println("scanRight: " + listAdd + " to: " + listAdd.scanRight(100)(addOp(_, _)))
输出：
--- scan
4:5
1:2
3:4
3:9
3:3
3:7
3:12
100:1
3:3
1:2
10:5
6:4
scan: List(1, 2, 3, 4, 5) to: ParVector(100, 101, 3, 6, 10, 15)
--- scanLeft
100:1
101:2
103:3
106:4
110:5
scanLeft: List(1, 2, 3, 4, 5) to: List(100, 101, 103, 106, 110, 115)
--- scanRight
5:100
4:105
3:109
2:112
1:114
scanRight: List(1, 2, 3, 4, 5) to: List(115, 114, 112, 109, 105, 100)
参照
- Scala in Depth by ScalaJoshua D. Suereth
- Community-driven documentation for Scala
- Collection Overview