做网站的公司利润,如何设置网站根目录,怎样建单位的网站,开服网站建设目录 集合基本函数#xff1a;
#xff08;1#xff09;获取集合长度
#xff08;2#xff09;获取集合大小
#xff08;3#xff09;循环遍历
#xff08;4#xff09;迭代器
#xff08;5#xff09;生成字符串
#xff08;6#xff09;是否包含
衍生集合… 目录 集合基本函数
1获取集合长度
2获取集合大小
3循环遍历
4迭代器
5生成字符串
6是否包含
衍生集合
1获取集合的头
2获取集合的尾
3集合最后一个数据
4集合初始数据
5反转
6取前后n 个元素
7去掉前后n 个元素
8并集不去重
9交集
10差集
11拉链
12滑窗 集合的低级函数
求和
乘积
最大值
最小值
排序
简单排序
从大到小
从小到大
排序二元组
自定义排序
sortWith排序
集合计算高级函数
过滤 map转化映射
转化1
转化2
转化3
扁平化
flatMap函数
分组
Reduce:
1.归约
2.折叠fold
foldLeft(): 两个Map的归约合并
方法1
方法二 集合基本函数
1获取集合长度 val length: Int list.length2获取集合大小 val size: Int list.size3循环遍历 list.foreach(println)4迭代器 val iterator: Iterator[Int] list.iteratorwhile (iterator.hasNext){println(iterator.next())} 5生成字符串 mkString方法是toString底层的方法 toString是加上一些前缀与mkString方法的拼接 val str: String list.mkString(\t)println(str) 6是否包含 val bool: Boolean list.contains(2)println(bool) 衍生集合 调用一个方法 原集合保持不变 生成一个新的集合 1获取集合的头 val head: Int list.headprintln(head) 2获取集合的尾 不是头的就是尾---去掉头的剩余集合 val tail: List[Int] list.tailprintln(tail) 3集合最后一个数据 val last: Int list.lastprintln(last) 4集合初始数据 不包含最后一个 val init: List[Int] list.initprintln(init) 5反转 val reverse: List[Int] list.reverseprintln(reverse) 6取前后n 个元素 取前两个 val ints: List[Int] list.take(2) 取后两个 val ints1: List[Int] list.takeRight(2)7去掉前后n 个元素 去掉前俩
返回值为剩下的元素 val ints2: List[Int] list.drop(2)去掉后俩 val ints3: List[Int] list.dropRight(2)8并集不去重 val ints4: List[Int] list.union(list1) 9交集 val ints5: List[Int] list.intersect(list1)10差集 val ints6: List[Int] list.diff(list1)11拉链 ---就是把两个集合进行拼接成二元组
当两个集合元素数量正好相等的时候 恰好组成元组
两恶搞集合元素数量不等的时候 会把多余的给舍弃val tuples: List[(Int, Int)] list.zip(list1)12滑窗 场景 给一个数组 -20050-1000-80 求任意相邻的三个数 成绩最大的是那三个 val list2 List(-200, 50, -100, 0, -80)val iterator: Iterator[List[Int]] list2.sliding(3, 1)var result0for (elem - iterator) {if (resultelem.product) {resultelem.product}} 参数 窗口大小 步长一次几个格子 如果在最后元素少于窗口大小 则依然输出剩下的
product product()方法属于类Abstract Iterator的具体值成员。它用于乘以指定集合的所有元素。 集合的低级函数
求和
val sum: Int ints.sum
乘积 val product: Int ints.product最大值 val max: Int ints.max最小值 val min: Int ints.min上述函数都没有()但是他是有参数的 他是一种隐式参数
排序
简单排序
排序计算机是采用的快排默认是从小到大排序如果需要从大到小需要重写他的参数
从大到小 val sorted: List[Int] ints.sorted从小到大 val ints1: List[Int] ints.sorted(Ordering.Int.reverse)排序结果的输出可以迭代器也可以for循环 val iterator: Iterator[Int] sorted.iteratorwhile(iterator.hasNext){print(iterator.next() )}
排序二元组 val tuples List((hello, 10), (world, 20), (tuple, 32), (spark, 58))默认按照第一个元素进行排序 val tuples1: List[(String, Int)] tuples.sorted(Ordering[(String, Int)])反转排序它是按照字母的倒叙进行排序 val reverse: List[(String, Int)] tuples.sorted(Ordering[(String, Int)]).reverse两种排序的运行结果对比 自定义排序
按照单词出现的次数排序
这样是需要自定义的 调用sortBy()函数By---什么方式
设置返回类型就是按照什么排序匿名函数 val tuples2: List[(String, Int)] tuples.sortBy((tuples: (String, Int)) tuples._2)按照单词出现的次数反转排序
通过sortBy()源码可知他是采用了柯里化写法闭包---把上层变量定义成常量传给下一层 val reverse1: List[(String, Int)] tuples.sortBy((tuples: (String, Int)) tuples._2)(Ordering[Int]).reverse上述代码在第一次传入参数返回的是以Int类型的集合 在对他进行封装成常量传递给下层 所以 在柯里化的第二个的时候在设置类型的时候要设置Int类型
sortWith排序
sortWith参数形式 这个就是类似于冒泡排序左边于靠近的右边的进行比较当不满足某条件的时候进行调换 val tuples3: List[(String, Int)] tuples.sortWith((lift: (String, Int), right: (String, Int)) lift._2 right._2)集合计算高级函数
下边所写高阶函数都有一个默认的foreach()逻辑在进行下边操作的时候都会一个一个的传入遍历
过滤 遍历一个集合并从中获取满足指定条件的元素组成一个新的集合 参数为让你填一个函数 int---BOOL 将集合中元素作为填写函数的传入参数 得到返回结果如果为true 保留 为false 删除 val ints1: List[Int] ints.filter(i i %2 0)map转化映射
map转化是使用集合的map方法进行结构转化
map方法的参数形式 转化1 val ints2: List[Int] ints.map(i i * 2)转化2 val tuples: List[(String, Int)] ints.map((i:Int) (我是, i))转化3
在Hadoop的hdfs中我们存储的是半结构化数据一条条的数据字符串 val list List(zhangsan,18,男,180, tangxiaocong,19,男,185)list.map((line:String){val strings: Array[String] line.split(,)//构造元组(strings(0),strings(1),strings(2),strings(3))})
扁平化
扁平化的使用场景为List集合嵌套List集合对于这种情况需要使用炸裂 val list1 List(List(1, 2, 3, 4), List(4, 5, 6, 7), List(7, 8, 9, 10))val flatten: List[Int] list1.flatten
执行结果不去重 元素必须是可拆分的集合才能调用扁平化
特例
如果在List中是String则可以使用flatten函数String是char的集合
上述情况会把String转换成char的形式
所以在扁平化的时候需要将集合中的字符串转化成List形式map转化 val list2 List(hello world, hello scala, hello spark)val list3: List[List[String]] list2.map((line: String) {val strings: Array[String] line.split(,)strings.toList})
让后在进行扁平化直接调用flatten
val flatten1: List[String] list3.flatten在框架中使用的是flatMap(实际是mapflatten)
flatMap函数
传入的参数还是map转化的逻辑让后默认调用flatten函数 val strings1: List[String] list2.flatMap((line: String) {line.split(,)})
flattenMap函数需要的参数是集合的形式是不需要转化成List集合的
分组
分组之后多组数据转换成了一行数据 生成数据有相同的key value值变成了一个List集合 val tuples1 List((A, 10), (B, 20), (C, 11), (D, 15),(A, 16), (B, 26), (C, 41), (D, 35))val map: Map[String, List[(String, Int)]] tuples1.groupBy(tuple tuple._1) 分组条件不止可以为元组的某个值也可以是自己特定的通过匿名函数设定 val ints3 List(1, 2, 3, 5, 4, 6, 7, 8, 9)val map1: Map[Int, List[Int]] ints3.groupBy((i: Int) i % 2) 返回值的结果是什么就按照什么进行排序
Reduce:
1.归约 参数表示输入输出的数据类型是一致的
第一个A1表示每次调用的结果值
第二个A1表示当前元素值
第三个A3本次调用的返回结果 作为下次的结果值
reduce将第一个初始值作为结果值进行传递 让后直接进行下次reduce跳过第一个元素从第二个元素开始运行逻辑 val ints List(1, 5, 6, 7, 8)val i1: Int ints.reduce((res: Int, i: Int) res i*2) 正确结果该是54 输出结果为53 因为运算逻辑为15*26*27*28*253
而我们正确的逻辑应该为1*25*26*27*28*254 2.折叠fold
归约的一种方法 这个函数是采用的柯里化写法第一个传入初始值也是结果值第二个传入运算逻辑
fold方法就很好的设置了初始值解决了Reduce方法的缺点 val i2: Int ints.fold(0)((res: Int, i: Int) res i * 2)运行结果 foldLeft():
初始值可以为不同类型常用于Map,tuple val tuple: (String, Int) ints.foldLeft((sum : elem*2, 0))((res: (String, Int), elem: Int) {//创建一个新的二元组(res._1, res._2 elem * 2)}) 两个Map的归约合并
两个Map集合 一个作为结果存储 一个作为集合遍历
方法1
val map mutable.Map((String, 14), (Scala, 35))val map1 Map((String, 14), (Scala, 35), (Spark, 33))for (elem - map1) {val key: String elem._1val value: Int elem._2if (map.contains(key)){map.update(key, value map.getOrElse(key,0))}else{map.put(key,value)}}
上述方法的两个Map一个是不可变 一个是可变---不可以重复执行不稳定会不断的累加
方法二
下边两个Map都是不可变的
不可变集合 做出改变后要重新返回一个对象 val map2 Map((String, 14), (Scala, 35))val map3 Map((String, 14), (Scala, 35), (Spark, 33))val map4: Map[String, Int] map2.foldLeft(map3)((mape, elem) {mape.updated(elem._1, mape.getOrElse(elem._1, 0) elem._2)})println(map4)
