Scala-17：集合-常用函数-蒲公英云

Scala-17：集合-常用函数

一、基本属性和常用操作

（1）获取集合长度

//（1）获取集合长度 
println(list.length)

（2）获取集合大小

//（2）获取集合大小,等同于 length 
println(list.size)

（3）循环遍历

//（3）循环遍历 
list.foreach(println)

（4）迭代器

//（4）迭代器 
for (elem <- list.itera tor) {
    println(elem) 
}

（5）生成字符串

//（5）生成字符串 
println(list.mkString(","))

（6）是否包含

//（6）是否包含 
println(list.contains(3))

二、衍生集合

（1）获取集合的头

//（1）获取集合的头 
println(list1.head)

（2）获取集合的尾（不是头的就是尾）

//（2）获取集合的尾（不是头的就是尾） 
println(list1.tail)

（3）集合最后一个数据

//（3）集合最后一个数据 
println(list1.last)

（4）集合初始数据（不包含最后一个）

//（4）集合初始数据（不包含最后一个） 
println(list1.init)

（5）反转

//（5）反转 
println(list1.reverse)

（6）取前（后）n 个元素

//（6）取前（后）n 个元素 
println(list1.take(3)) println(list1.takeRight(3))

（7）去掉前（后）n 个元素

//（7）去掉前（后）n 个元素 
println(list1.drop(3)) println(list1.dropRight(3))

（8）并集

//（8）并集 
println(list1.union(list2))

（9）交集

//（9）交集 
 println(list1.intersect(list2))

（10）差集

//（10）差集 
println(list1.diff(list2))

（11）拉链

//（11）拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用 
println(list1.zip(list2))

（12）滑窗

//（12）滑窗 
list1.sliding(2, 5).foreach(println)

三、集合计算简单函数

（1）求和

//（1）求和 
println(list.sum)

（2）求乘积

//（2）求乘积 
println(list.product)

（3）最大值

//（3）最大值     
println(list.max)

（4）最小值

//（4）最小值 
println(list.min)

（5）排序

//（5）排序 
// （5.1）按照元素大小排序 
println(list.sortBy(x => x)) 
// （5.2）按照元素的绝对值大小排序 
println(list.sortBy(x => x.abs)) 
// （5.3）按元素大小升序排序 
println(list.sortWith((x, y) => x < y)) 
// （5.4）按元素大小降序排序 
println(list.sortWith((x, y) => x > y))

（1）sorted

对一个集合进行自然排序，通过传递隐式的 Ordering

（2）sortBy

对一个属性或多个属性进行排序，通过它的类型。

（3）sortWith

基于函数的排序，通过一个 comparator 函数，实现自定义排序的逻辑。

四、集合计算高级函数

（1）过滤

遍历一个集合并从中获取满足指定条件的元素组成一个新的集合

//（1）过滤 
println(list.filter(x => x % 2 == 0))

（2）转化/映射（map）

将集合中的每一个元素映射到某一个函数

//（2）转化/映射 
println(list.map(x => x + 1))

（3）扁平化

//（3）扁平化
println(nestedList.flatten)

（4）扁平化+映射注

flatMap 相当于先进行 map 操作，在进行 flatten 操作集合中的每个元素的子元素映射到某个函数并返回新集合

//（4）扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten操作 
println(wordList.flatMap(x => x.split(" ")))

（5）分组(group)

按照指定的规则对集合的元素进行分组

//（5）分组 
println(list.groupBy(x => x % 2))

（6）简化（归约）

Reduce 简化（归约）：通过指定的逻辑将集合中的数据进行聚合，从而减少数据，最终获取结果。

val list = List(1,2,3,4) 
// 将数据两两结合，实现运算规则 
val i: Int = list.reduce( (x,y) => x-y ) 
println("i = " + i) 
// 从源码的角度，reduce 底层调用的其实就是 reduceLeft 
//val i1 = list.reduceLeft((x,y) => x-y) 
// ((4-3)-2-1) = -2 
val i2 = list.reduceRight((x,y) => x-y) 
println(i2)

（7）折叠

Fold 折叠：化简的一种特殊情况。

val list = List(1,2,3,4) 
// fold 方法使用了函数柯里化，存在两个参数列表 
// 第一个参数列表为 ： 零值（初始值） 
// 第二个参数列表为： 简化规则 
// fold 底层其实为 foldLeft 
val i = list.foldLeft(1)((x,y)=>x-y) 
val i1 = list.foldRight(10)((x,y)=>x-y) 
println(i) 
println(i1)

两个集合合并

// 两个 Map 的数据合并 
val map1 = mutable.Map("a"->1, "b"->2, "c"->3) 
val map2 = mutable.Map("a"->4, "b"->5, "d"->6) 
val map3: mutable.Map[String, Int] = map2.foldLeft(map1) 
{
    (map, kv) => {
        val k = kv._1 
        val v = kv._2 
        map(k) = map.getOrElse(k, 0) + v 
        map 
    } 
} 
println(map3)