Scala数据结构

主要的集合特质

Scala同时支持可变集合和不可变集合，优先采用不可变集合。集合主要分为三大类：序列（List），集（set），映射（map）。所有的集合都扩展自Iterable特质。对几乎所有的集合类，Scala都同时提供了可变和不可变版本。

Seq是一个有先后次序的值的序列。IndexedSeq能够通过整形下表快速访问
Set是一个没有先后顺序的集合。
Map是一组键值对偶，SortedMap按照键的排序访问其中的实体。

数组

定长数组

val nums  = new Array[Int](10)

变长数组

var b = ArrayBuffer[Int]()

Array与ArrayBuffer的互转

ArrayBuffer = Array.toBuffer

Array = ArrayBuffer.toArray

//遍历数组

for (i <- nums) println(i)

for (i <- 0 to nums.length - 1) println(nums(i))

for (i <- 0 until nums.length) println(nums(i))

数组转换

转换动作不会修改原数组，而是产生一个新的数组

多维数组

和java一样，多维数组通过数组的数组来实现，可以使用ofDim方法实现

val array = Array.ofDim[Int](2, 3)

//赋值

array(0)(0)=10

array(0)(1)=11

array(0)(2)=12

array(1)(0)=20

array(1)(1)=21

array(1)(2)=22

//遍历

for (i <- array; j <- i) println(j)

和java数组的互操作

Scala数组是通过java进行实现的，所以可以进行互相转换操作，使用AsJavaConverters 或者 AsScalaConverters 进行转换

import scala.collection.mutable.ArrayBuffer

import scala.collection.JavaConverters._

val a = ArrayBuffer("hello", "world")

//转为Java对象 b.command()可以调用java的方法

val b = new ProcessBuilder(a.asJava)

//转为Scala

val sb = b.command().asScala

映射

映射就是KV的集合，类似于Java中的Map

映射操作

import scala.collection.mutable

//不可变的构造映射

val map = Map("name" -> "upuptop", "age" -> 10)

//可变映射

val map2 = scala.collection.mutable.Map("name" -> "upuptop", "age" -> 10)

//空映射

val map3 = new mutable.HashMap[String, Int]()

//对偶

"name" -> "upuptop"

//对偶元组

var map4 = Map(("name" -> "upuptop"), ("age" -> 10))

//获取值

println(map("name"))

//遍历值

for (i <- map) println(i)

//同时遍历键值对

for ((k, v) <- map) println(s"key:${k},value:${v}")

//遍历所有的键

for (k <- map.keys) println(k)

//遍历所有的值

for (v <- map.values) println(v)

//简便操作

map.foreach(println(_))

注意：

根据键获取值，如没有键会抛异常，可以通过contains方法进行判断是否存在键
不可变映射不能更新

和Java的互操作

与数组相同

元组

元组是不同类型值的聚集，元组使用_1、_2进行访问

元组的下标识从1开始，不是从0开始

//定义元组

var aa = ("app", 123, false)

//访问元组

aa._1

aa._2

aa._3

//打印结果

aa: (String, Int, Boolean) = (app,123,false)

res0: String = app

res1: Int = 123

res2: Boolean = false

注意

元组的下标识从1开始，不是从0开始
aa._1 可以写成aa _1(把点换成空格)，不能省略空格
元组可用于函数需要返回不止一个值的情况
可以把多个值绑在一起以便他们以后能够被一起处理

队列

队列是一个先进先出的结构

import scala.collection.mutable

var q = new mutable.Queue[Int]()

q += 1

q +=2

q ++= List(3,4,5)

//出队 删除 1

q.dequeue()

//入队 新加6

q.enqueue(6)

q

//获取第一个元素

q.head

//获取除了第一元素之外的其他元素

q.tail

打印结果：

import scala.collection.mutable

q: scala.collection.mutable.Queue[Int] = Queue()

res0: scala.collection.mutable.Queue[Int] = Queue(1)

res1: scala.collection.mutable.Queue[Int] = Queue(1, 2)

res2: scala.collection.mutable.Queue[Int] = Queue(1, 2, 3, 4, 5)

res3: Int = 1

res4: Unit = ()

res5: scala.collection.mutable.Queue[Int] = Queue(2, 3, 4, 5, 6)

res6: Int = 2

res7: scala.collection.mutable.Queue[Int] = Queue(3, 4, 5, 6)

堆栈

Stack 是一个先进后出的结构

import scala.collection.mutable

val s = new mutable.Stack[Int]();

//入栈

s.push(1,2,3,4)

//出栈

s.pop()

s

//取栈顶上的元素 但不出栈

s.top

//取除了栈顶的其他元素

s.tail

打印：

import scala.collection.mutable

s: scala.collection.mutable.Stack[Int] = Stack()

res0: scala.collection.mutable.Stack[Int] = Stack(4, 3, 2, 1)

res1: Int = 4

res2: scala.collection.mutable.Stack[Int] = Stack(3, 2, 1)

res3: Int = 3

res4: scala.collection.mutable.Stack[Int] = Stack(2, 1)

列表

如果List为空，用Nil来表示

val list1 = List(1, 2, 3)

//第一个元素

list1.head

//除了第一个元素的之后元素

list1.tail

//将9 放到list1这个列表的最前面

var list2 = 9 :: list1

list2

//组成9,4,2一个列表

var list3 = 9 :: (4 :: (2 :: Nil))

list3

打印结果：

list1: List[Int] = List(1, 2, 3)

res0: Int = 1

res1: List[Int] = List(2, 3)

list2: List[Int] = List(9, 1, 2, 3)

res2: List[Int] = List(9, 1, 2, 3)

list3: List[Int] = List(9, 4, 2)

res3: List[Int] = List(9, 4, 2)

集

元素不重复
无顺序，默认哈希
有需集（SortedSet，红黑树实现）

val set = Set(1, 2, 3, 3)

val set2 = set + 5

set

set.head

set.tail

打印结果：

set: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

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

res1: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

res2: Int = 1

res3: scala.collection.immutable.Set[Int] = Set(2, 3)

添加去除元素的操作符

向后:+或向前+:追加元素到序列中
添加+元素到无先后次序的集合中
用-移除元素（map只能加不能减）
用++或--来批量添加和移除元素
对于列表，优先使用::和:::
改值操作有+=,++=,-=,--=
集合可以使用&求交集，|并集
优先使用++、&、|、尽量不用 ++：、+=：、++=:

val set = Set(1, 2, 3, 3)

val set1 = Set(2, 3, 4)

//并集  1, 2, 3, 4

set | set1

//交集 2, 3

set & set1

常用方法

这些方法从不改变原有集合。他们返回一个与原集合类型相同的新集合

将函数映射到集合

将一元函数应用到集合中的每一个元素。

map应用于集合中的每一个元素，并产生转换后的一个新元素。

val names = List("peter", "Bob", "Mary")

//List(peter, bob, mary)  通过map方法，传入函数应用到每个元素上

names.map(_.toLowerCase)

flatMap方法同样应用于集合的每一个元素，对于每一个元素产生的一个集合，并将集合中的元素串接在一起。

val names = List("peter", "Bob", "Mary")

def ulcase(s: String) = Vector(s.toLowerCase(), s.toUpperCase())

//peter, PETER, bob, BOB, mary, MARY

names.flatMap(ulcase(_))

化简、折叠、扫描

将二元函数应用到集合中的元素

例如：

化简操作：

val list = List(1, 2, 3, 4, 5)

//(((1-2)-3)-4)-5 = -13

list.reduceLeft(_ - _)

//1-(2-(3-(4-5))) = 3

list.reduceRight(_ - _)

折叠操作

val list = List(1, 2, 3, 4, 5)

//0-1-2-3-4-5

list.foldLeft(0)(_ - _)

//1-(2-(3-(4-(5-0))))

list.foldRight(0)(_ - _)

求字符出现的次数

/*

  getOrElse

    第一个参数是key，如果该key存在，那么返回key对应的值

    第二个参数是默认值，如果key不存在，那么返回默认值

   freq += ('a' -> 0)

  //i: Int = 1

  val i = freq.getOrElse('u', 1)

  //a: Int = 0

  val a = freq.getOrElse('a', 1)

*/

val line = "upuptop"

var freq = scala.collection.mutable.Map[Char, Int]()

//循环赋值 如果字符存在那么拿到存储的值进行加1操作  如果没有存储 k为字符 v为1

for (i <- line) freq(i) = freq.getOrElse(i, 0) + 1

println(freq)

扫描操作：

扫描就是化简和折叠的结合。可以得到包含所有中间结果的集合：

var list = List(1, 2, 3, 4, 5)

list.scanLeft(0)(_ - _)

list.scanRight(0)(_ - _)

打印结果

list: List[Int] = List(1, 2, 3, 4, 5)

res0: List[Int] = List(0, -1, -3, -6, -10, -15)

res1: List[Int] = List(3, -2, 4, -1, 5, 0)

拉链操作

作用于两个集合，将对应的元素合并成一个元组。

var list = List(1, 2, 3, 4, 5)

var list2 = List(2, 3, 4, 5, 6)

//List((1,2), (2,3), (3,4), (4,5), (5,6))

list.zip(list2)

//List((1,0), (2,1), (3,2), (4,3), (5,4))

list.zipWithIndex

迭代器

使用迭代器进行集合遍历

var list = List(1, 2, 3, 4, 5)

val iterator = list.iterator

while (iterator.hasNext) {

  println(iterator.next())

}

或者：

for (i <- iterator) println(i)

流（不可变列表）

流Stream只有在需要的时候才会去计算下一个元素，是一个尾部被懒计算的不可变列表。

#::操作符用于返回流。

// #:: 返回一个流

def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm( n + 1 )

val tenOrMore = numsForm(10)

tenOrMore.tail

tenOrMore.head

// 获取最后一个元素

tenOrMore.tail.tail.tail

var squares = numsForm(5).map(x => x * x)

squares.take(5).force

//squares.force   不要尝试对一个无穷流的成员进行求值，OutOfMemoryError

懒视图

可以对其他集合使用view方法是集合具有懒执行的行为，该方法产出一个器方法总是被懒执行的集合、但是view不会缓存数据，每次都要重新计算

// 通过View的懒执行

val palindromicSquares = (1 to 100).view.map(x => {

  println(x);

  x * x

})

// Evaluates the first eleven

palindromicSquares.take(10).mkString(",")

// Contrast with streams

def squares(x: Int): Stream[Int] = {

  println(x);

  x * x

} #:: squares(x + 1)

val palindromicSquareStream = squares(0)

palindromicSquareStream(10)

// Caution

// Evaluates only the first ten

palindromicSquares.take(10).last

// Evaluates all elements

palindromicSquares(10)

与java集合互操作的总结

线程安全的集合

SynchronizedBuffer
SynchronizedMap
SynchronizedPriorityQueue
SynchronizedQueue
SynchronizedSet
SynchronizedStack

var scores = new mutable.HashMap[String,Int]() with mutable.SynchronizedMap[String,Int]

并行集合

Scala为了充分利用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算。

主要用的算法有：

divide and conquer：分治算法

Scala通过splitters，combiners等抽象层来实现。主要原理是将计算工作分解很多任务，分发给一些处理器去完成，并将它们处理结果合并返回

work stealing：Work Stealing算法

主要用于任务调度负载均衡。

并行集合位于scala.collection.parallel,跟不同集合一样

主要的实现类：

ParArray
ParHashMap
ParHashSet
ParRange
ParHashMap
ParHashSet
ParVector

通过par关键字将集合转为一个并行集合，并行集合的扩展自ParSeq、ParSet、ParMap特质的类型，所有的特质都是ParIterable的子类型，但并不是Iterable的子类型。所以不能将并行集合传递为预期的Iterable、Seq、Map的方法。可以通过 ser方法将并行集合转为串行集合

注意：在并行任务中，不要同时更新一个共享变量

操作符概述

1.如果想在变量名、类名、等定义中使用保留字，可以使用反引号：

val `val` = 42

2.A 操作符 B 等同于 A.操作符(B) 这种形式叫中置操作符

3.后置操作符：A 操作符等同于 A.操作符 ，如果操作符定义的时候不带() 则调用的时候不能加()

4.前置操作符，=、-、!、~等 操作符 A 等同于 A.unary_操作符

5.赋值操作符， A操作符= B 等同于 A = A 操作符 B