scala中常用的10个函数
操作 Scala 集合时，一般会进行两类操作：转换操作（transformation ）和行动操作（actions）（有些人喜欢叫他为聚合操作）。第一种操作类型将集合转换为另一个集合，第二种操作类型返回某些类型的值。
1、map
map 是 Scala 集合最常用的一个函数。它的功能十分强大：
valnumbers= Seq(1,2,3,4,5,6)
//List(2, 4, 6, 8, 10, 12)
numbers.map(n=> n * 2)
valchars= Seq('a','b','c','d')
//输出为List(A, B, C, D)
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
valabcd= Seq('a','b','c','d')
//List(A, a, B, b, C, c, D, d)
abcd.flatMap(ch=> List(ch.toUpper, ch))
scala> List(List(1,2),List(3,4)).flatMap(x=>x.map(x=>x*2))
res5: List[Int] = List(2, 4, 6, 8)
4、foreach和forall（对集合条件检查）
foreach和map相似，只不过它没有返回值或者说返回值是Unit，foreach只要是为了对参数进行作用。
比如 names.foreach{name=>println(name)}
有一个场景大家都知道，即确保集合中所有元素都要符合某些要求，如果有哪怕一个元素不符合条件，就需要进行一些处理：
valnumbers=Seq(3,7,2,9,6,5,1,4,2)
//ture
numbers.forall(n=> n < 10)
//false
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
。他们是从不同的方面做同样的工作：
valnumbers=Seq(1,2,3,4,5)
//15
numbers.foldLeft(0)((res, n) => res + n)val words = Seq("apple", "dog", "table")
//13
words.foldLeft(0)((resultLength, word) => resultLength + word.length)
val words = Seq("apple", "dog", "table")
//13
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
同理：(_*_) (_/_)
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 推荐了一个很赞的解决方案：
valnumbers=Seq(11,2,5,1,6,3,9)
numbers.max//11
numbers.min//1
但实际操作的数据更加复杂。下面我们介绍一个更高级的例子，其中包含一个书的序列（查看源代码案例）。
caseclassBook(title:String, pages:Int)
valbooks=Seq(
Book("Future of Scala developers",85),
Book("Parallel algorithms",240),
Book("Object Oriented Programming",130),
Book("Mobile Development",495)
)
//Book(Mobile Development,495)
books.maxBy(book=> book.pages)
//Book(Future of Scala developers,85)
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