RDD是什么

基本操作

• wordcount.txt文件

hadoop lizemin
lizemin hadoop
lzm hadoop

• bin/spark-shell 操作命令

val rdd1 = sc.textFile("file:///export/data/wordcount.txt")

val rdd2 = rdd1.flatMap(item=> item.split(" "))

val rdd3 = rdd2.map(item => (item,1))

val rdd4 = rdd3.reduceByKey((curr,agg) => curr + agg)

rdd4.collect()

res0: Array[(String, Int)] = Array((lizemin,2), (hadoop,3), (lzm,1))

• bin\spark-submit 操作命令

/**
   * 提交运行
   * bin/spark-submit --class net.jd.spark.rdd.WordCount2 --master spark://node01:7077 spark-0.0.1.jar
   * @param args
   */
  def main(args: Array[String]): Unit = {
    //    创建SparkContext
    val conf = new SparkConf().setAppName("word_count")
    val sc = new SparkContext(conf)
    //    加载文件
    val rdd1: RDD[String] = sc.textFile("/export/data/wordcount.txt")
    //    处理
    val rdd2: RDD[String] = rdd1.flatMap(item => item.split(" "))
    val rdd3: RDD[(String, Int)] = rdd2.map(item => (item, 1))
    val rdd4: RDD[(String, Int)] = rdd3.reduceByKey((curr, agg) => curr + agg)
    //    得到结果
    val result: Array[(String, Int)] = rdd4.collect()
    result.foreach(item => println(item))

  }

RDD特点

1. RDD是数据集
2. RDD是编程模型
3. RDD相互之间有依赖关系
4. RDD是可以分区的

核心对象，sparkContext

  @Test
  def sparkContext(): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[6]").setAppName("spark_context")
    val sc = new SparkContext(conf)
  }

从本地集合创建

  @Test
  def rddCreationLocal(): Unit = {
    val seq = Seq("test1", "test2", "test3")

    val rdd1: RDD[String] = sc.parallelize(seq, 2)
    val rdd3: RDD[String] = sc.parallelize(seq)

    val rdd2: RDD[String] = sc.makeRDD(seq, 2)
    val rdd4: RDD[String] = sc.makeRDD(seq)

  }

从文件创建

  @Test
  def rddCreationFiles(): Unit = {
    sc.textFile("////")

    /**
     *
     * 1. 传入一个 文件路径
     * hdfs://
     * file://
     * /../   如果在本地 读取的是本地文件  如果集群 读取的是 hdfs
     *
     * 2. 是否支持分区，
     * 支持，
     * 如果本地 取得是本地 cpu盒数 和 2 比较取小
     * 如果集群 由HDFS的block决定
     *
     * 3. 支持什么平台
     * AWS
     * 阿里云
     *
     */

  }

从RDD衍生

  @Test
  def rddCreateFromRDD(): Unit = {
    val rdd1: RDD[Int] = sc.parallelize(Seq(1, 2, 3))
    // 通过算子操作 ， 生成新的rdd
    // 原地计算
    val rdd2: RDD[Int] = rdd1.map(item => item)

  }