scala中常用的10个方法

 操作 Scala 集合时，一般会进行两类操作：转换操作（transformation ）和行动操作（actions）（有些人喜欢叫他为聚合操作）。第一种操作类型将集合转换为另一个集合，第二种操作类型返回某些类型的值。

1、map

map 是 Scala 集合最常用的一个函数。它的功能十分强大：

[html]  view plain  copy

1. valnumbers= Seq(1,2,3,4,5,6)   
2. //List(2, 4, 6, 8, 10, 12)  
3. numbers.map(n=> n * 2)   
4. valchars= Seq('a','b','c','d')  
5. //输出为List(A, B, C, D)  
6. chars.map(ch=> ch.toUpper)  

map  函数的逻辑是遍历集合中的元素并对每个元素调用函数。你也可以不调用任何函数，保持返回元素本身，但这样  map 无法发挥作用，因为你在映射过后得到的是同样的集合。

2、flatten

flatten可以把嵌套的结构展开.  当有一个集合的集合， 然后你想对这些集合的所有元素进行操作时，就会用到 flatten。

如果一个集合里存放的是元组，则没法压平，只能压平集合

val   abcd   =   Seq( 'a' ,   'b' ,   'c' ,   'd' ) val   efgj   =   Seq( 'e' ,   'f' ,   'g' ,   'h' ) val   ijkl   =   Seq( 'i' ,   'j' ,   'k' ,   'l' ) val   mnop   =   Seq( 'm' ,   'n' ,   'o' ,   'p' ) val   qrst   =   Seq( 'q' ,   'r' ,   's' ,   't' ) val   uvwx   =   Seq( 'u' ,   'v' ,   'w' ,   'x' ) val   yz    =   Seq( 'y' ,   'z' ) val   alphabet   =   Seq(abcd, efgj, ijkl, mnop, qrst, uvwx, yz)   // List(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) alphabet.flatten

3、flatmap

flatMap结合了map和flatten的功能。接收一个可以处理嵌套列表的函数，然后 把返回结果连接起来

flatMap使用流程：内部成员进行 map ， map 的结果为一个返回 ，然 后在如果的基础上进行 flat 将 map 操作后的结果进行合并；可以拆分成map+flatten

[html]  view plain  copy

1. valabcd= Seq('a','b','c','d')  
2. //List(A, a, B, b, C, c, D, d)  
3. abcd.flatMap(ch=> List(ch.toUpper, ch))  
4. scala> List(List(1,2),List(3,4)).flatMap(x=>x.map(x=>x*2))  
5. res5: List[Int] = List(2, 4, 6, 8)  

4、foreach和forall（对集合条件检查）

foreach和map相似，只不过它没有返回值或者说返回值是Unit，foreach只要是为了对参数进行作用。

比如 names.foreach{name=>println(name)}

有一个场景大家都知道，即确保集合中所有元素都要符合某些要求，如果有哪怕一个元素不符合条件，就需要进行一些处理：

[html]  view plain  copy

1. valnumbers=Seq(3,7,2,9,6,5,1,4,2)   
2. //ture  
3. numbers.forall(n=> n < 10)   
4. //false  
5. numbers.forall(n=> n > 5)  而 forall 函数就是为处理这类需求而创建的。  

5.filter过滤

过滤出 集合中符合特定条件的子集

让我们举例说明：过滤一个数字 List，只获取奇数的元素。

val   numbers   =   Seq( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 )   numbers.filter(n   = > n   %   2   ==   0 )    //seq(2,4,6,8,10)

然后加大难度，我想获取页数大于120页的书。 

case   class   Book(title :   String, pages :   Int) val   books   =   Seq(   Book( "Future of Scala developers" ,   85 ),   Book( "Parallel algorithms" ,   240 ),   Book( "Object Oriented Programming" ,   130 ),   Book( "Mobile Development" ,   495 ) )   books.filter(book   = > book.pages > =   120 )

实际上，过滤是一个转换类型的方法，但是比运用  min 和  max 方法简单

6.对集合进行分组partition

你是否尝试过将一个集合按一定的规则拆分成两个新的集合？比如，我们把某个集合拆分成偶数集和奇数集，partition 函数可以帮我们做到这一点：

val   numbers   =   Seq( 3 ,   7 ,   2 ,   9 ,   6 ,   5 ,   1 ,   4 ,   2 ) //(List(2, 6, 4, 2), List(3, 7, 9, 5, 1)) numbers. partition (n   = > n   %   2   ==   0 ) // (List(Book(Parallel algorithms,240), Book(Object Oriented Programming,130)),      List(Book(Future of Scala developers,85), Book(Mobile Development,495))) case   class   Book(title :   String, pages :   Int) val   books   =   Seq(   Book( "Future of Scala developers" ,   85 ),   Book( "Parallel algorithms" ,   240 ),   Book( "Object Oriented Programming" ,   130 ),   Book( "Mobile Development" ,   495 ) ) val  boo= books.partition(book =>book.pages %  2 == 0 )   println (boo)

7.fold讲解

另一个流行的操作是  fold 。 在 Scala 的上下文中，通常可以考虑  foldLeft  和  foldRight 。他们是从不同的方面做同样的工作：

[html]  view plain  copy

1. valnumbers=Seq(1,2,3,4,5)  
2.  //15  
3. numbers.foldLeft(0)((res, n) => res + n)  

在第一对括号中，我们放一个起始值。 在第二对括号中，我们定义需要对数字序列的每个元素执行的操作。 第一步，n = 0，然后它根据序列元素变化。 另一个关于 foldLeft 的例子，计算字符数：

[html]  view plain  copy

1. val words = Seq("apple", "dog", "table")   
2. //13  
3. words.foldLeft(0)((resultLength, word) => resultLength + word.length)  
4. val words = Seq("apple", "dog", "table")   
5. //13  
6. words.foldLeft(0)((resultLength, word) => resultLength + word.length)  

比较fold和reduce的功能

补充：reduce的使用:从左边加减，默认调用自己的reduceLeft()，方法。

  val a = List(1,2,3,5,6)
 val a = List(1,2,3,5,6)
  val b = a.reduce(_+_) //求和21，类似a.sum
  val c = a.reduce(_-_)//求差。-19
  同理：(_*_) (_/_)
  val b = a.reduce(_+_) //求和21，类似a.sum
  val c = a.reduce(_-_)//求差。-19
  同理：(_*_) (_/_)

8.zip,拉链

zip方法将两个集合结合在一起

scala>  List('a,'b,'c).zip(List(1,2,3))

res32: List[(Symbol, Int)] = List(('a,1), ('b,2), ('c,3))

zipWithIndex将元素和下标结合在一起

scala> List(2,3,4,5).zipWithIndex

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

9.动作函数，求最大值，最小值

   

Scala 推荐了一个很赞的解决方案：

[html]  view plain  copy

1. valnumbers=Seq(11,2,5,1,6,3,9)   
2. numbers.max//11  
3. numbers.min//1  
4. 但实际操作的数据更加复杂。下面我们介绍一个更高级的例子，其中包含一个书的序列（查看源代码案例）。  
5. caseclassBook(title:String, pages:Int)   
6. valbooks=Seq(  
7.   Book("Future of Scala developers",85),  
8.   Book("Parallel algorithms",240),  
9.   Book("Object Oriented Programming",130),  
10.   Book("Mobile Development",495)  
11. )   
12. //Book(Mobile Development,495)  
13. books.maxBy(book=> book.pages)  
14. //Book(Future of Scala developers,85)  
15. books.minBy(book=> book.pages)  

如上所示， minBy  &  maxBy 方法解决了复杂数据的问题。你只需选择决定数据最大或最小的属性。

10.欧拉图函数（Euler Diagram函数）

    差集、交集和并集。以下示例能很好地解释 Euler Diagram 函数：

val   num 1   =   Seq( 1 ,   2 ,   3 ,   4 ,   5 ,   6 ) val   num 2   =   Seq( 4 ,   5 ,   6 ,   7 ,   8 ,   9 )   //List(1, 2, 3) num 1 .diff(num 2 )     //List(4, 5, 6) num 1 .intersect(num 2 )     //List(1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9) num 1 .union(num 2 )

上述示例中的  union 保留了重复的元素。如果我们不需要重复怎么办？这时可以使用  distinct 函数：

//List(1, 2, 3, 4, 5, 6, 7, 8, 9)

num1.union(num2).distinct