Scala 速通语法（十一）| 数据结构

Scala 速通语法（十一）| 数据结构

map映射函数

• map函数返回一个新集合
• 将集合的元素 依次遍历 传递到（）内函数中

  //创建list
  val list = List(1, 2, 3, 4, 5)
  //每个元素 * 2
  println(list.map(_ * 2))

flatmap 映射：flat 即压扁，压平，扁平化映射

• flatmap 将集合中所有元素进行扁平化操作，即把所有元素打散

 val names = List("Alice", "Bob", "Nick")
  //需求是将 List 集合中的所有元素，
  val names2 = names.flatMap(upper)
  println("names2=" + names2)
  }

  def upper( s : String ) : String = {
    s. toUpperCase
  }
  //输出： names2=List(A, L, I, C, E, B, O, B, N, I, C, K)

filter 集合元素的过滤

• filter 将集合中符合条件的元素 放置在新集合中
• 传入函数返回是 Boolean值

    //返回首字母是A的字符串
    val name2 = names.filter(_.startsWith("A"))
    println(name2)

reduce/reduceLeft/reduceRight

• reduce 将集合中的值前两个值传入函数得出值再传入第一个参数，第二个参数用集合下一个值
• 默认从左到右 即 reduceLeft
• 要求传入函数返回值为集合元素同类型

   val list = List(1, 2, 3, 4, 5)
   //list累加
   println(list.reduce(_ + _))

fold/foldLeft/foldRight 折叠

• fold 传入一个初始值作为第一个参数 函数将上一步返回的值作为函数的第一个参数继续传递参与运算，直到 list 中的所有元素被遍历
• 可以把 reduceLeft 看做简化版的 foldLeft
• foldLeft 和 foldRight 缩写方法分别是：/:和:\

  val list = List(1, 2, 3, 4, 5)
  println(list.fold(10)(_ + _ ))
  
  var i6 = (1 /: list4) (minus) // =等价=> list4.foldLeft(1)(传入函数)
  i6 = (100 /: list4) (minus) //=等价=> list4.foldLeft(100)(传入函数)

scan 扫描

• scan 扫描，即对某个集合的所有元素做 fold 操作，但是会把产生的所有中间结果放置于一个集合中保存
• 会保存中间结果

  val list = List(1, 2, 3, 4, 5)
  val list2 = list.scan(0)(_ + _)
  println(list2)
  
  //结果 List(0, 1, 3, 6, 10, 15)

拉链(合并)

• zip 在开发中，当我们需要将两个集合进行 对偶元组合并，可以使用拉链

  // 拉链
  val list1 = List(1, 2, 3)
  val list2 = List(4, 5, 6)
  val list3 = list1.zip(list2) // (1,4),(2,5),(3,6)
  println("list3=" + list3)

拉链的本质就是两个集合的合并操作，合并后每个元素是一个 对偶元组
如果两个集合个数不对应，会造成数据丢失
集合不限于 List, 也可以是其它集合比如 Array
如果要取出合并后的各个对偶元组的数据，可以按照元组方式遍历

iterator 迭代器

val iterator = List(1, 2, 3, 4, 5).iterator // 得到迭代器

//遍历
while (iterator.hasNext) {
  println(iterator.next())
}

//遍历2
for(enum <- iterator) {
  println(enum) //
}

Stream 流

• stream 是一个集合。这个集合，可以用于存放无穷多个元素，但是这无穷个元素并不会一次性生产出来，而是需要用到多大的区间，就会动态的生产，末尾元素遵循 lazy 规则

//创建 Stream
def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm(n + 1)
val stream1 = numsForm(1)
println(stream1) 

//创建的集合的第一个元素是 n , 后续元素生成的规则是 n + 1
//后续元素生成的规则是指定的 ，比如 numsForm( n * 4)...

View 视图

• Stream 的懒加载特性，也可以对其他集合应用 view 方法来得到类似的效果
• view 方法产出一个总是被懒执行的集合
• view 不会缓存数据，每次都要重新计算，比如遍历 View 时

//请找到 1-100 中，数字倒序排列 和它本身相同的所有数。(1 2, 11, 22, 33 ...)

//如果这个数，逆序后和原来数相等，就返回 true,否则返回 false
def eq(i: Int): Boolean = {
  println("eq 被调用..")
  i.toString.equals(i.toString.reverse)
}


//使用 view，来完成这个问题,程序中，对集合进行 map,filter,reduce,fold...
//你并不希望立即执行，而是在使用到结果才执行，则可以使用 view 来进行优化.
val viewSquares2 = (1 to 100).view.filter(eq)
  println(viewSquares2)
  //遍历
  for (item <- viewSquares2) {
    println("item=" + item)
  }
}