(Scala 四.2 ) 数据结构 集合操作

import scala.collection.mutable
//########################### 4.11 将函数映射到集合 #################################

/**
  * Map
  * 将集合中的每个元素,在一元函数中进行映射
  */
val names = List("Peter", "Paul", "Mary")
//    映射  (匿名函数)
names.map(_.toUpperCase())
names.map((_, 1))



/**
  * flatMap
  * 处理每个元素分别产生一个集合,并将集合元素串接在一起
  */

//参数s:传入的元素      返回 构建Vector(大写,小写)
def ulcase(s: String) = Vector(s.toUpperCase(), s.toLowerCase())

names.flatMap(ulcase)


//########################### 4.12 化简、折叠、扫描 #################################
/**
  * 将二元函数应用于集合中的元素
  */

/**
  * 化简
  */
List(1, 7, 2, 9).reduceLeft(_ - _)
//((1 - 7) - 2) - 9 = -17
List(1, 7, 2, 9).reduceRight(_ - _)
//1 - (7 - (2 - 9)) = -13
List(1, 7, 2, 9).reduceLeft(_ + _)
//1 + 7 + 2 + 9  = 19


/**
  * 折叠
  */
List(1, 7, 2, 9).foldLeft(0)(_ - _)
//0 - 1 - 7 - 2 - 9 = -19
List(1, 7, 2, 9).foldRight(0)(_ - _)
//1- (7 - (2 - (0 - 9))) = -13

List(1, 7, 2, 9).reverse
List(1, 7, 2, 9).reverse.foldLeft(0)(_ - _)
//0 - 9 - 2 - 7 - 1 = -19

var a = 1
var b = 2

def sub(a: Int, b: Int) = (b, a)

val freq = scala.collection.mutable.Map[Char, Int]()
for (c <- "Mississippi") {
  freq(c) = freq.getOrElse(c, 0) + 1
  println(freq)
}

for (c <- "Mississippi") freq(c) = freq.getOrElse(c, 0) + 1


(Map[Char, Int]() /: "Mississippi") {
  (m, c) => m + (c -> (m.getOrElse(c, 0) + 1))
}


/**
  * 扫描
  * 简化和折叠的结合,得到的是包含所有中间结果的集合
  */
(1 to 10).scanLeft(0)(_ + _)
(1 to 10).scanRight(0)(_ + _)

//########################### 4.13 拉链操作 #################################
/**
  * 拉链操作
  * 见异思迁,把2ge集合的元素根据索引位置绑在一块,大小取决于小的那个长度
  */
val symbols = Array("<", "-", ">")
val counts = Array(2, 10, 3, 4)

val pairs = symbols.zip(counts)

"Scamza".zipWithIndex
"Scamza".zipWithIndex.max //寻找hash值最大的字符和其索引
"Scamza".zipWithIndex.max._2

//########################### 4.14 迭代器 #################################
/**
  * 迭代器
  */

val it = counts.iterator
while (it.hasNext)
  println(it.next())


for (elem <- counts)
  println(elem)



//########################### 4.15 流 #################################

/**
  * 流Stream 只有在需要的时候才汇去计算下一个元素
  * 是一个尾部被懒计算的不可变列表
  * Construct a stream consisting of a given first element followed by elements from a lazily evaluated Stream.
  * 构造一个流，该流由给定的第一个元素和来自延迟计算流的元素组成。
  * def #::(hd: A): Stream[A] = cons(hd, tl)
  */
def numsForm(n: BigInt): Stream[BigInt] = n #:: numsForm(n + 1)

val tenOrMore = numsForm(10)

tenOrMore.tail
tenOrMore.tail.tail.tail


val squeares = numsForm(5).map(x => x * x)
squeares.take(5)
squeares.take(5).force
tenOrMore



//########################### 4.16 懒视图 #################################
/**
  * 用view方法可以对其它集合实现懒加载
  */
val palindromicSquares =
  (1 to 1000).view.map(x => {
    x * x
  }).filter(x => x.toString == x.toString.reverse)
palindromicSquares.take(100).mkString(",")

//########################### 4.17  与java集合的互操作总结 #################################


//########################### 4.18  线程安全的集合 #################################
/**
  * 在多线程进行集合操作时,并发问题很突出
  * Scala类库提供了6个并发特质
  * 通过混入这些集合,可以让集合的操作变成同步
  */
//SynchronizedBuffer
//SynchronizedMap
//SynchronizedPriorityQueue
//SynchronizedQueue
//SynchronizedSet
//SynchronizedStack


val scores = new mutable.HashMap[String, Int] with mutable.SynchronizedMap[String, Int]


//########################### 4.19  并行集合 #################################
/**
  * par 将集合转为并行集合
  * seq 将并行集合转为集合
  */
(1 to 5).foreach {
  it => println(Thread.currentThread()); println("^" + it)
}


(1 to 5).par.foreach {
  it => println(Thread.currentThread()); println("^" + it)
}


(1 to 5).par.map(_ + 100).seq
(1 to 5).par.map(_ + 100)