Java 集合 : 数据的容器,可以在内部容纳数据
   List : 有序,可重复的
   Set : 无序,不可重复
   Map : 无序,存储K-V键值对,key不可重复

scala 集合 : 可变集合(ArrayList) & 不可变集合(数组)
   String(不可变字符串), (StringBuilder, StringBuffer)(可变字符串)

集合的基本方法

    val list: List[Int] = List(1,2,3,4)
// 反转集合
//println(list.reverse) //List(6, 5, 4, 3, 2, 1) //set,map没有反转
list.max
list.min
list.sum //求和
list.product //乘积 // TODO 排序
//val listStr = List("1", "5", "9", "11")
//println("排序 = " + listStr.sorted) //排序 = List(1, 11, 5, 9) 按照字典顺序; 数字、字符串都是按字符串的字典顺序排序 val stringList = List("11", "55", "13", "22")
// 1, 5, 3, 2
// 11 22 13 55
// TODO 排序 使用自定义排序规则进行排序
println(stringList.sortBy(x => {
x.substring(1, 2) //List(11, 22, 13, 55)
}))
//TODO 排序:升序,降序
println("升序= " + stringList.sortWith{ //升序= List(11, 13, 22, 55)
case (left, right) => {
left < right
}
})
println("降序= " + stringList.sortWith{ //降序= List(55, 22, 13, 11)
case (left, right) => {
left > right
}
})
TODO : 分组  groupBy(x=>{x%2})
    println("分组= " +list.groupBy(x => {   //分组= Map(1 -> List(1, 3, 5), 0 -> List(2, 4, 6))
x % 2
}))
聚合
Map 转换,映射
// map方法将集合中的每一个元素进行转换后放置到新的集合中
    println(list.map(_ * 2)) //List(2, 4, 6, 8, 10, 12)
println(list.map((_, 1))) //List((1,1), (2,1), (3,1), (4,1), (5,1), (6,1))

flatMap 扁平化  数->可迭代

(整体,拆成一个个的个体变成可迭代的集合

    val list: List[Int] = List(1,2,3,4)

  // TODO flatMap 扁平化
val list2 = List(List(1,2), List(3, 4), List(5, 6)) // ==> List(1,2,3,4,5,6)
// in : List, out : Iterator
println("扁平化=" + list2.flatMap(x => x)) //扁平化=List(1, 2, 3, 4, 5, 6) 集合中整体拆成一个个的 
 reduce 化简,也称归约
    // TODO reduce 化简
println(list.reduce((_ + _))) //10 两两聚合
println(list.reduce(_ - _)) //-8
println(list.reduceLeft(_ - _))//-8 同上,底层调用是一样的
println(list.reduceRight(_ - _)) //-2 从右边开始计算

fold 折叠foldLeft    foldRight 缩写分别为 /: 和 :\

scala中两个map的合并 foldLeft

    val list: List[Int] = List(1,2,3,4)

// TODO fold fold和reduce比较类似,仅仅是多了一个集合之后的初始值
println(list.fold(10)(_ - _)) // -0 底层本质上就是调用的foldLeft(z)(op)
println(list.foldLeft(10)(_ - _)) //-0 // 1,2,3,4 ==> reverse ==> 4,3,2,1
// 底层运算时,将集合反转后相邻的元素交互调用逻辑
println(list.foldRight(0)(_ - _)) //-2
//reverse.foldLeft(z)((right, left) => op(left, right))

扫描 scanLeft

扫描,即对某个集合的所有元素做fold操作,但是会把产生的所有中间结果放置于一个集合中保存

    def minus(num1: Int, num2: Int): Int = {
num1 - num2
}
val i1 = (1 to 5).scanLeft(5)(minus) //1 2 3 4 5
//5 4 2 -1 -5 -10
println(i1) //Vector(5, 4, 2, -1, -5, -10) def add( num1 : Int, num2 : Int ) : Int = {
num1 + num2
}
val i2 = (1 to 5).scanLeft(5)(add) //1 2 3 4 5
//5 6 8 11 15 20
println(i2) //Vector(5, 6, 8, 11, 15, 20)

集合交Intersect、差diff、合union

    val lis1 = List(1,2,3,4)
val lis2 = List(3,4,5,6,7)
// 两个集合合并
println(lis1.union(lis2)) //List(1, 2, 3, 4, 3, 4, 5, 6, 7)
// 两个集合交集
println(lis1.intersect(lis2)) //List(3, 4)
// 两个集合差集
println(lis2.diff(lis1)) //List(5, 6, 7)
拉链,将两个集合进行 对偶元组合并,可以使用拉链
 List1(1,2,3,4) List2(3,4,5,6,7) #多余的它会舍掉
println(lis1.zip(lis2)) //List((1,3), (2,4), (3,5), (4,6))

滑动窗口 sliding

   // 滑动窗口window
val intses: Iterator[List[Int]] = list.sliding(3)
for (elem <- intses) {
println(elem) //List(1, 2, 3)
//List(2, 3, 4)
}

过滤filter   a.filter(_%2 == 0)

    // TODO 过滤
val a = List(1, 2, 3, 4)
def test(i: Int): Boolean = {
i % 2 == 0
}
println("过滤=" + a.filter(test)) //简化如下
println(a.filter(_ % 2 == 1))

wordcount

object TestWorldCount {
def main(args: Array[String]): Unit = {
// 数据
val lines = List("Hello Atguigu", "Hello Scala", "Hello Hbase", "Hi Atguigu")
// 将一行的数据进行分解,变成一个一个的单词(扁平化)
val words: List[String] = lines.flatMap(line => {line.split(" ")})
// 将扁平化后的单词进行分组
val groupNameToWordMap: Map[String, List[String]] = words.groupBy(word=>word)
// 将分组后的数据转换为单词和数量的结构 _1是单词分组名称; t._2是集合
val wordToCountMap: Map[String, Int] = groupNameToWordMap.map(t=>{(t._1, t._2.size)})
// 将转换后的数据进行排序
// map(k-v, k1-v1, k2-v2) ==> List((k,v), (k1,v1))
val resultList: List[(String, Int)] = wordToCountMap.toList.sortWith {
case (left, right) => {
left._2 > right._2 //元组, 根据v去比较判断
}
}
---------------简化版-------------------------------
val resultList: List[(String, Int)] = lines.flatMap(_.split(" ")).groupBy(word => word).map(t => {
(t._1, t._2.size)
}).toList.sortWith {
case (left, right) => {
left._2 > right._2
}
}
-----------------------------------------
resultList resultList.foreach(println)
} }

map中_1 key, _2 value

array考虑泛型,map的k,v不考虑泛型

Scala集合常用方法解析的更多相关文章

  1. Scala实战高手****第6课 :零基础实战Scala集合操作及Spark源码解析

    本课内容1.Spark中Scala集合操作鉴赏2.Scala集合操作实战 --------------------------------------------------------------- ...

  2. Scala集合类型详解

    Scala集合 Scala提供了一套很好的集合实现,提供了一些集合类型的抽象. Scala 集合分为可变的和不可变的集合. 可变集合可以在适当的地方被更新或扩展.这意味着你可以修改,添加,移除一个集合 ...

  3. Scala函数式编程(三) scala集合和函数

    前情提要: scala函数式编程(二) scala基础语法介绍 scala函数式编程(二) scala基础语法介绍 前面已经稍微介绍了scala的常用语法以及面向对象的一些简要知识,这次是补充上一章的 ...

  4. Scala词法文法解析器 (二)分析C++类的声明

    最近一直在学习Scala语言,偶然发现其Parser模块功能强大,乃为BNF而设计.啥是BNF,读大学的时候在课本上见过,那时候只觉得这个东西太深奥.没想到所有的计算机语言都是基于BNF而定义的一套规 ...

  5. Scala词法文法解析器 (一)解析SparkSQL的BNF文法

    平台公式及翻译后的SparkSQL 平台公式的样子如下所示: if (XX1_m001[D003]="邢おb7肮α䵵薇" || XX1_m001[H003]<"2& ...

  6. JavaScript数组常用方法解析和深层次js数组扁平化

    前言 数组作为在开发中常用的集合,除了for循环遍历以外,还有很多内置对象的方法,包括map,以及数组筛选元素filter等. 注:文章结尾处附深层次数组扁平化方法操作. 作为引用数据类型的一种,在处 ...

  7. 前端开发:Javascript中的数组,常用方法解析

    前端开发:Javascript中的数组,常用方法解析 前言 Array是Javascript构成的一个重要的部分,它可以用来存储字符串.对象.函数.Number,它是非常强大的.因此深入了解Array ...

  8. Scala集合操作

    大数据技术是数据的集合以及对数据集合的操作技术的统称,具体来说: 1.数据集合:会涉及数据的搜集.存储等,搜集会有很多技术,存储技术现在比较经典方案是使用Hadoop,不过也很多方案采用Kafka.  ...

  9. Device Tree常用方法解析

    Device Tree常用方法解析 Device Tree在Linux内核驱动中的使用源于2011年3月17日Linus Torvalds在ARM Linux邮件列表中的一封邮件,他宣称“this w ...

随机推荐

  1. [BZOJ 3745] [COCI 2015] Norma

    Description 给定一个正整数序列 \(a_1,a_2,\cdots,a_n\),求 \[ \sum_{i=1}^n\sum_{j=i}^n(j-i+1)\min(a_i,a_{i+1},\c ...

  2. poj 3764 The xor-longest Path (01 Trie)

    链接:http://poj.org/problem?id=3764 题面: The xor-longest Path Time Limit: 2000MS   Memory Limit: 65536K ...

  3. Kubernetes 中的渐进式交付:蓝绿部署和金丝雀部署

    渐进式交付是持续交付的下一步, 它将新版本部署到用户的一个子集,并在将其滚动到全部用户之前对其正确性和性能进行评估, 如果不匹配某些关键指标,则进行回滚. 这里有一些有趣的项目,使得渐进式交付在 Ku ...

  4. 【CF1132F】Clear the String(动态规划)

    [CF1132F]Clear the String(动态规划) 题面 CF 题解 考虑区间\(dp\). 增量考虑,每次考虑最后一个字符和谁一起删去,然后直接转移就行了. #include<io ...

  5. webpack学习记录-初步体验(一)

    一.关于webpack 自从出现模块化以后,大家可以将原本一坨代码分离到个个模块中,但是由此引发了一个问题.每个 JS 文件都需要从服务器去拿,由此会导致加载速度变慢.Webpack 最主要的目的就是 ...

  6. OI中卡常数技巧

    一.I/O优化 读入优化是卡常数最重要的一条! inline int read() { ,f=;char c=getchar(); ;c=getchar();} +c-';c=getchar();} ...

  7. 在 Angular6 中使用 HTTP 请求服务端数据

    第一步 准备好api接口地址, 例如 https://api.example.com/api/ 第二步 在根组件 app.module.ts 中引入 HttpClientModule 模块. // a ...

  8. InnoDB-MVCC与乐观锁

    最近通过<高性能MySQL>一书学习MySQL方面的知识,在看到书中所讲InnoDB-MVCC部分的时候,有一种强烈的感觉,这不就是乐观锁吗(入门级小学徒的疑惑脸)?当下便去网上以各种方式 ...

  9. django - 总结 - admin

    admin组件,一旦我们注册了表以后,会自动生成很多url,那他是如何添加的呢, 因为admin在启动后会自动执行每个app下的ready方法: 具体是由 from django.utils.modu ...

  10. Java之final关键字详解

    1. 修饰类 当用final去修饰一个类的时候,表示这个类不能被继承. 注意: a. 被final修饰的类,final类中的成员变量可以根据自己的实际需要设计为fianl. b. final类中的成员 ...