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）是否包含
		 println(list.contains(3))
	 }
}

2 衍生集合

1）说明
（1）获取集合的头
（2）获取集合的尾（不是头的就是尾）
（3）集合最后一个数据
（4）集合初始数据（不包含最后一个）
（5）反转
（6）取前（后）n 个元素
（7）去掉前（后）n 个元素
（8）并集
（9）交集
（10）差集
（11）拉链
（12）滑窗
2）案例实操

object TestList {
 def main(args: Array[String]): Unit = {
 val list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
 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）反转
 println(list1.reverse)
 //（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）实操

object TestList {
 def main(args: Array[String]): Unit = {
	 val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)
	 //（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）分组
		 println(list.groupBy(x => x % 2))
	 }
}

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

案例实操

object TestReduce {
 def main(args: Array[String]): Unit = {
	 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)
 }
}

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) = map.getOrElse(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]] = wordList.groupBy(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)] = wordToCountMap.toList.sortWith {
	 	(left, right) => {
		 	left._2 > right._2
	 	}
	 }
 	// 5) 对排序后的结果取前 3 名
 	val resultList: List[(String, Int)] = sortList.take(3)
 	println(resultList)
 }
}

6 复杂 WordCount 案例

1）方式一

object TestWordCount {
 def main(args: Array[String]): Unit = {
 	// 第一种方式（不通用）
 	val tupleList = List(("Hello Scala Spark World ", 4), ("Hello Scala Spark", 3), ("Hello Scala", 2), ("Hello", 1))
 	val stringList: List[String] = tupleList.map(t=>(t._1 + " ") * t._2)
 	//val words: List[String] = 
	stringList.flatMap(s=>s.split(" "))
 	val words: List[String] = stringList.flatMap(_.split(" "))
	//在 map 中，如果传进来什么就返回什么，不要用_省略
 	val groupMap: Map[String, List[String]] = words.groupBy(word=>word)
 	//val groupMap: Map[String, List[String]] = 
	words.groupBy(_)
 	// (word, list) => (word, count)
 	val wordToCount: Map[String, Int] = groupMap.map(t=>(t._1, t._2.size))
 	val wordCountList: List[(String, Int)] = wordToCount.toList.sortWith {
		 (left, right) => {
		 	left._2 > right._2
		 }
	 }.take(3)
 	//tupleList.map(t=>(t._1 + " ") * t._2).flatMap(_.split(" ")).groupBy(word=>word).map(t=>(t._1, t._2.size))
 	println(wordCountList)
 }
}

2）方式二

object TestWordCount {
 def main(args: Array[String]): Unit = {
 	val tuples = List(("Hello Scala Spark World", 4), ("Hello Scala Spark", 3), ("Hello Scala", 2), ("Hello", 1))
	 // (Hello,4),(Scala,4),(Spark,4),(World,4)
	 // (Hello,3),(Scala,3),(Spark,3)
	 // (Hello,2),(Scala,2)
	 // (Hello,1)
 	val wordToCountList: List[(String, Int)] = tuples.flatMap {
	 	t => {
			 val strings: Array[String] = t._1.split(" ")
			 strings.map(word => (word, t._2))
 		}
	 }
	 // Hello, List((Hello,4), (Hello,3), (Hello,2), (Hello,1))
	 // Scala, List((Scala,4), (Scala,3), (Scala,2)
	 // Spark, List((Spark,4), (Spark,3)
	 // Word, List((Word,4))
 	val wordToTupleMap: Map[String, List[(String, Int)]] = wordToCountList.groupBy(t=>t._1)
 	val stringToInts: Map[String, List[Int]] = wordToTupleMap.mapValues {
 		datas => datas.map(t => t._2)
 	}
 	stringToInts
	/*
	 val wordToCountMap: Map[String, List[Int]] = wordToTupleMap.map {
		 t => {
		 	(t._1, t._2.map(t1 => t1._2))
		 }
	 }
	 val wordToTotalCountMap: Map[String, Int] = wordToCountMap.map(t=>(t._1, t._2.sum))
	 println(wordToTotalCountMap)
	 */
 }
}