spark 基本操作整理

关于spark 的详细操作请参照spark官网

scala 版本：2.11.8

1.添加spark maven依赖，如需访问hdfs，则添加hdfs依赖

groupId = org.apache.spark
artifactId = spark-core_2.
version = 2.3.

groupId = org.apache.hadoop
artifactId = hadoop-client
version = <your-hdfs-version>

2.sparkcontext 的创建

    val conf = new SparkConf().setAppName("example").setMaster("local[*]")
    val sc = new SparkContext(conf)

    sc.stop()

sc 使用结束，记得关闭

3.创建rdd

1）parallelized 方法

val words = sc.parallelize(Array("dong","jason","puma","large"),2)

2）读取外部数据

val rdd = sc.textFile("path_to_file(local or hdfs)")

一个放重要的概念，partitions，spark在逻辑上回对数据进行分区，每个分区会安排一个task来处理，textfile 如果读取的时hdfs，则默认partitions 是 文件的block数，

一般情况下为资源中每个cpu分配 2-4 个task为宜

4. SparkContext.wholeTextFiles

    val rdd = sc.wholeTextFiles("./")
    rdd.take().foreach(println)

-----------------------------------
(file:/C:/notos/code/sailertest/aa.csv,name,age
jason,
dong,)

其输出结果时一个元组，(filepath,filecontent)

5.读取 hadoop sequencefFile

val seqRdd = sc.sequenceFile[String,Int]("seq")
seqRdd.take().foreach(println)

(jason,)
(dong,)

sequenceFile[K,V]中的K，V 必须指定，且2要与sequencefile的类型匹配

6.向方法传递函数

object Func{
  def concat(tp:(String,Int)):String={
    tp._1 + " " + tp._2
  }
}

val seqRdd = sc.sequenceFile[String,Int]("seq").map(Func.concat)

上述例子是把方法定义在单利对象中，与之相对，也可以把方法定义在类中，请看下面的例子

class MyClass{
  val field = " "
  def concat(rdd:RDD[(String,Int)]) :RDD[String] ={
    val field_  = field
    rdd.map(tp=> tp._1 + field_ + tp._2)
  }
}

这里在concat方法中我没没有直接 使用 Myclass 的 成员 field ，因为直接使用field （(tp=> tp._1 + field + tp._2) 相当于是 (tp=> tp._1 + this.field + tp._2)）

这样会把整个类再引用一遍

7. rdd key-value 操作

    val wordcount = sc.textFile("aa.txt")
      .flatMap(_.split("\\s+",-))
      .map(word=>(word,))
      .reduceByKey((x,y)=> x+y)
    wordcount.collect()
      .foreach(println)

(Liu,)
(worth,)
(,)
(after,)
(profit,)

8.计算平均数

    val list = List(, , , , )
    val rdd = sc.parallelize(list)
    val sum = rdd.reduce(_ + _)
    val num = rdd.map(x => ).reduce(_ + _)
    val sn = rdd.aggregate((, ))((u, v) => (u._1 + v, u._2 + ),
      (u1, u2) => (u1._1 + u2._1, u1._2 + u2._2)
    )
    val res = sn._1.toDouble/sn._2
    println(sum.toDouble/num)
    println(res)

9.计算每个年级的平均成绩

    val list = List(
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", ),
      ("", )
    )
    val avgScores = sc.parallelize(list)
      .combineByKey(
        (score: Int) => (score, ),
        (u: (Int, Int), v: Int) => (u._1 + v, u._2 + ),
        (u: (Int, Int), u2: (Int, Int)) => (u._1 + u2._1, u._2 + u2._2)
      ).mapValues(x => x._1.toDouble / x._2)
    avgScores.collect().foreach(println)

(,94.0)
(,94.0)

10. 广播变量

    val broadcastVar = sc.broadcast(Array(,,))
    broadcastVar.value.foreach(println)

广播变量会被发送到每台机器，而不是每个task

11.累加器

val rdd = sc.parallelize(List(,,,))
    val acc = sc.longAccumulator("myacc")
    rdd.map(x=>acc.add(x)).collect()
    println()
    println(acc.value)