Scala集合中的函数(扩展)

阅读目录

• 1.拉链（zip）
• 2.迭代器（Iterator）
• 3.流（stream）
• 4.视图（view）
• 5.并行集合

 

回到顶部

1.拉链（zip）

将两个集合进行 对偶元组合并，可以使用拉链

?

1 2 3 4 5 6 7 8

object Demo_031 {   def main(args: Array[String]): Unit = {     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
• 如果要取出合并后的各个对偶元组的数据，可以遍历

?

1 2 3

for(item<-list3){   print(item._1 + " " + item._2) //取出时，按照元组的方式取出即可   }

　　

回到顶部

2.迭代器（Iterator）

 通过iterator方法从集合获得一个迭代器，通过while循环和for表达式对集合进行遍历

 

 

 实例：

?

1 2 3 4 5 6 7 8 9 10 11 12 13

object Demo_032 {   def main(args: Array[String]): Unit = {     val iterator = List(1, 2, 3, 4, 5).iterator // 得到迭代器     println("--------遍历方式1 -----------------")     while (iterator.hasNext) {       println(iterator.next())     }     println("--------遍历方式2 for -----------------")     for (enum <- iterator) {       println(enum) //     }   } }

回到顶部

3.流（stream）

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

 

使用tail，会动态的向stream集合按规则生成新的元素

?

1 2 3 4 5 6 7 8 9 10 11

object Demo_033 {   def main(args: Array[String]): Unit = {     def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm(n + 1)     val stream1 = numsForm(1)     println(stream1) //     //取出第一个元素     println("head=" + stream1.head) //     println(stream1.tail) //注意不能使用stream.last，否则会陷入无限循环     println(stream1) //   } }

　　运行结果

 

实例：使用map映射stream的元素并进行一些计算

?

1 2 3 4 5 6 7 8 9

object Demo_034 {   def main(args: Array[String]): Unit = {     def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm(n + 1)     def multi(x:BigInt) : BigInt = {       x * x     }     println(numsForm(5).map(multi)) //? (25,?)   } }

　　输出

回到顶部

4.视图（view）

 Stream的懒加载特性，也可以对其他集合应用view方法来得到类似的效果，具有如下特点：

• view方法产出一个总是被懒执行的集合。
• view不会缓存数据，每次都要重新计算，比如遍历View时。

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13

object Demo_035 {   def main(args: Array[String]): Unit = {     def eq(i: Int): Boolean = {       i.toString.equals(i.toString.reverse)     }     //说明: 没有使用view     val viewSquares1 = (1 to 100).filter(eq)     println(viewSquares1)     //使用view     val viewSquares2 = (1 to 100).view.filter(eq)     println(viewSquares2)   } }

　　输出结果

回到顶部

5.并行集合

 

 应用案例   parallel

• 打印1~5

?

1 2 3 4 5 6 7 8 9 10 11

object Demo_036 {   def main(args: Array[String]): Unit = {     def method(i:Int): Unit ={        print("\t"+i)     }     (1 to 5).foreach(method)     println()     (1 to 5).par.foreach(method)//并行方式输出     } }

　　输出

 

•  查看并行集合中元素访问的线程

?

1 2 3 4

val result1 = (0 to 100).map{case _ => Thread.currentThread.getName} val result2 = (0 to 100).par.map{case _ => Thread.currentThread.getName} println(result1) println(result2)

　　

---

如果您觉得阅读本文对您有帮助，请点一下“推荐”按钮，您的“推荐”将是我最大的写作动力！欢迎各位转载，但是未经作者本人同意，转载文章之后必须在文章页面明显位置给出作者和原文连接，否则保留追究法律责任的权利。