Scala Spark的使用

最新推荐文章于 2024-05-03 13:10:58 发布
最新推荐文章于 2024-05-03 13:10:58 发布
阅读量650 收藏 7
点赞数
分类专栏： Spark 文章标签： Scala Spark RDD 算子
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22511813/article/details/103038020
版权

SparkContext的创建

#创建一个SparkConf
val work: SparkConf = new >SparkConf().setMaster(“local[*]”).setAppName(“work”)
#创建一个SparkContext
val sc = new SparkContext(work)

Spark RDD创建

  1. 创建一个RDD(有如下几种方式)

val rdd = sc.parallelize(Arral(1,2,3,4,5,6,7,8))
val rdd = sc.makeRDD(Array(1,2,3,4,5,6,7,8))
val rdd = sc…textFile(“scr/hotel.txt”)

转换算子

  1. map算子
  2. flatMap算子
  3. mapPartitions算子
  4. mapPartitionsWithlndex算子
  5. union算子
  6. cartesian算子
  7. groupBy算子、groupByKey算子
  8. filter算子
  9. distinct算子
  10. subtract算子
  11. sample算子
  12. cache算子
  13. persist算子
  14. mapValues算子、flatMapValues算子
  15. combineByKey算子
  16. reduceByKey算子
  17. repartition算子
  18. cogroup算子
  19. join算子
  20. leftOutJoin和rightOutJoin算子、fullOuterJoin算子
  21. intersection算子
  22. foreach算子
  23. saveAsTextFile算子
  24. saveAsObjectFile算子
  25. collect算子
  26. collectAsMap算子
  27. count，countByKey，CountByValue算子
  28. take、takeSample算子
  29. reduce算子
  30. aggregate算子
  31. zip、zipWithlndex算子（转换算子）
Value数据类型的Transformation算子
  • 输入分区与输出分区一对一型
  1. map算子

处理数据是一对一的关系，进入一条数据，出去的还是一条数据。map的输入变换函数应用于RDD中所有的元素，而mapPartitions应用于所有分区。区别于mapPartitions主要在于调度粒度不同。如parallelize（1 to 10 ，3），map函数执行了10次，而mapPartitions函数执行了3次。

val infos: RDD[String] = sc.parallelize(Array[String]("hello spark","hello hdfs","hello HBase"))
val result: RDD[Array[String]] = infos.map(one => {
  one.split(" ")
})
result.foreach(arr =>{arr.foreach(println)})
  1. flatMap算子

flatMap是一对多的关系，处理一条数据得到多条结果，将原来 RDD 中的每个元素通过函数 f 转换为新的元素，并将生成的 RDD 的每个集合中的元素合并为一个集合。

val infos: RDD[String] = sc.makeRDD(Array[String]("hello spark","hello hdfs","hello MapReduce"))
val rdd1: RDD[String] = infos.flatMap(one => {
  one.split(" ")
})
rdd1.foreach(println)
  1. mapPartitions算子

mapPartitions遍历的是每一个分区中的数据，一个个分区的遍历。获取到每个分区的迭代器，在函数中通过这个分区整体的迭代 器对整 个分区的元素进行操作，相对于map一条条处理数据，性能比较高，可获取返回值。
可以通过函数f(iter) =>iter.filter(_>=3)对分区中所有的数据进行过滤，大于和等于3的数据保留，一个方块代表一个RDD分区，含有1,2,3的分区过滤，只剩下元素3。

val listRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6,5,4,3,2,1), 2)
    val mappartitionsRDD: RDD[Int] = listRDD.mapPartitions(x => {
      x.filter(_ > 3)
    })
    mappartitionsRDD.foreach(println(_))
  1. mapPartitionsWithlndex算子

拿到每个RDD中的分区，以及分区中的数据

val lines: RDD[String] = sc.textFile("./data/words",5)
    val result: RDD[String] = lines.mapPartitionsWithIndex((index, iter) => {
      val arr: ArrayBuffer[String] = ArrayBuffer[String]()
      iter.foreach(one => {
//        one.split(" ")
        arr.append(s"partition = [$index] ,value = $one")
      })
      arr.iterator
    }, true)
    result.foreach(println)

打印结果

  • 输入分区与输出分区多对一型
  1. union算子

union合并两个RDD，两个RDD必须是同种类型，不一定是K，V格式的RDD

val rdd1: RDD[String] = sc.parallelize(List[String]("zhangsan","lisi","wangwu","maliu"),3)
val rdd2: RDD[String] = sc.parallelize(List[String]("a","b","c","d"),4)
val unionRDD: RDD[String] = rdd1.union(rdd2)
unionRDD.foreach(println)
  1. cartesian算子

求笛卡尔积，该操作不会执行shuffle操作，但最好别用，容易触发OOM

val conf=new SparkConf().setAppName("cratesian").setMaster("local")
    val sc=new SparkContext(conf)

    val arr1=sc.parallelize(Array(1,3,5))
    val arr2=sc.parallelize(Array(2,4,6))
    arr1.cartesian(arr2).collect.foreach(println)
  • 输出分区与输出分区多对多型
  1. groupBy算子、groupByKey算子

groupBy算子按照指定的规则，将数据分组

val rdd: RDD[(String, Double)] = sc.parallelize(List[(String,Double)](("zhangsan",66.5),("lisi",33.2),("zhangsan",66.7),("lisi",33.4),("zhangsan",66.8),("wangwu",29.8)))
val result: RDD[(Boolean, Iterable[(String, Double)])] = rdd.groupBy(one => {
  one._2 > 34
})
result.foreach(println)

打印结果

groupByKey算子根据key去将相同的key对应的value合并在一起（K,V）=>(K,[V])

val rdd: RDD[(String, Double)] = sc.parallelize(List[(String,Double)](("zhangsan",66.5),("lisi",33.2),("zhangsan",66.7),("lisi",33.4),("zhangsan",66.8),("wangwu",29.8)))
val rdd1: RDD[(String, Iterable[Double])] = rdd.groupByKey()
rdd1.foreach(info=>{
  val name: String = info._1
  val value: Iterable[Double] = info._2
  val list: List[Double] = info._2.toList
  println("name = "+name+",value ="+list)
})

打印结果

  • 输出分区是输入分区子集类型
  1. filter算子

过滤数据，返回true的数据会被留下

val infos: RDD[String] = sc.makeRDD(List[String]("hehe","hahha","zhangsan","lisi","wangwu"))
val result: RDD[String] = infos.filter(one => {
  !one.equals("zhangsan")
})
result.foreach(println)

打印结果
9. distinct算子

distinct去重，有shuffle产生，内部实际是map+reduceByKey+map实现

val infos: RDD[String] = sc.parallelize(List[String]("a","a","b","a","b","c","c","d"),4)
val result: RDD[String] = infos.distinct()
result.foreach(println)

打印结果

  1. subtract算子

取RDD的差集，subtract两个RDD的类型要一致，结果RDD的分区数与subtract算子前面的RDD分区数多的一致。

val rdd1 = sc.parallelize(List[String]("zhangsan","lisi","wangwu"),5)
val rdd2 = sc.parallelize(List[String]("zhangsan","lisi","maliu"),4)
val subtractRDD: RDD[String] = rdd1.subtract(rdd2)
subtractRDD.foreach(println)
println("subtractRDD partition length = "+subtractRDD.getNumPartitions)

打印结果
11. sample算子

sample随机抽样，参数sample（withReplacement:有无放回抽样，fraction:抽样的比例，seed:用于指定的随机数生成器的种子）
有种子和无种子的区别：
有种子是只要针对数据源一样，都是指定相同的参数，那么每次抽样到的数据都是一样的
没有种子是针对同一个数据源，每次抽样都是随机抽样

val lines: RDD[String] = sc.textFile("./data/sampleData.txt")
val result: RDD[String] = lines.sample(true,0.01,100)
result.foreach(println)
sc.stop

打印结果

  • Cache算子
  1. cache算子
  2. persist算子

cache()和persist()注意问题
1.cache()和persist()持久化单位是partition，cache()和persist()是懒执行算子，需要action算子触发执行
2.对一个RDD使用cache或者persist之后可以赋值给一个变量，下次直接使用这个变量就是使用持久化的数据。也可以直接对RDD进行cache或者persist，不赋值给一个变量
3.如果采用第二种方法赋值给变量的话，后面不能紧跟action算子
4.cache()和persist()的数据在当前application执行完成之后会自动清除

val conf: SparkConf = new SparkConf().setMaster("local").setAppName("cache")
    val sc: SparkContext = new SparkContext(conf)
    sc.setLogLevel("Error")
    val lines: RDD[String] = sc.textFile("./data/persistData.txt")

    //    val linescache: RDD[String] = lines.persist(StorageLevel.MEMORY_ONLY)
    val linescache: RDD[String] = lines.cache()

    val startTime1: Long = System.currentTimeMillis()
    val count1: Long = linescache.count()
    val endTime1: Long = System.currentTimeMillis()
    println("count1 = "+count1+". time = "+(endTime1-startTime1) + "mm")

    val starttime2: Long = System.currentTimeMillis()
    val count2: Long = linescache.count()
    val endTime2: Long = System.currentTimeMillis()
    println("count2 = "+count2+", time = "+(endTime2-starttime2) + "ms")
    sc.stop()
Key-Value数据类型的Transformation算子
  • 输入分区与输出分区一对一
  1. mapValues算子、flatMapValues算子

mapValues算子针对K，V格式的数据，只对Value做操作，Key保持不变

val infos: RDD[(String, String)] = sc.makeRDD(
    List[(String,String)](
    ("zhangsan","18"),("lisi","20"),("wangwu","30")
    ))
val result: RDD[(String, String)] = infos.mapValues(s => {
  s + " " + "zhangsan18"
})
result.foreach(println)
sc.stop()

打印结果

flatMapValues算子（K,V）->(K,V)，作用在K,V格式的RDD上，对一个Key的一个Value返回多个Value

  • 对单个RDD或者两个RDD聚集
单个RDD聚集
  1. combineByKey算子

首先给RDD中每个分区中的每一个key一个初始值
其次在RDD每个分区内部相同的key聚合一次
再次在RDD不同的分区之间将相同的key结果聚合一次

val rdd1: RDD[(String, Int)] = sc.makeRDD(List[(String, Int)](
  ("zhangsan", 10), ("zhangsan", 20), ("wangwu", 30),
  ("lisi", 40), ("zhangsan", 50), ("lisi", 60),
  ("wangwu", 70), ("wangwu", 80), ("lisi", 90)
),3)
rdd1.mapPartitionsWithIndex((index,iter)=>{
  val arr: ArrayBuffer[(String, Int)] = ArrayBuffer[(String,Int)]()
  iter.foreach(tp=>{
    arr.append(tp)
    println("rdd1 partition index ="+index+".value ="+tp)
  })
  arr.iterator
}).count()
println("++++++++++++++++++++++++++++++++++++")
val result: RDD[(String, String)] = rdd1.combineByKey(v=>{v+"hello"}, (s:String, v)=>{s+"@"+v}, (s1:String, s2:String)=>{s1+"#"+s2})
result.foreach(println)

打印结果

  1. reduceByKey算子

首先会根据key去分组，然后在每一组中将value聚合，作用在KV格式的RDD上

val infos: RDD[(String, Int)] = sc.parallelize(
    List[(String,Int)](("zhangsan",1),("zhangsan",2),
    ("zhangsan",3),("lisi",100),("lisi",200)),5
    )
val result: RDD[(String, Int)] = infos.reduceByKey((v1, v2)=>{v1+v2})
result.foreach(println)
sc.stop()

打印结果
17. repartition算子

重新分区，可以将RDD的分区增多或者减少，会产生shuffle，coalesc(num,true) = repartition(num)

val rdd1: RDD[String] = sc.parallelize(List[String](
  "love1", "love2", "love3", "love4",
  "love5", "love6", "love7", "love8",
  "love9", "love10", "love11", "love12"
), 3)
val rdd2: RDD[String] = rdd1.mapPartitionsWithIndex((index, iter) => {
  val list: ListBuffer[String] = ListBuffer[String]()
  iter.foreach(one => {
    list.append(s"rdd1 partition = [$index] ,value = [$one]")
  })
  list.iterator
}, true)
val rdd3: RDD[String] = rdd2.repartition(3)
val rdd4: RDD[String] = rdd3.mapPartitionsWithIndex((index, iter) => {
  val arr: ArrayBuffer[String] = ArrayBuffer[String]()
  iter.foreach(one => {
    arr.append(s"rdd3 partition = [$index] ,value = [$one]")
  })
  arr.iterator
})
val results: Array[String] = rdd4.collect()
results.foreach(println)
sc.stop()

打印结果

两个RDD聚集
  1. cogroup算子

合并两个RDD,生成一个新的RDD。分区数与分区数多个那个RDD保持一致

val rdd1 = sc.parallelize(List[(String,String)](("zhangsan","female"),("zhangsan","female1"),("lisi","male"),("wangwu","female"),("maliu","male")),3)
val rdd2 = sc.parallelize(List[(String,Int)](("zhangsan",18),("lisi",19),("lisi",190),("wangwu",20),("tianqi",21)),4)
val resultRDD: RDD[(String, (Iterable[String], Iterable[Int]))] = rdd1.cogroup(rdd2)

resultRDD.foreach(info=>{
  val key = info._1
  val value1: List[String] = info._2._1.toList
  val value2: List[Int] = info._2._2.toList
  println("key ="+key+",value"+value1+", value2 = "+value2)
})
println("resultRDD partition length ="+resultRDD.getNumPartitions)
sc.stop()

打印结果

  • 连接
  1. join算子

会产生shuffle,(K,V)格式的RDD和(K,V)格式的RDD按照相同的K，join得到(K,(V,W))格式的数据，分区数按照大的来。

val nameRDD: RDD[(String, String)] = sc.parallelize(List[(String,String)](("zhangsan","female"),("lisi","male"),("wangwu","female")),3)
val scoreRDD: RDD[(String, Int)] = sc.parallelize(List[(String,Int)](("zhangsan",18),("lisi",19),("wangwu",20)),2)
val joinRDD: RDD[(String, (String, Int))] = nameRDD.join(scoreRDD)
println(joinRDD.getNumPartitions)
joinRDD.foreach(println)

打印结果
20. leftOutJoin和rightOutJoin算子、fullOuterJoin算子

leftOuterJoin(K,V)格式的RDD和(K,V)格式的RDD，使用leftOuterJoin结合，以左边的RDD出现的key为主 ，得到(K,(V,Option(W)))

val nameRDD: RDD[(String, String)] = sc.parallelize(
    List[(String,String)](("zhangsan","female"),
    ("lisi","male"),("wangwu","female"),("maliu","male")
    ))
val scoreRDD: RDD[(String, Int)] = sc.parallelize(
    List[(String,Int)](("zhangsan",22),("lisi",19),
    ("wangwu",20),("tianqi",21)
    ))
val leftOutJoin: RDD[(String, (String, Option[Int]))] = nameRDD.leftOuterJoin(scoreRDD)
leftOutJoin.foreach(println)
sc.stop()

打印结果

rightOuterJoin(K,V)格式的RDD和（K,W）格式的RDD使用rightOuterJoin结合以右边的RDD出现的key为主，得到(K,(Option(V),W))

val nameRDD: RDD[(String, String)] = sc.parallelize(
    List[(String,String)](("zhangsan","female"),("lisi","male")
    ,("wangwu","female"),("maliu","male")),3
    )
  val scoreRDD: RDD[(String, Int)] = sc.parallelize(
      List[(String,Int)](("zhangsan",18),("lisi",19),
      ("wangwu",20),("tianqi",21)),4
      )
  val rightOuterJoin: RDD[(String, (Option[String], Int))] = nameRDD.rightOuterJoin(scoreRDD)
  rightOuterJoin.foreach(println)
  println("rightOuterJoin RDD partiotion length = "+rightOuterJoin.getNumPartitions)
  sc.stop()

打印结果

fullOuterJoin算子(K,V)格式的RDD和(K,V)格式的RDD，使用fullOuterJoin结合是以两边的RDD出现的key为主，得到(K(Option(V),Option(W)))

val nameRDD: RDD[(String, String)] = sc.parallelize(List[(String,String)](("zhangsan","female"),("lisi","male"),("wangwu","female"),("maliu","male")),3)
val ageRDD: RDD[(String, Int)] = sc.parallelize(List[(String,Int)](("zhangsan",18),("lisi",16),("wangwu",20),("tianqi",21)),4)
val fullOuterJoin: RDD[(String, (Option[String], Option[Int]))] = nameRDD.fullOuterJoin(ageRDD)
fullOuterJoin.foreach(println)
println("fullOuterJoin RDD partition length = "+fullOuterJoin.getNumPartitions)
sc.stop()

打印结果

  1. intersection算子

intersection取两个RDD的交集，两个RDD的类型要一致，结果RDD的分区数要与两个父RDD多的那个一致

val rdd1: RDD[String] = sc.parallelize(List[String]("zhangsan","lisi","wangwu"),5)
val rdd2: RDD[String] = sc.parallelize(List[String]("zhangsan","lisi","maliu"),4)
val result: RDD[String] = rdd1.intersection(rdd2)
result.foreach(println)
println("intersection partition length = "+ result.getNumPartitions)
sc.stop()

打印结果

行动算子

Action算子
  • 无输出
  1. foreach算子

foreach遍历RDD中的每一个元素

val lines: RDD[String] = sc.textFile("./data/words") lines.foreach(println)
  • HDFS
  1. saveAsTextFile算子

将DataSet中的元素以文本的形式写入本地文件系统或者HDFS中，Spark将会对每个元素调用toString方法，将数据元素转换成文本文件中的一行数据，若将文件保存在本地文件系统，那么只会保存在executor所在机器的本地目录

val infos: RDD[String] = sc.parallelize(List[String]("a","b","c","e","f","g"),4)

infos.saveAsTextFile("./data/infos")

目录结构

  1. saveAsObjectFile算子

将数据集中元素以ObjectFile形式写入本地文件系统或者HDFS中

infos.saveAsObjectFile("./data/infosObject")

目录结构

  • Scala集合和数据类型
  1. collect算子

collect回收算子，会将结果回收到Driver端，如果结果比较大,就不要回收，这样的话会造成Driver端的OOM

val lines: RDD[String] = sc.textFile("./data/words")
sc.setLogLevel("Error")
val result: Array[String] = lines.collect()
result.foreach(println)

打印结果

  1. collectAsMap算子

将K、V格式的RDD回收到Driver端作为Map使用

val weightInfos: RDD[(String, Double)] = sc.parallelize(
    List[(String,Double)](new Tuple2("zhangsan",99),
        new Tuple2("lisi",78.6),
        new Tuple2("wangwu",122.2323)
        )
        )
val stringToDouble: collection.Map[String, Double] = weightInfos.collectAsMap()
stringToDouble.foreach(tp=>{
  println(tp._1+"**************"+tp._2)
})
sc.stop()

打印结果

  1. count，countByKey，CountByValue算子

count统计RDD共有多少行数据

val lines: RDD[String] = sc.textFile("./data/sampleData.txt")

val result: Long = lines.count()

println(result)

sc.stop()
直接给出结果行数

countByKey统计相同的key出现的个数

val rdd: RDD[(String, Integer)] = sc.makeRDD(List[(String,Integer)](
    ("a",1),("a",100),("a",1000),("b",2),("b",200),("c",3),("c",4),("d",122)
    ))
val result: collection.Map[String, Long] = rdd.countByKey()
result.foreach(println)

countByValue统计RDD中相同的Value出现的次数，不要求数据必须为RDD格式

val rdd = sc.makeRDD(List[(String,Integer)](
    ("a",1),("a",1),("a",1000),("b",2),("b",200),("c",3),("c",3)
    ))
val result: collection.Map[(String, Integer), Long] = rdd.countByValue()
result.foreach(println)

打印结果

  1. take、takeSample算子

take取出RDD中的前N个元素

val lines: RDD[String] = sc.textFile("./data/words")

val array: Array[String] = lines.take(3)

array.foreach(println)

takeSapmle(withReplacement,num,seed)，随机抽样将数据结果拿回Driver端使用，返回Array，
withReplacement:有无放回抽样，num:抽样的条数，seed:种子

val lines: RDD[String] = sc.textFile("./data/words")

val result: Array[String] = lines.takeSample(false,3,10)

result.foreach(println)

打印结果

  1. reduce算子
val rdd: RDD[Int] = sc.makeRDD(Array[Int](1,2,3,4,5))

val result: Int = rdd.reduce((v1, v2) => { v1 + v2 })

//直接得到结果

println(result) }
  1. aggregate算子

首先是给定RDD的每一个分区一个初始值，然后RDD中每一个分区中按照相同的key，结合初始值去合并，最后RDD之间相同的key聚合

val rdd1: RDD[(String, Int)] = sc.makeRDD(List[(String, Int)](
  ("zhangsan", 10), ("zhangsan", 20), ("wangwu", 30),
  ("lisi", 40), ("zhangsan", 50), ("lisi", 60),
  ("wangwu", 70), ("wangwu", 80), ("lisi", 90)
), 3)
rdd1.mapPartitionsWithIndex((index,iter)=>{
  val arr: ArrayBuffer[(String, Int)] = ArrayBuffer[(String,Int)]()
  iter.foreach(tp=>{
    arr.append(tp)
    println("rdd1 partition index ="+index+", value ="+tp)
  })
  arr.iterator
}).count()
val result: RDD[(String, String)] = 
    rdd1.aggregateByKey("hello")(
        (s, v)=>{s+"~"+v}, (s1, s2)=>{s1+"#"+s2}
        )
result.foreach(println)

打印结果
打印结果
mapPartitionsWithIndex注释掉执行结果：
打印结果

  1. zip、zipWithlndex算子（转换算子）

zip算子 —Transformation类算子，将两个RDD合成一个K，V格式的RDD，分区数要相同，每个分区中的元素必须相同

val rdd1: RDD[String] = sc.parallelize(List[String]("a","b","c","d"),2)
val rdd2: RDD[Int] = sc.parallelize(List[Int](1,2,3,4),2)
val result: RDD[(String, Int)] = rdd1.zip(rdd2)
result.foreach(println)

打印结果
打印结果
zipWithIndex算子—Transformation类算子

val rdd1 = sc.parallelize(List[String]("a","b","c"),2)
val rdd2 = sc.parallelize(List[Int](1,2,3),numSlices = 2)
val result: RDD[(String, Long)] = rdd1.zipWithIndex()
val result2: RDD[(Int, Long)] = rdd2.zipWithIndex()
result.foreach(println)
result2.foreach(println)

打印结果
在这里插入图片描述

Spark内置函数RDD Spark中有收藏–Spark RDD的函数详解

将程序打包成jar包在集群上运行

pass

List匹配

//partition:按照某种条件对数据进行分类
        //def partition(p: A => Boolean): (Repr, Repr)
        println(List(1, 2, 3, 4, 5) partition (_ % 2 == 0))
        //(List(2, 4),List(1, 3, 5))
      
        //find:查找集合第一个符合条件的元素
        //def find(p: A => Boolean): Option[A]
        println(List(1, 2, 3, 4, 5) find (_ % 2 == 0)) //Some(2)
        println(List(1, 2, 3, 4, 5) find (_ <= 0))     //None
        
        //takeWhile:着个匹配符合条件的元素 直到不符合条件 之后的元素不在判断
        //override def takeWhile(p: A => Boolean): List[A]
        println(List(6, 5, 2, 3, 5) takeWhile (_ < 4))
        //List()
        
        //dropWhile:着个匹配去除符合条件的元素 直到不符合条件 之后的元素不在判断
        //override def dropWhile(p: A => Boolean): List[A]
        println(List(1, 2, 6, 4, 5) dropWhile (_ < 4))
        //List(6, 4, 5)
      
        //span 着个匹配按照某种条件对数据进行分类 直到不符合条件 之后的元素不在判断
        //override def span(p: A => Boolean): (List[A], List[A])
        println(List(1, 7, 3, 4, 5) span (_ < 4))
        //(List(1),List(7, 3, 4, 5))
        
        //forall  当所有的元素满足条件时 返回true 否则返回false
        //def forall(p: A => Boolean): Boolean
        println(List(1, 7, 3, 4, 5) forall (_ >= 4))   //false
        println(List(11, 7, 13, 4, 5) forall (_ >= 4)) //true
        println
        
        //exists  当存在(至少有一个满足)元素满足条件时 返回true 否则返回false
        //def exists(p: A => Boolean): Boolean
        println(List(1, 7, 3, 4, 5) exists (_ >= 4))   //true
        println(List(11, 7, 13, 4, 5) exists (_ >= 4)) //true
        
        println
        def hastotallyZeroRow(m: List[List[Int]]) = m exists (row => row forall (_ == 0))
        val m = List(List(1, 0, 0), List(0, 1, 0), List(0, 0, 0))
        println(hastotallyZeroRow(m))   //true
晓喻丶
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark算子
JasonChen3318的博客
05-07 538
1.parallelize 1.解释 - 并行集合的创建（RDD） 使用已经存在的迭代器或者集合通过调用spark驱动程序提供的parallelize函数来创建并行集合 - 并行集合被创建用来在分布式集群上并行计算的。 2.例子 data = [1, 2, 3, 4, 5] distData = sc.parallelize(data) 一旦创建RDD，RDD，就可以在集群上并行的去被操作。我...
Spark基础之：常用算子逐一详解
weixin_43542605的博客
01-09 4524
Spark常用算子逐一详解 一、什么是Spark rdd算子 二、算子的分类 三、常用的Transformation算子及使用方法 四、常用的Action算子及使用方法 五、关于rdd算子的常见问题汇总
Spark大数据技术（Scala）小白教程（一)——大数据技术概述以及环境配置_spark scala教程
2401_84182936的博客
05-03 583
Apache Spark 是一个基于内存计算的大数据处理框架，提供了高性能和灵活性，支持多种数据处理模式。Spark 提供了丰富的 API，包括 Spark Core、Spark SQL、Spark Streaming、MLlib（机器学习库）和 GraphX（图计算库），使得用户可以方便地进行数据处理、数据分析和机器学习等任务。
Spark的算子的分类
King_S_H的博客
06-11 5296
从大方向来说，Spark 算子大致可以分为以下两类: 1）Transformation 变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。　　　Transformation 操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。 2）Action 行动算子：这类算子会触发 SparkContext 提交 Job 作业。　　 Action 算子会触发 Spark 提交作业（Job），并将数据
spark的算子
diskindom的博客
11-23 971
Spark中的单Value算子是指对一个RDD中的每个元素进行操作，并返回一个新的RDD。这些单Value算子能够对RDD中的每个元素进行处理，并返回一个新的RDD，可以用于各种数据转换、过滤、去重等操作。
Jupyter notebook运行Spark+Scala教程
08-19
标题中提到的是使用 Jupyter Notebook 运行 Spark+Scala 教程，这意味着我们将使用 Jupyter Notebook 作为开发环境，来编写和运行 Spark+Scala 代码。 描述：主要介绍了 Jupyter Notebook 运行 Spark+Scala 教程，...
scala+spark
06-26
"快学Scala 中文版带目录"这本书可能是针对初学者的Scala教程，涵盖了Scala的基础语法、面向对象和函数式编程概念，以及如何使用Scala与其他Java库集成。目录可能包括变量和类型、控制流、类和对象、模式匹配、高阶...
Linux中Scala和Spark安装
最新发布
05-31
Linux中Scala和Spark安装，0基础看了都能会
本地使用scala操作spark示例.doc
03-06
本地使用scala操作spark示例
【Spark】Spark的常用算子
weixin_46429290的博客
03-07 2519
使用给定的函数对 RDD 的元素进行聚合，seqOp 计算在分区中初始值到中间结果的聚合计算，而 combOp 在节点上对中间结果进行聚合。: 返回对输入 RDD 和参数 RDD 执行联合操作的结果，生成一个新的 RDD，不去重。: 返回对输入 RDD 和参数 RDD 执行交集操作的结果，生成一个新的 RDD。: 返回对输入 RDD 和参数 RDD 执行差集操作的结果，生成一个新的 RDD。: 返回对输入 RDD 和参数 RDD 执行笛卡尔积的结果，生成一个新的 RDD。
spark 常用算子大全（分类详细，图片解析）
BigData_Hubert的博客
09-25 7051
scala 系列 spark 常用算子大全 scala 常用算子大全scala 系列前言思维导图 前言 上一篇博客已经给大家介绍了 scala OOP， 掌握了OOP 的知识后，就已经算是进入 scala 的门了。scala OOP基础是 spark 和 flink 的基础。 本篇博客将为大家带来 scala 高级扩展的介绍。主要包括模式匹配和正则表达式，此外还有异常处理、注解和高级类型的简单了解。 思维导图 ...
Spark算子分类详解
GSpinach的博客
07-12 537
@Date : 2019-07-12 @Author : Spinach | GHB @Link : http://blog.csdn.net/bocai8058 [TOC] 0 算子常见分类 从大方向来说，Spark算子大致可以分为以下两类: Transformation变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。 Transformation 操...
Spark常见算子总结
u010920561的博客
10-10 553
官方文档上列举共有32种常见算子，包括Transformation的20种操作和Action的12种操作。 内容自己用心整理，看我的就够了 Transformation： 1.map map的输入变换函数应用于RDD中所有元素，而mapPartitions应用于所有分区。区别于mapPartitions主要在于调用粒度不同。如parallelize（1 to 10， 3），map函数执行10次，而...
spark常见算子总结
03-14 149
RDD编程API: 1,RDD中的所有转换(Transformation)都是延迟加载的，也就是说，它们并不会直接计算结果,只是记住这些应用到基础数据集（例如一个文件）上的转换动作。只有当发生一个要求返回结果给Driver的动作时，这些转换才会真正运行spark 常见算子总结(其一) package day02 import org.apache.spark.{SparkC...
spark算子_Spark算子总结
weixin_39623713的博客
11-21 215
一、RDD介绍1、什么是RDDRDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据抽象。代码中是一个抽象类，它代表一个不可变、可分区、里面的元素可并行计算的集合。2、RDD特性RDD：是不存数据的，partition也是不存数据的（是一系列处理逻辑）RDD五大特性：a、RDD是由一系列partition组成 b、算子（函数作用到par...
Spark行动算子(Action)--reduce算子
寒暄的博客
08-03 2686
语法 val newRdd = oldRdd. reduce(func) 源码 def reduce(f : scala.Function2[T, T, T]) : T = { /* compiled code */ } 作用 通过func函数聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据。 例子 package com.day1 import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf, SparkContext}
横扫Spark之 - 9个常见的行动算子
阿年的博客
02-09 987
Spark中常见的9个行动算子以及使用示例
Scala Spark 绑定：线性代数子程序手册
"Scala Spark Bindings 是一份关于在Scala中使用Spark进行线性代数运算的文档，提供了清晰的英文版。文档主要关注如何利用Scala和Spark的绑定接口进行大数据处理，并强调了在编程环境中结合高效计算、大规模处理和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值