spark笔记3

RDD缓存

package cn.tedu.cache

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.storage.StorageLevel

object Driver {
def main(args: Array[String]): Unit = {
val conf=new SparkConf().setMaster(“local”).setAppName(“cache”)
val sc=new SparkContext(conf)
//–指定检查点目录路径
//–可以是本地路径或HDFS
sc.setCheckpointDir(“c://data/check”)

val data=sc.textFile("c://data/topk.txt", 2)
//--习惯上，将数据源RDD做缓存，避免数据恢复到源头去磁盘读取。
//--RDD的缓存指的是:显式的将RDD数据持久化到内存或磁盘上,不会被GC所回收掉
data.cache()

val r1=data.flatMap{_.split(" ")}
val r2=r1.map{(_,1)}
//--persist()的缓存级别同cache(),都是默认的memory_only
//--此外，也可以用persist()指定其他级别
//--根据经验，一般会将整个计算链处于中间位置的RDD缓存
//--如果一个计算链很长，比如30个，可以比如每个10个缓存一下
r2.persist(StorageLevel.MEMORY_AND_DISK)
//--将r2做检查点存储
r2.checkpoint()
val r3=r2.reduceByKey{_+_}
r3.foreach{println} 
//--当整个Job执行完之后，一定要记得清除RDD的缓存
data.unpersist()
r3.unpersist()

}
}

倒排索引创建

数据 一个目录下有三个文件 文件里面的内容有相识的部分，求相识的部分都在哪些文件里出现过
package cn.tedu.inverted
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
object Driver {
def main(args: Array[String]): Unit = {
val conf=new SparkConf().setMaster(“local”).setAppName(“inverted”)
val sc=new SparkContext(conf)
//–将指定目录下所有文件数据读取到一个RDD中
//–RDD[(filePath,fileText)]
//–课后作业:完成倒排索引表
//–(scala,doc3) (hadoop,doc1,doc2)
//–提示:文档名从filePath获取
//–单词从fileText中获取，先按\r\n 把每行数据切出来，在按空格将每行数据的单词切分
val data=sc.wholeTextFiles(“c://data/inverted/*”)
//–RDD[(filePath,fileText)]->RDD[(fileName,fileText)]
val r1=data.map{case(filePath,fileText)=>
val fileName=filePath.split("/").last.dropRight(4)
(fileName,fileText)
}
//–RDD[(fileName,fileText)]->RDD[(word,fileName)]
val r2=r1.flatMap{case(fileName,fileText)=>
fileText.split("\r\n").flatMap{ line => line.split(" “) }
.map {word =>(word,fileName) }
}
val r3=r2.groupByKey.map { case(word,buffer) =>
(word,buffer.toList.distinct.mkString(”,")) }
r3.foreach{println}
}
}

排序

源数据
aa 12
bb 32
aa 3
cc 43
dd 23
cc 5
cc 8
bb 33
bb 12
按照第一列做升序，按照第二列做降序

创建对象
package cn.tedu.ssort
/**

• 用于封装文件中两列数据，并实现二次排序的比较规则
  /
  class Ssort(val col1:String, val col2:Int) extends Ordered[Ssort] with Serializable{
  /

  • compare用于定义排序比较规则
    */
    def compare(that: Ssort): Int = {
    //–先按第一列做升序排序
    val result=this.col1.compareTo(that.col1)
    if(result==0){
    //–再按第二列做降序排序
    that.col2.compareTo(this.col2)

  }else{
  result
  }
  }
  }

入口代码
package cn.tedu.ssort
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
object Driver {
def main(args: Array[String]): Unit = {
val conf=new SparkConf().setMaster(“local”).setAppName(“ssort”)

val sc=new SparkContext(conf)

val data=sc.textFile("c://data/ssort.txt")

//--RDD[String:line]->RDD[(Ssort(col1,col2),line)]->sortByKey,
//--会按Ssort对象中的compare排序
val r1=data.map { line =>
  val info=line.split(" ") 
  val col1=info(0)
  val col2=info(1).toInt
  (new Ssort(col1,col2),line)
}
//--true表示按Ssort对象中Compare的规则排序
//--false表示按Compare中的规则反排序
val r2=r1.sortByKey(true).map{x=>x._2}
r2.foreach{println}

}
}