reactive programming 1.3 Recap- Collections

1. 集合框架概述

     Iterable <---------  Seq, Set, Map

      Seq  <--------- IndexedSeq, linkedSeq

      indexedSeq <------ Vectors, Array ,String

      linkedSeq <------- List

2.集合常见操作

  map， flatMap, filter

  foldLeft, foldRight

3. 实现Map操作

  abstract class List[+T] {
    def map[U](f: T => U): List[U] = this match {
      case x :: xs => f(x) :: xs.map(f)
      case Nil => Nil
    }
  }

实现flatMap,只有两点不同：1.f返回的是List 2.prepend改成contact

abstract class List[+T] {
  def flatMap[U](f:T=>List[U]):List[U] = this match {
    case List(x::xs) => f(x) ++ flatMap(xs)
    case Nil => Nil
  }
}

实现filter

abstract class List[+T] {
  def filter(f:T => Boolean): List[T] = this match {
    case List(x::xs) => if (f(x)) x:: xs.filter(f) else xs.filter(f)
    case Nil => Nil
  }
}

filter返回类型和原List是一样的

4. ++ 和 :::的不同

package week1

object Test {
  List(1,2) ::: List(3,4)                         //> res0: List[Int] = List(1, 2, 3, 4)
  List(1,2) ++ List(3,4)                          //> res1: List[Int] = List(1, 2, 3, 4)
 }

:::是右操作符，执行的是prepend操作

++是左操作符，执行的是append操作

5.Scala没有for循环，只有for表达式

 scala将for 表达式转化成map,flatmap或filter来执行

for (x <- e1) yield e2  被转化成  e1.map(x => e2)

for(x <- e1 if f; s) yield e2  被转化成  for (x <- e1.withFilter(x =>f); s) yield e2

6.for表达式可以与模式匹配一起用

  val data: List[JSON] = ...
  for {
    JObj(bindings) <- data
    JSeq(phones) = bindings("phoneNumbers")
    JObj(phone) <- phones
    JStr(digits) = phone("number")
    if digits startsWith "212"
  } yield (bindings("firstName"), bindings("lastName"))

7. flatMap, map,filter到for 语句的转换。找出100以内所有 i +j 为素数的i,j组合

object Main extends App {
  def isPrime(n: Int):Boolean =  (2 to n-1) forall (d => n %d != 0)
  val ls = (1 to 10) flatMap (i => (1 to 10) filter (j => isPrime(i+j)) map (j =>  (i, j)))
  println(ls)
}

虽然达到了目的，可读性却很差，改用for循环

package week1

object Main extends App {
  def isPrime(n: Int):Boolean =  (2 to n-1) forall (d => n %d != 0)
  val ls = for {
      i <- 1 to 10
      j <- 1 to 10
      if isPrime(i +j )
  } yield (i, j)
      
  println(ls)
}

8. 编译器做的转换

for (x <- e1 if f; s) yield e2
for (x <- e1.withFilter(x => f); s) yield e2

for (x <- e1; y <- e2; s) yield e3
e1.flatMap(x => for (y <- e2; s) yield e3)

带有模式匹配的for语句，模式被改写成传递给withFilter的函数

pat <- expr
x <- expr withFilter {
case pat => true
case _ => false
} map {
case pat => x
}