scala入门5-集合API

集合相关api

1、属性

	def main(args: Array[String]): Unit = {
	
		val list = List[Int](10,20,30)
	
		//获取集合的长度
		println(list.size)
		println(list.length)
	
		//是否包含某个元素
		println(list.contains(100))
	
		//判断集合是否为空
		println(list.isEmpty)
	
		//判断集合是否不为空
		println(list.nonEmpty)
	
		//生成字符串
		println(list)
		println(list.mkString("#"))
	
	}

2、衍生集合

	def main(args: Array[String]): Unit = {
	
		//去重  *****
		val list = List[Int](10,10,20,30,2,1,1,50)
		val list2 = list.distinct
		println(list2)
	
		//删除前多少个元素，保留剩余的元素
		val list3 = list.drop(2)
		println(list3)
	
		//删除后多少个元素，保留剩余元素
		val list4 = list.dropRight(3)
		println(list4)
	
		//获取第一个元素  ****
		val head = list.head
		println(head)
	
		//获取最后一个元素 *****
		val last = list.last
		println(last)
	
		//获取除开最后一个元素的所有元素
		val list5 = list.init
		println(list5)
		println("*"*100)
		//除开第一个元素的所有元素
		val list11 = list.tail
		println(list11)
	
		//反转
		val list7 = list.reverse
		println(list7)
	
		//获取子集合
		val list8 = list.slice(2,5)
		println(list8)
	
		//窗口  ******
		//size: 窗口的大小
		//step: 窗口滑动的长度
		val list9 = list.sliding(3,2)
		println(list9.toBuffer)
	
		//获取前多少个元素 *****
		val list12 = list.take(3)
		println(list12)
	
		//获取后多少个元素
		val list13 = list.takeRight(3)
		println(list13)
	
		//val list = List[Int](10,10,20,30,2,1,1,50)
		val list14 = List[Int](10,1,4,5,20)
		//交集[两个集合共同的元素]
		val list15 = list.intersect(list14)
		println(list15)
		//差集[ 除开交集之外的元素  A 差 B => 结果是A中除开交集之外的所有元素 ]
		val list16 = list.diff(list14)
		println(list16)
		//并集【两个集合的所有元素,不去重】
		val list17 = list.union(list14)
		println(list17)
	
		//拉链
		val list18 = List[String]("aa","bb","cc","dd")
		val list19 = List[Int](1,2,3)
		val list20 = list18.zip(list19)
		println(list20)
	
		//反拉链
		val list21 = list20.unzip
		println(list21)
	}

3、初级计算api

	def main(args: Array[String]): Unit = {
		val list = List[Int](2,7,1,9,10,5,3)
	
		//最大值
		val max = list.max
		//最小值
		val min = list.min
		println(max)
		println(min)
		//根据什么获取最大值
		val list2 = List[String]("zhangsan 20 3000","lisi 15 5000","wangwu 30 1000")
		//maxBy中的函数是针对集合的每个元素
		val maxBy = list2.maxBy(x=>x.split(" ")(1).toInt)
		println(maxBy)
		//根据什么获取最小值
		val list3 = List[(String,Int)]( ("ZHANGSAN",1000),("LISI",2500),("WANGWU",3000),("WANGWU",2500) )
		//minBy中的函数是针对集合的每个元素
		println(list3.minBy(_._2))
		//求和
		println(list.sum)
		//List[String]("spark","hello").sum
		//排序
		//直接按照元素本身排序[升序]
		val list4 = list.sorted
	
		println(list4)
		//降序
		val list5 = list4.reverse
		println(list5)
	
		println(list3.sorted)
		//指定按照哪个字段排序[升序] *****
		println(list3.sortBy(_._2))
		//根据指定的规则排序
		println(list.sortWith((x, y) => x < y))
		println(list.sortWith((x, y) => y < x))
	}

4、高级api

	def main(args: Array[String]): Unit = {
	
		val list = List[String]("spark", "hello", "java", "python")
		//map(func: 集合元素类型 => B ): 主要用来转换数据[转换值、转换类型]
		//   map中的函数是针对集合的每个元素进行操作
		//   map的应用场景: 一对一 【val B = A.map(..)    B集合的元素的个数=A集合元素个数】
		val list2 = list.map(x => x.length)
		println(list2)
		val list3 = List[Int](10, 20, 30, 40)
		val list4 = list3.map(x => x * x)
		println(list4)
		println("-" * 100)
	
		//foreach(func: 集合元素类型 => U ):Unit
		//  foreach中的函数也是针对集合的每个元素
		//  foreach与map的区别: map有返回值，foreach没有返回值
		val list5 = List[(String, Int, String)](("lisi", 20, "深圳"), ("zhangsan", 15, "北京"))
		list5.foreach(println(_))
		println("-" * 100)
		list5.foreach(println)
		println("-" * 100)
	
		//flatten-压平
		//flatten只能用于集合中嵌套集合的场景
		//flatten的应用场景: 一对多
		val list6 = List[List[String]](
		List[String]("aa", "bb"),
		List[String]("cc", "dd"),
		List[String]("ee", "ff")
		)
	
		val list7 = list6.flatten
		println(list7)
		println("-" * 100)
	
		val list8 = List[List[List[String]]](
		List(List[String]("aa", "bb"), List[String]("cc", "dd")),
		List(List[String]("ee", "ff"), List[String]("oo", "xx"))
		)
	
		val list9 = list8.flatten
		println(list9)
	
		val list10 = List[String]("spark", "hello")
		println(list10.flatten)
		println("-" * 100)
	
		//flatMap(func: 集合元素类型=> 集合 ) = map+flatten
		// flatMap中的函数也是针对集合中的每个元素
		// flatMap应用场景: 一对多
		val list11 = List[String]("hadoop spark", "hello java python")
	
		val list12 = list11.map(x => x.split(" "))
	
		val list13 = list12.flatten
		println(list13)
	
		println(list11.flatMap(_.split(" ")))
		println("-" * 100)
	
		//filter( func: 集合元素类型 => Boolean ) - 过滤
		//  filter中的函数针对集合的每个元素,filter保留的是函数返回值为true的数据
		val list14 = List[Int](10, 2, 4, 5, 7, 9)
	
		println(list14.filter(_ % 2 == 0))
		println("-" * 100)
	
		//groupBy(func: 集合元素类型=> K ) --分组
		//groupBy是根据指定的字段进行分组，里面的函数针对是集合每个元素
		//groupBy的结果是Map[分组的key,List[原有集合元素类型]]
		val list15 = List[(String, String)](
		("ZHANGSAN", "SHENZHEN"),
		("LISI", "BEIJING"),
		("WANGWU", "SHENZHEN"),
		("ZHAOLIU", "SHENZHEN")
		)
		//list15.groupBy(x=> x._2)
		val list16 = list15.groupBy(_._2)
		println(list16)
		println("-" * 100)
	
		//reduce(func: (集合元素类型,集合元素类型) =>  集合元素类型 ) --聚合
		//  reduce中的函数是两两聚合，然后将上一次的聚合结果与下一个元素再次聚合
		//  reduce最终结果是单个数据，数据的类型就是原有集合的元素类型
		val list17 = List[Int](10, 2, 4, 5, 7, 9)
	
		val result = list17.reduce((agg, curr) => {
		println(s"agg=${agg}  curr=${curr}")
		agg * curr
		})
		//reduce的执行过程：
		// agg上一次的聚合结果  curr:本次要聚合元素
		//      第一次执行的时候，agg的值就是集合第一个元素[10], curr集合第二个元素[2]  (agg,curr)=> agg * curr = 20
		//      第二次执行的时候，agg上一次的聚合结果[20], curr集合第三个元素[4]  (agg,curr)=> agg * curr = 80
		//  ......
	
		println(result)
	
		//reduceRight(func: (集合元素类型,集合元素类型) =>  集合元素类型 )
		//  reduceRight中的函数是两两聚合，然后将上一次的聚合结果与下一个元素再次聚合
		//  reduceRight最终结果是单个数据，数据的类型就是原有集合的元素类型
		println("-" * 100)
		val result2 = list17.reduceRight((curr, agg) => {
		println(s"agg=${agg}  curr=${curr}")
		agg - curr
		})
		//reduceRight的执行过程：
		// agg上一次的聚合结果  curr:本次要聚合元素
		//      第一次执行的时候，agg的值就是集合第最后一个元素[9], curr集合倒数第二个元素[7]  (agg,curr)=> agg - curr = 2
		//      第二次执行的时候，agg上一次的聚合结果[2], curr集合倒数第三个元素[5]  (agg,curr)=> agg * curr = -1
		//  ......
		println(result2)
	
		println("-" * 100)
		//fold(agg第一次执行的初始值)(func: (集合元素类型，集合元素类型)=>集合元素类型)
		//fold与reduce唯一的不同就是多了agg的初始值
		list17.fold(100)((agg, curr) => {
		println(s"agg=${agg}  curr=${curr}")
		agg - curr
		})
		println("-" * 100)
		//foldRight(agg第一次执行的初始值)(func: (集合元素类型，集合元素类型)=>集合元素类型)
		list17.foldRight(200)((curr, agg) => {
		println(s"agg=${agg}  curr=${curr}")
		agg - curr
		})
	}