Scala集合-集合常⽤函数Scala 集合-集合常⽤函数
1 基本属性和常⽤操作
1）说明
（1）获取集合长度
（2）获取集合⼤⼩
（3）循环遍历
（4）迭代器
（5）⽣成字符串
（6）是否包含
2）案例实操
object TestList {
def main(args: Array[String]):Unit={
val list: List[Int]= List(1,2,3,4,5,6,7)
//（1）获取集合长度
println(list.length)
//（2）获取集合⼤⼩，等同于 length
println(list.size)
//（3）循环遍历
list.foreach(println)
//（4）迭代器
for(elem <- list.itera tor){
println(elem)
}
//（5）⽣成字符串
println(list.mkString(","))
//（6）是否包含
ains(3))
}
}
2 衍⽣集合
1）说明
（1）获取集合的头
（2）获取集合的尾（不是头的就是尾）
（3）集合最后⼀个数据
（4）集合初始数据（不包含最后⼀个）
groupby是什么函数
（5）反转
（6）取前（后）n 个元素
（7）去掉前（后）n 个元素
（8）并集
（9）交集
（10）差集
（11）拉链
（12）滑窗
2）案例实操
val list2: List[Int]= List(4,5,6,7,8,9,10)
//（1）获取集合的头
println(list1.head)
//（2）获取集合的尾（不是头的就是尾）
println(list1.tail)
//（3）集合最后⼀个数据
println(list1.last)
//（4）集合初始数据（不包含最后⼀个）
println(list1.init)
//（5）反转
verse)
/
/（6）取前（后）n 个元素
println(list1.take(3))
println(list1.takeRight(3))
//（7）去掉前（后）n 个元素
println(list1.drop(3))
println(list1.dropRight(3))
//（8）并集
println(list1.union(list2))
//（9）交集
println(list1.intersect(list2))
//（10）差集
println(list1.diff(list2))
//（11）拉链注：如果两个集合的元素个数不相等，那么会将同等数量的数据进⾏拉链，多余的数据省略不⽤ println(list1.zip(list2))
//（12）滑窗
list1.sliding(2,5).foreach(println)
}
}
3 集合计算简单函数
1）说明
（1）求和
（2）求乘积
（3）最⼤值
（4）最⼩值
（5）排序
2）实操
//（1）求和
println(list.sum)
//（2）求乘积
println(list.product)
//（3）最⼤值
println(list.max)
//（4）最⼩值
println(list.min)
/
/（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 函数，实现⾃定义排序的逻辑。
4 集合计算⾼级函数
1）说明
（1）过滤：遍历⼀个集合并从中获取满⾜指定条件的元素组成⼀个新的集合
（2）转化/映射（map）：将集合中的每⼀个元素映射到某⼀个函数
（3）扁平化
（4）扁平化+映射
注：flatMap 相当于先进⾏ map 操作，在进⾏ flatten 操作集合中的每个元素的⼦元素映射到某个函数并返回新集合（5）分组(group)：按照指定的规则对集合的元素进⾏分组
（6）简化（归约）
（7）折叠
2）实操
object TestList {
def main(args: Array[String]):Unit={
val list: List[Int]= List(1,2,3,4,5,6,7,8,9)
val nestedList: List[List[Int]]= List(List(1,2,3), List(4,5,6), List(7,8,9))
val wordList: List[String]= List("hello world","hello","hello scala")
//（1）过滤
println(list.filter(x => x %2==0))
//（2）转化/映射
println(list.map(x => x +1))
/
/（3）扁平化
println(nestedList.flatten)
//（4）扁平化+映射注：flatMap 相当于先进⾏ map 操作，在进⾏ flatten操作
println(wordList.flatMap(x => x.split(" ")))
//（5）分组
upBy(x => x %2))
}
}
3）Reduce ⽅法
Reduce 简化（归约） ：通过指定的逻辑将集合中的数据进⾏聚合，从⽽减少数据，最终获取结果。
案例实操
val list = List(1,2,3,4)
// 将数据两两结合，实现运算规则
val i:Int= duce((x,y)=> x-y )
println("i = "+ i)
// 从源码的⾓度，reduce 底层调⽤的其实就是 reduceLeft //val i1 = duceLeft((x,y) => x-y)
// ((4-3)-2-1) = -2
val i2 = duceRight((x,y)=> x-y)
println(i2)
}
}
4）Fold ⽅法
Fold 折叠：化简的⼀种特殊情况。
（1）案例实操：fold 基本使⽤
object TestFold {
def main(args: Array[String]):Unit={
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)
}
}
（2）案例实操：两个集合合并
object TestFold {
def main(args: Array[String]):Unit={
// 两个 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)= OrElse(k,0)+ v
map
}
}
println(map3)
}
}
5 普通 WordCount 案例
1）需求
单词计数：将集合中出现的相同的单词，进⾏计数，取计数排名前三的结果
2）需求分析
3）案例实操
object TestWordCount {
def main(args: Array[String]):Unit={
// 单词计数：将集合中出现的相同的单词，进⾏计数，取计数排名前三的结果
val stringList = List("Hello Scala Hbase kafka","Hello Scala Hbase","Hello Scala","Hello")
// 1) 将每⼀个字符串转换成⼀个⼀个单词
val wordList: List[String]= stringList.flatMap(str=>str.split(" "))
//println(wordList)
// 2) 将相同的单词放置在⼀起
val wordToWordsMap: Map[String, List[String]]= upBy(word=>word)
//println(wordToWordsMap)
// 3) 对相同的单词进⾏计数
// (word, list) => (word, count)
val wordToCountMap: Map[String,Int]= wordToWordsMap.map(tuple=>(tuple._1, tuple._2.size)) // 4) 对计数完成后的结果进⾏排序（降序）
val sortList: List[(String,Int)]= List.sortWith {
(left, right)=>{
left._2 > right._2
}
}
// 5) 对排序后的结果取前 3 名
val resultList: List[(String,Int)]= sortList.take(3)
println(resultList)
}
}
6 复杂 WordCount 案例
1）⽅式⼀

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。