Scala集合详解(第七章:集合、数组、列表、set集合、map集合、元组、队列、并行)(尚硅谷笔记)

最新推荐文章于 2024-07-25 15:23:33 发布
最新推荐文章于 2024-07-25 15:23:33 发布
阅读量1.6k 收藏 4
点赞数 2
分类专栏： 大数据 文章标签： scala java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Argonaut_/article/details/129166767
版权

集合

第七章:集合

7.1 集合简介

1）Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable
特质。
2）对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两
个包

  • 不可变集合：scala.collection.immutable
  • 可变集合： scala.collection.mutable

3）Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而
不会对原对象进行修改。类似于 java 中的 String 对象
4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似
于 java 中 StringBuilder 对象
建议：在操作集合的时候，不可变用符号，可变用方法

7.1.1 不可变集合继承图

在这里插入图片描述
1）Set、Map 是 Java 中也有的集合
2）Seq 是 Java 没有的，我们发现 List 归属到 Seq 了，因此这里的 List 就和 Java 不是同一个
概念了
3）我们前面的 for 循环有一个 1 to 3，就是 IndexedSeq 下的 Range
4）String 也是属于 IndexedSeq
5）我们发现经典的数据结构比如 Queue 和 Stack 被归属到 LinearSeq(线性序列)
6）大家注意 Scala 中的 Map 体系有一个 SortedMap，说明 Scala 的 Map 可以支持排序
7）IndexedSeq 和 LinearSeq 的区别：

  • （1）IndexedSeq 是通过索引来查找和定位，因此速度快，比如 String 就是一个索引集合，通过索引即可定位
  • （2）LinearSeq 是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找

7.1.2 可变集合继承图

在这里插入图片描述

7.2 数组

7.2.1 不可变数组

加粗样式1）第一种方式定义数组

定义：val arr1 = new ArrayInt

  • （1）new 是关键字
  • （2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定 Any
  • （3）(10)，表示数组的大小，确定后就不可以变化

2）案例实操

object TestArray{
 def main(args: Array[String]): Unit = {
 //（1）数组定义
 val arr01 = new Array[Int](4)
 println(arr01.length) // 4
 //（2）数组赋值
 //（2.1）修改某个元素的值
 arr01(3) = 10
 //（2.2）采用方法的形式给数组赋值
 arr01.update(0,1)
 //（3）遍历数组
 //（3.1）查看数组
 println(arr01.mkString(","))
 //（3.2）普通遍历
 for (i <- arr01) {
 println(i)
 }
 //（3.3）简化遍历
 def printx(elem:Int): Unit = {
 println(elem)
 }
 arr01.foreach(printx)
 // arr01.foreach((x)=>{println(x)})
 // arr01.foreach(println(_))
 arr01.foreach(println)
 //（4）增加元素（由于创建的是不可变数组，增加元素，其实是产生新的数
组）
 println(arr01)
 val ints: Array[Int] = arr01 :+ 5
 println(ints)
 }
}

3）第二种方式定义数组
val arr1 = Array(1, 2)

  • （1）在定义数组时，直接赋初始值
  • （2）使用 apply 方法创建数组对象

4）案例实操

object TestArray{
 def main(args: Array[String]): Unit = {
 var arr02 = Array(1, 3, "bobo")
 println(arr02.length)
 for (i <- arr02) {
 println(i)
 }
 }
}

7.2.2 可变数组

1）定义变长数组

val arr01 = ArrayBuffer[Any](3, 2, 5)

  • （1）[Any]存放任意数据类型
  • （2）(3, 2, 5)初始化好的三个元素
  • （3）ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer

2）案例实操

  • （1）ArrayBuffer 是有序的集合
  • （2）增加元素使用的是 append 方法()，支持可变参数
import scala.collection.mutable.ArrayBuffer
object TestArrayBuffer {
 def main(args: Array[String]): Unit = {
 //（1）创建并初始赋值可变数组
 val arr01 = ArrayBuffer[Any](1, 2, 3)
 //（2）遍历数组
 for (i <- arr01) {
 println(i)
 }
 println(arr01.length) // 3
 println("arr01.hash=" + arr01.hashCode())
 //（3）增加元素
 //（3.1）追加数据
 arr01.+=(4)
 //（3.2）向数组最后追加数据
 arr01.append(5,6)
 //（3.3）向指定的位置插入数据
 arr01.insert(0,7,8)
 println("arr01.hash=" + arr01.hashCode())
 //（4）修改元素
 arr01(1) = 9 //修改第 2 个元素的值
 println("--------------------------")
 for (i <- arr01) {
 println(i)
 }
 println(arr01.length) // 5
 }
}

7.2.3 不可变数组与可变数组的转换

1）说明

arr1.toBuffer //不可变数组转可变数组
arr2.toArray //可变数组转不可变数组

  • （1）arr2.toArray 返回结果才是一个不可变数组，arr2 本身没有变化
  • （2）arr1.toBuffer 返回结果才是一个可变数组，arr1 本身没有变化

2）案例实操

object TestArrayBuffer {
 def main(args: Array[String]): Unit = {
 //（1）创建一个空的可变数组
 val arr2 = ArrayBuffer[Int]()
 //（2）追加值
 arr2.append(1, 2, 3)
 println(arr2) // 1,2,3
 //（3）ArrayBuffer ==> Array
 //（3.1）arr2.toArray 返回的结果是一个新的定长数组集合
 //（3.2）arr2 它没有变化
 val newArr = arr2.toArray
 println(newArr)
 
 //（4）Array ===> ArrayBuffer
 //（4.1）newArr.toBuffer 返回一个变长数组 newArr2
 //（4.2）newArr 没有任何变化，依然是定长数组
 val newArr2 = newArr.toBuffer
 newArr2.append(123)
 println(newArr2)
 }
 }

7.2.4 多维数组

1）多维数组定义

val arr = Array.ofDimDouble
说明：二维数组中有三个一维数组，每个一维数组中有四个元素

2）案例实操

object DimArray {
 def main(args: Array[String]): Unit = {
 
 //（1）创建了一个二维数组, 有三个元素，每个元素是，含有 4 个元素一维
数组()
 val arr = Array.ofDim[Int](3, 4)
 arr(1)(2) = 88
 //（2）遍历二维数组
 for (i <- arr) { //i 就是一维数组
 for (j <- i) {
 print(j + " ")
 }
 println()
 }
 }
}

7.3 列表 List

7.3.1 不可变 List

1）说明

  • （1）List 默认为不可变集合
  • （2）创建一个 List（数据有顺序，可重复）
  • （3）遍历 List
  • （4）List 增加数据
  • （5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
  • （6）取指定数据
  • （7）空集合 Nil
    2）案例实操
object TestList {
 def main(args: Array[String]): Unit = {
 //（1）List 默认为不可变集合
 //（2）创建一个 List（数据有顺序，可重复）
 val list: List[Int] = List(1,2,3,4,3)
 
 //（7）空集合 Nil
 val list5 = 1::2::3::4::Nil
 //（4）List 增加数据
 //（4.1）::的运算规则从右向左
 //val list1 = 5::list
 val list1 = 7::6::5::list
 //（4.2）添加到第一个元素位置
 val list2 = list.+:(5)
 //（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
 val list3 = List(8,9)
 //val list4 = list3::list1
 val list4 = list3:::list1
 //（6）取指定数据
 println(list(0))
 //（3）遍历 List
 //list.foreach(println)
 //list1.foreach(println)
 //list3.foreach(println)
 //list4.foreach(println)
 list5.foreach(println)
 }
}

7.3.2 可变 ListBuffer

1）说明

  • （1）创建一个可变集合 ListBuffer
  • （2）向集合中添加数据
  • （3）打印集合数据

2）案例实操

import scala.collection.mutable.ListBuffer
object TestList {
 def main(args: Array[String]): Unit = {
 //（1）创建一个可变集合
 val buffer = ListBuffer(1,2,3,4)
 //（2）向集合中添加数据
 buffer.+=(5)
buffer.append(6)
buffer.insert(1,2)
 //（3）打印集合数据
 buffer.foreach(println)
//（4）修改数据
buffer(1) = 6
buffer.update(1,7)
//（5）删除数据
buffer.-(5)
buffer.-=(5)
buffer.remove(5)
 }
}

7.4 Set 集合

默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用
scala.collection.mutable.Set 包

7.4.1 不可变 Set

1）说明

  • （1）Set 默认是不可变集合，数据无序
  • （2）数据不可重复
  • （3）遍历集合

2）案例实操

object TestSet {
 def main(args: Array[String]): Unit = {
 //（1）Set 默认是不可变集合，数据无序
 val set = Set(1,2,3,4,5,6)
 //（2）数据不可重复
 val set1 = Set(1,2,3,4,5,6,3)
 //（3）遍历集合
 for(x<-set1){
 println(x)
 }
 }
}

7.4.2 可变 mutable.Set

1）说明

  • （1）创建可变集合 mutable.Set
  • （2）打印集合
  • （3）集合添加元素
  • （4）向集合中添加元素，返回一个新的 Set
  • （5）删除数据

2）案例实操

object TestSet {
 def main(args: Array[String]): Unit = {
 //（1）创建可变集合
 val set = mutable.Set(1,2,3,4,5,6)
 //（3）集合添加元素
 set += 8
 //（4）向集合中添加元素，返回一个新的 Set
 val ints = set.+(9)
 println(ints)
 println("set2=" + set)
 //（5）删除数据
 set-=(5)
  //（2）打印集合
 set.foreach(println)
 println(set.mkString(","))
 }
}

7.5 Map 集合

Scala 中的 Map 和 Java 类似，也是一个散列表，它存储的内容也是键值对（key-value）
映射

7.5.1 不可变 Map

1）说明

  • （1）创建不可变集合 Map
  • （2）循环打印
  • （3）访问数据
  • （4）如果 key 不存在，返回 0

2）案例实操

object TestMap {
 def main(args: Array[String]): Unit = {
 // Map
 //（1）创建不可变集合 Map
 val map = Map( "a"->1, "b"->2, "c"->3 )
 //（3）访问数据
 for (elem <- map.keys) {
 // 使用 get 访问 map 集合的数据，会返回特殊类型 Option(选项):
有值（Some），无值(None)
 println(elem + "=" + map.get(elem).get)
 }
 //（4）如果 key 不存在，返回 0
 println(map.get("d").getOrElse(0))
 println(map.getOrElse("d", 0))
 //（2）循环打印
 map.foreach((kv)=>{println(kv)})
 }
}

7.5.2 可变 Map

1）说明

  • （1）创建可变集合
  • （2）打印集合
  • （3）向集合增加数据
  • （4）删除数据
  • （5）修改数据

2）案例实操

object TestSet {
 def main(args: Array[String]): Unit = {
 //（1）创建可变集合
 val map = mutable.Map( "a"->1, "b"->2, "c"->3 )
 //（3）向集合增加数据
 map.+=("d"->4)
 // 将数值 4 添加到集合，并把集合中原值 1 返回
 val maybeInt: Option[Int] = map.put("a", 4)
 println(maybeInt.getOrElse(0))
 //（4）删除数据
 map.-=("b", "c")
 //（5）修改数据
 map.update("d",5)
map("d") = 5
 //（2）打印集合
 map.foreach((kv)=>{println(kv)})
 }
}

7.6 元组

1）说明

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。
注意：元组中最大只能有 22 个元素。

2）案例实操

  • （1）声明元组的方式：(元素 1，元素 2，元素 3)
  • （2）访问元组
  • （3）Map 中的键值对其实就是元组,只不过元组的元素个数为 2，称之为对偶
object TestTuple {
 def main(args: Array[String]): Unit = {
 //（1）声明元组的方式：(元素 1，元素 2，元素 3)
 val tuple: (Int, String, Boolean) = (40,"bobo",true)
 //（2）访问元组
 //（2.1）通过元素的顺序进行访问，调用方式：_顺序号
 println(tuple._1)
 println(tuple._2)
 println(tuple._3)
 //（2.2）通过索引访问数据
 println(tuple.productElement(0))
 //（2.3）通过迭代器访问数据
 for (elem <- tuple.productIterator) {
 println(elem)
 }
 //（3）Map 中的键值对其实就是元组,只不过元组的元素个数为 2，称之为
对偶
 val map = Map("a"->1, "b"->2, "c"->3)
 val map1 = Map(("a",1), ("b",2), ("c",3))
 map.foreach(tuple=>{println(tuple._1 + "=" + tuple._2)})
 }
}

7.7 集合常用函数

7.7.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))
 }
}

7.7.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)
 }
}

7.7.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 函数，实现自定义排序的逻辑。

7.7.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 
atguigu", "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)
 }
}

7.7.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)
 }
}

7.7.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)
 */
 }
}

7.8 队列

1）说明

Scala 也提供了队列（Queue）的数据结构，队列的特点就是先进先出。进队和出队的方
法分别为 enqueue 和 dequeue。

2）案例实操

object TestQueue {
 def main(args: Array[String]): Unit = {
 val que = new mutable.Queue[String]()
 que.enqueue("a", "b", "c")
 println(que.dequeue())
 println(que.dequeue())
 println(que.dequeue())
 }
}

7.9 并行集合

1）说明

Scala 为了充分使用多核 CPU，提供了并行集合（有别于前面的串行集合），用于多核
环境的并行计算。

2）案例实操

object TestPar {
 def main(args: Array[String]): Unit = {
  val result1 = (0 to 100).map{case _ => 
Thread.currentThread.getName}
 val result2 = (0 to 100).par.map{case _ => 
Thread.currentThread.getName}
 println(result1)
 println(result2)
 }
}
Argonaut_
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021-03-08~09~10~11~12 大数据课程笔记 day47day48day49day50day51
qq_44745905的博客
03-12 1054
@R星校长 大数据技术之Flink 第一章 初识Flink   在当前数据量激增的时代，各种业务场景都有大量的业务数据产生，对于这些不断产生的数据应该如何进行有效的处理，成为当下大多数公司所面临的问题。目前比较流行的大数据处理引擎Apache Spark，基本上已经取代了MapReduce成为当前大数据处理的标准。但对实时数据处理来说，Apache Spark的Spark-Streaming还有性能改进的空间。对于Spark-Streaming的流计算本质上还是批（微批）计算，Apache Flink.
Scala 数组集合
01-07
Scala 常用数组集合简单总结 数组 Array-数组 //伴⽣对象创建数组 var a1=Array(1,2,3,5,4) //创建⻓度为5的数组，所有值都是0 var a2=new Array[Int](5) //获取⻓度 a1.length a2.size //修改 a1(1) = -1 a1.update...
Scala基础语法详解
Bessenn的博客
12-12 1173
Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性.Scala 运行在Java虚拟机上，并兼容现有的Java程序.Scala 源代码被编译成Java字节码，所以它可以运行于JVM之上，并可以调用现有的Java类库。
Scala超全详解
lukabruce的博客
08-16 1万+
转自：【https://blog.csdn.net/c391183914/article/details/78647533?locationNum=2&amp;fps=1】 一 Scala安装与配置 1 安装 2 配置IDEA 二 Scala基础 1 Hello Scala 11 IDEA运行HelloScala程序 12 控制台运行HelloScala程序 ...
笔记：新手的Spark指南
MrLevo520的博客
07-25 2146
macOS Sierra 10.12.4Spark 1.6.2Python 2.7转载请注明出处：前言 既然做了Hive的整理，那就把spark的也整理下吧，当做入门指南和自己的笔记吧~与君共勉 Spark基础Spark是什么？ Spark是个通用的集群计算框架，通过将大量数据集计算任务分配到多台计算机上，提供高效内存计算。如果你熟悉Hadoop，那么你知道分布式计算框架要解决两个问题：如何
flink学习
weixin_38312502的博客
02-14 958
尚硅谷Flink入门到实战-学习笔记 尚硅谷2021最新Java版Flink 下面笔记来源（尚硅谷公开资料、网络博客、个人小结） 中间会把自己认为较重要的点做做标记（下划线、加粗等） 1. Flink的特点 事件驱动（Event-driven） 基于流处理 一切皆由流组成，离线数据是有界的流；实时数据是一个没有界限的流。（有界流、无界流） 分层API 越顶层越抽象，表达含义越简明，使用越方便 越底层越具体，表达能力越丰富，使用越灵活 1.1 Flink vs Spark Stream
Spark Streaming笔记
好女绪的博客
03-22 353
Spark Streaming笔记 转载自Spark修炼之道 1. Spark流式计算简介 Hadoop的MapReduce及Spark SQL等只能进行离线计算，无法满足实时性要求较高的业务需求，例如实时推荐、实时网站性能分析等，流式计算可以解决这些问题。目前有三种比较常用的流式计算框架，它们分别是Storm，Spark Streaming和Samza，各个框架的比较及使用情况，可以参见：htt...
大数据开发面试知识点总结
热门推荐
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
02-09 2万+
​本文详细介绍大数据hadoop生态圈各部分知识，包括不限于hdfs、yarn、mapreduce、hive、sqoop、kafka、flume、spark、flink等技术，总结内容适合大数据开发者学习，希望能够和大家多多交流。
Python 核心编程笔记
wangquan2596489的专栏
09-22 2900
代码改变世界 Posts - 507, Articles - 262, Comments - 738 CnblogsDashboardLogin HomeContactGalleryRSS 一个人的旅行 白首为功名。旧山松竹老，阻归程。欲将心事付瑶琴。知音少，弦断有谁听？ python核心编程--笔记（不定时跟新） 2011-11-09 23:12 by
Flink从入门到入土（详细教程）
Java笔记虾
09-02 5543
和其他所有的计算框架一样，flink也有一些基础的开发步骤以及基础，核心的API，从开发步骤的角度来讲，主要分为四大部分1.Environment Flink Job在提交执行计算时，需...
Scala集合（二）Java开发Java经验技巧共10页
11-22
1. Scala集合框架：介绍Scala集合库的基本结构，如Seq、Set、Map等，以及它们与Java集合的区别。 2. 高级特性：可能涉及函数式编程的概念，如高阶函数、惰性求值和不可变性，以及这些特性如何在Scala集合中实现。 3....
Scala集合Java开发Java经验技巧共9页.pdf
11-22
Scala的集合库是其一大亮点，它提供了丰富的数据结构，如List、Set、Map等，并且这些集合都是不可变的，这在多线程环境中带来了显著的安全性提升。此外，Scala集合库还支持高阶函数，如map、filter、fold等，使得...
Scala函数式编程专题--scala集合和函数
08-18
Scala函数式编程专题--scala集合和函数 以下是关于Scala函数式编程专题--scala集合和函数的知识点： 1. Scala 集合介绍 Scala 集合是指 Scala 语言中的数据结构，包括 List、Tuple、Map 等。这些集合类型都有其...
A1.zip_YLB_zip_快学Scala 课后习题答案集合
09-23
Scala是一种强大的多范式编程语言，它融合了面向对象和函数式编程的概念。"快学Scala"可能是一个教育课程或教程，旨在帮助学习者迅速掌握Scala的基础和高级特性。"课后习题答案集合"表明这个压缩包包含了该课程相关...
探索Perl的图形用户界面开发：工具、技巧与实践
2402_85762143的博客
07-23 1214
Perl的GUI开发提供了多种工具和方法，允许开发者根据项目需求和个人偏好选择合适的工具包。通过遵循最佳实践和利用Perl的强大功能，开发者可以创建出既美观又实用的GUI应用程序。随着技术的不断发展，Perl社区也在不断推出新的工具和库，以支持更高效、更现代的GUI开发。本文只是一个入门指南，深入学习Perl GUI开发还需要阅读更多的文档、参与社区讨论和实践项目。希望本文能为你的Perl GUI开发之旅提供一些帮助和启发。
Spark实时（三）：Structured Streaming入门案例
Lansonli（蓝深李）的博客
07-24 816
我们使用Structured Streaming来监控socket数据统计WordCount。
探索Perl的奇妙世界：入门学习与实战指南
最新发布
sinner小屋
07-25 1506
《探索Perl的奇妙世界：入门学习与实战指南》为大家提供了一个全面的Perl编程学习路径，从基础知识到高级技巧，涵盖了Perl在Web开发、数据库操作和生物信息学中的实际应用。通过详实的代码案例和实战演练，本书帮助大家深入理解Perl的强大功能和灵活性。同时，文中还探讨了Perl的优势与局限，以及其在未来的发展潜力，适合所有希望提升Perl编程技能的读者。
Kafka知识总结（基本介绍+基本概念）
月伴飞鱼
07-24 1235
通过异步处理提高系统性能（减少响应所需时间）削峰/限流降低系统耦合性。
Scala集合框架详解：Seq, Set与Map的 immutable与mutable对比
Scala的集合主要分为三大类别：序列（Seq）、集（Set）和映射（Map），这些集合都继承自`Iterable`特质，体现了函数式编程中的数据流概念。 1. **集合类型**: - **序列（Seq）**: Seq是最常用的不可变序列类型，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值