spark-RDD

最新推荐文章于 2024-06-04 15:24:20 发布
最新推荐文章于 2024-06-04 15:24:20 发布
阅读量375 收藏
点赞数
分类专栏： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovezhaohaimig/article/details/85912468
版权

RDD 是什么？

RDD，全称为 Resilient Distributed Datasets，是一个容错的、并行的数据结构，可以让用户显式地将数据存储到磁盘和内存中，并能控制数据的分区。同时，RDD 还提供了一组丰富的操作来操作这些数据。在这些操作中，诸如 map、flatMap、filter 等转换操作实现了 monad 模式，很好地契合了 Scala 的集合操作。除此之外，RDD 还提供了诸如 join、groupBy、reduceByKey 等更为方便的操作（注意，reduceByKey 是 action，而非 transformation），以支持常见的数据运算

RDD 支持两种操作：转化操作和行动操作。RDD 的转化操作是返回一
个新的 RDD 的操作，比如 map() 和 filter()，而行动操作则是向驱动器程序返回结果或
把结果写入外部系统的操作，会触发实际的计算，比如 count() 和 first()。Spark 对待
转化操作和行动操作的方式很不一样，因此理解你正在进行的操作的类型是很重要的。如
果对于一个特定的函数是属于转化操作还是行动操作感到困惑，你可以看看它的返回值类
型：转化操作返回的是 RDD，而行动操作返回的是其他的数据类型

。

通常来讲，针对数据处理有几种常见模型，包括：Iterative Algorithms，Relational Queries，MapReduce，Stream Processing。例如 Hadoop MapReduce 采用了 MapReduces 模型，Storm 则采用了 Stream Processing 模型。RDD 混合了这四种模型，使得 Spark 可以应用于各种大数据处理场景。

RDD 作为数据结构，本质上是一个只读的分区记录集合。一个 RDD 可以包含多个分区，每个分区就是一个 dataset 片段。RDD 可以相互依赖。如果 RDD 的每个分区最多只能被一个 Child RDD 的一个分区使用，则称之为 narrow dependency；若多个 Child RDD 分区都可以依赖，则称之为 wide dependency。不同的操作依据其特性，可能会产生不同的依赖。例如 map 操作会产生 narrow dependency，而 join 操作则产生 wide dependency。

创建RDD

1.使用程序中的集合创建RDD

2.使用本地文件系统创建RDD

3.使用HDS创建RDD

4.基于DB创建RDD

5.基于NoSQL,例如HBase

6.基于s3创建RDD

7.基于数据流创建RDD

1.使用程序中的集合创建RDD

调用SparkContext 的 parallelize()，将一个存在的集合，变成一个RDD

package com.rdd.spark

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

/**
 * 通过集合获取rdd
 * */
object RDDBaseCollections {
  def main(args: Array[String] ){
     /**  
      * 第1步，创建Spark的配置对象SparkConf ,设置Spark程序的运行时的配置信息。
      * */
     val conf = new SparkConf() ;//创建SparkConf 对象
     conf.setAppName("Wow,my  first spark app"); // 设置应用程序的名称，在程序运行的监控面可以看到名称
     conf.setMaster("local");//此时,程序在本地运行，不需要安装Spark集群
     /**
      * 第2步:创建SparkContext 对象
      * Sparkcontext 是spark 程序所有功能的唯一入口，无论是采用Scala ,Java 、Python, R等都必须有一个Spark
      * Sparkcontext 核心作用：初始spark 应用程序 运行所有需要的核心组件，DAGScheduker,TaskScheduker
      * 同时还会负责Spark程序Master注册程序
      * Sparkcontext 是整个 应用中最为至关重要的一个对象
      * 
      * */
     val sc = new SparkContext(conf);//创建sparkContext对象，通过sparkConf实例来定制spark运行
     
     var numbers = 1 to 100 //创建一个scala的集合
     var rdd = sc.parallelize( numbers)
     var sum = rdd.reduce(_+_)//1+2 =3 3+3=6 6+4=10 ....
     println("sum="+sum)
     }
}

2.使用本地文件系统创建RDD

package com.rdd.spark

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

/**
 * 通过文件获取rdd
 * */
object RDDBaseLocalFile {
  def main(args: Array[String] ){
     /**  
      * 第1步，创建Spark的配置对象SparkConf ,设置Spark程序的运行时的配置信息。
      * */
     val conf = new SparkConf() ;//创建SparkConf 对象
     conf.setAppName("RDDBaseLocalFile"); // 设置应用程序的名称，在程序运行的监控面可以看到名称
     conf.setMaster("local");//此时,程序在本地运行，不需要安装Spark集群
     /**
      * 第2步:创建SparkContext 对象
      * Sparkcontext 是spark 程序所有功能的唯一入口，无论是采用Scala ,Java 、Python, R等都必须有一个Spark
      * Sparkcontext 核心作用：初始spark 应用程序 运行所有需要的核心组件，DAGScheduker,TaskScheduker
      * 同时还会负责Spark程序Master注册程序
      * Sparkcontext 是整个 应用中最为至关重要的一个对象
      * 
      * */
     val sc = new SparkContext(conf);//创建sparkContext对象，通过sparkConf实例来定制spark运行
     val rdd = sc.textFile("G://work//64bit//scala//spark-1.6.0-bin-hadoop2.6//README.md")
     var linesLength = rdd.map(line => line.length())//map(func)：数据集中的每个元素经过用户自定义的函数转换形成一个新的RDD，新的RDD叫MappedRDD
     var sum = linesLength.reduce(_+_)
     println("文件总的长度："+sum)
    
     }
}

行动操作

是真正触发计算的地方。Spark程序执行到行动操作时，才会执行真正的计算，从文件中加载数据，完成一次又一次转换操作，最终，完成行动操作得到结果。
下面列出一些常见的行动操作（Action API）：
* count() 返回数据集中的元素个数
* collect() 以数组的形式返回数据集中的所有元素
* first() 返回数据集中的第一个元素
* take(n) 以数组的形式返回数据集中的前n个元素
* reduce(func) 通过函数func（输入两个参数并返回一个值）聚合数据集中的元素
* foreach(func) 将数据集中的每个元素传递到函数func中运行*

scala> val list = List("Hadoop","Spark","Hive","Spark")
list: List[String] = List(Hadoop, Spark, Hive, Spark)
 
scala> val rdd = sc.parallelize(list)
rdd: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[11] at parallelize at <console>:29
 
scala> val pairRDD = rdd.map(word => (word,1))
pairRDD: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[12] at map at <console>:31
 
scala> pairRDD.foreach(println)
(Hadoop,1)
(Spark,1)
(Hive,1)
(Spark,1)

常用的键值对转换操作包括reduceByKey()、groupByKey()、sortByKey()、join()、cogroup()等，下面我们通过实例来介绍。

reduceByKey(func)

reduceByKey(func)的功能是，使用func函数合并具有相同键的值。比如，reduceByKey((a,b) => a+b)，有四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)，对具有相同key的键值对进行合并后的结果就是：(“spark”,3)、(“hadoop”,8)。可以看出，(a,b) => a+b这个Lamda表达式中，a和b都是指value，比如，对于两个具有相同key的键值对(“spark”,1)、(“spark”,2)，a就是1，b就是2。
我们对上面第二种方式创建得到的pairRDD进行reduceByKey()操作，代码如下：

  1. scala> pairRDD.reduceByKey((a,b)=>a+b).foreach(println)
  2. (Spark,2)
  3. (Hive,1)
  4. (Hadoop,1)
 def reduceByKeyTranformation(sc: SparkContext){
    val lines = sc.textFile("G://work//64bit//scala//spark-1.6.0-bin-hadoop2.6//README.md", 1);//读取本地文件，并设置一个Partition
     
     /**
      * 第4步:对初始的RDD进行Transformation级别的处理，例如 map  filter 等高阶函数等的编程，来进行具体的数据计算
      * 4.1步 :将每一行的字符串拆分分成单个的单词 
      * */
     val words = lines.flatMap{line => line.split(" ")}; //对每一行的字符串进行拆分 并把所有的拆分结果通过flat 合并成一个
     
     
         /**
      * 第4步:对初始的RDD进行Transformation级别的处理，例如 map  filter 等高阶函数等的编程，来进行具体的数据计算
      * 4.2步 : 在单词拆分的基础上对每个单词实例计数为1，也是word=>(word,1)
      * */
     
     val pairs = words.map{word => (word,1)};
     
         /**
      * 第4步:对初始的RDD进行Transformation级别的处理，例如 map  filter 等高阶函数等的编程，来进行具体的数据计算
      * 4.3步 : 在每个单词实例计数为1基础之上统计每个单词在文件中出现的总次数
      * */
     
     val wordCounts = pairs.reduceByKey(_+_);//对相同的key,进行value的累计(包括Local和Reducer级别同时Reduce)
      wordCounts.foreach(wordNumberPair => println(wordNumberPair._1+":"+wordNumberPair._2));
     
  }

reduceByKey( ）是对相同的key进行操作

groupByKey()

groupByKey()的功能是，对具有相同键的值进行分组。比如，对四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)，采用groupByKey()后得到的结果是：(“spark”,(1,2))和(“hadoop”,(3,5))。
我们对上面第二种方式创建得到的pairRDD进行groupByKey()操作，代码如下：

  1. scala> pairRDD.groupByKey()
  2. res15: org.apache.spark.rdd.RDD[(String, Iterable[Int])] = ShuffledRDD[15] at groupByKey at <console>:34
  3. //从上面执行结果信息中可以看出，分组后，value被保存到Iterable[Int]中
  4. scala> pairRDD.groupByKey().foreach(println)
  5. (Spark,CompactBuffer(1, 1))
  6. (Hive,CompactBuffer(1))
  7. (Hadoop,CompactBuffer(1))
def groupByKeyTranformation(sc: SparkContext){
    var data =Array(Tuple2(100,"Spark"),Tuple2(100,"scala"),Tuple2(90,"hadoop"),Tuple2(90,"kafka"),Tuple2(80,"java"),Tuple2(80,"Habase"))
    var rddData = sc.parallelize(data)
    var mapkey = rddData.groupByKey()
    mapkey.collect().foreach(print)
  }

(Spark, scala))

(80,CompactBuffer(java, Habase))

(90,CompactBuffer(hadoop, kafka))

scala

keys

keys只会把键值对RDD中的key返回形成一个新的RDD。比如，对四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)构成的RDD，采用keys后得到的结果是一个RDD[Int]，内容是{“spark”,”spark”,”hadoop”,”hadoop”}。
我们对上面第二种方式创建得到的pairRDD进行keys操作，代码如下：

 
  1. scala> pairRDD.keys
  2. res17: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[17] at keys at <console>:34
  3. scala> pairRDD.keys.foreach(println)
  4. Hadoop
  5. Spark
  6. Hive
  7. Spark

scala

values

values只会把键值对RDD中的value返回形成一个新的RDD。比如，对四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)构成的RDD，采用keys后得到的结果是一个RDD[Int]，内容是{1,2,3,5}。
我们对上面第二种方式创建得到的pairRDD进行values操作，代码如下：

 
  1. scala> pairRDD.values
  2. res0: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[2] at values at <console>:34
  3.  
  4. scala> pairRDD.values.foreach(println)
  5. 1
  6. 1
  7. 1
  8. 1

scala

sortByKey()

sortByKey()的功能是返回一个根据键排序的RDD。
我们对上面第二种方式创建得到的pairRDD进行keys操作，代码如下：

 
  1. scala> pairRDD.sortByKey()
  2. res0: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[2] at sortByKey at <console>:34
  3. scala> pairRDD.sortByKey().foreach(println)
  4. (Hadoop,1)
  5. (Hive,1)
  6. (Spark,1)
  7. (Spark,1)

scala

mapValues(func)

我们经常会遇到一种情形，我们只想对键值对RDD的value部分进行处理，而不是同时对key和value进行处理。对于这种情形，Spark提供了mapValues(func)，它的功能是，对键值对RDD中的每个value都应用一个函数，但是，key不会发生变化。比如，对四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)构成的pairRDD，如果执行pairRDD.mapValues(x => x+1)，就会得到一个新的键值对RDD，它包含下面四个键值对(“spark”,2)、(“spark”,3)、(“hadoop”,4)和(“hadoop”,6)。
我们对上面第二种方式创建得到的pairRDD进行keys操作，代码如下：

 
  1. scala> pairRDD.mapValues(x => x+1)
  2. res2: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[4] at mapValues at <console>:34
  3. scala> pairRDD.mapValues(x => x+1).foreach(println)
  4. (Hadoop,2)
  5. (Spark,2)
  6. (Hive,2)
  7. (Spark,2)

scala

join

join(连接)操作是键值对常用的操作。“连接”(join)这个概念来自于关系数据库领域，因此，join的类型也和关系数据库中的join一样，包括内连接(join)、左外连接(leftOuterJoin)、右外连接(rightOuterJoin)等。最常用的情形是内连接，所以，join就表示内连接。
对于内连接，对于给定的两个输入数据集(K,V1)和(K,V2)，只有在两个数据集中都存在的key才会被输出，最终得到一个(K,(V1,V2))类型的数据集。

比如，pairRDD1是一个键值对集合{(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)}，pairRDD2是一个键值对集合{(“spark”,”fast”)}，那么，pairRDD1.join(pairRDD2)的结果就是一个新的RDD，这个新的RDD是键值对集合{(“spark”,1,”fast”),(“spark”,2,”fast”)}。对于这个实例，我们下面在spark-shell中运行一下：

  1. scala> val pairRDD1 = sc.parallelize(Array(("spark",1),("spark",2),("hadoop",3),("hadoop",5)))
  2. pairRDD1: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[24] at parallelize at <console>:27
  3.  
  4. scala> val pairRDD2 = sc.parallelize(Array(("spark","fast")))
  5. pairRDD2: org.apache.spark.rdd.RDD[(String, String)] = ParallelCollectionRDD[25] at parallelize at <console>:27
  6.  
  7. scala> pairRDD1.join(pairRDD2)
  8. res9: org.apache.spark.rdd.RDD[(String, (Int, String))] = MapPartitionsRDD[28] at join at <console>:32
  9.  
  10. scala> pairRDD1.join(pairRDD2).foreach(println)
  11. (spark,(1,fast))
  12. (spark,(2,fast))

进行job操作

 def jobTranformation(sc: SparkContext){//进行job转换操作
      val studentNames = Array(
        Tuple2(1,"Spark"),
        Tuple2(2,"Techyon"),    
        Tuple2(3,"Hadoop"),    
        Tuple2(4,"Java")    
      )
      val studentScores = Array(
        Tuple2(1,100),
        Tuple2(2,90),    
        Tuple2(3,65),    
        Tuple2(4,80)    
      )
      val names = sc.parallelize(studentNames)
       val scores = sc.parallelize(studentScores)
      val studentInfo =  names.join(scores)
      studentInfo.collect().foreach(println)
      
    }

运行结果：

(4,(Java,80))
(1,(Spark,100))
(3,(Hadoop,65))
(2,(Techyon,90))

cogroup

 

一个综合实例

题目：给定一组键值对(“spark”,2),(“hadoop”,6),(“hadoop”,4),(“spark”,6)，键值对的key表示图书名称，value表示某天图书销量，请计算每个键对应的平均值，也就是计算每种图书的每天平均销量。
很显然，对于上面的题目，结果是很显然的，(“spark”,4),(“hadoop”,5)。
下面，我们在spark-shell中演示代码执行过程：

 
  1. scala> val rdd = sc.parallelize(Array(("spark",2),("hadoop",6),("hadoop",4),("spark",6)))
  2. rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[38] at parallelize at <console>:27
  3.  
  4. scala> rdd.mapValues(x => (x,1)).reduceByKey((x,y) => (x._1+y._1,x._2 + y._2)).mapValues(x => (x._1 / x._2)).collect()
  5. res22: Array[(String, Int)] = Array((spark,4), (hadoop,5))

scala

要注意，上面语句中，mapValues(x => (x,1))中出现了变量x，reduceByKey((x,y) => (x._1+y._1,x._2 + y._2))中也出现了变量x，mapValues(x => (x._1 / x._2))也出现了变量x。但是，必须要清楚，这三个地方出现的x，虽然都具有相同的变量名称x，但是，彼此之间没有任何关系，它们都处在不同的变量作用域内。如果你觉得这样会误导自己，造成理解上的掌握，实际上，你可以把三个出现x的地方分别替换成x1、x2、x3也是可以的，但是，很显然没有必要这么做。
上面是完整的语句和执行过程，可能不太好理解，下面我们进行逐条语句分解给大家介绍。每条语句执行后返回的屏幕信息，可以帮助大家更好理解语句的执行效果，比如生成了什么类型的RDD。

（1）首先构建一个数组，数组里面包含了四个键值对，然后，调用parallelize()方法生成RDD，从执行结果反馈信息，可以看出，rdd类型是RDD[(String, Int)]。

 
  1. scala> val rdd = sc.parallelize(Array(("spark",2),("hadoop",6),("hadoop",4),("spark",6)))
  2. rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[38] at parallelize at <console>:27

scala

（2）针对构建得到的rdd，我们调用mapValues()函数，把rdd中的每个每个键值对(key,value)的value部分进行修改，把value转换成键值对(value,1)，其中，数值1表示这个key在rdd中出现了1次，为什么要记录出现次数呢？因为，我们最终要计算每个key对应的平均值，所以，必须记住这个key出现了几次，最后用value的总和除以key的出现次数，就是这个key对应的平均值。比如，键值对(“spark”,2)经过mapValues()函数处理后，就变成了(“spark”,(2,1))，其中，数值1表示“spark”这个键的1次出现。下面就是rdd.mapValues()操作在spark-shell中的执行演示：
scala> rdd.mapValues(x => (x,1)).collect()
res23: Array[(String, (Int, Int))] = Array((spark,(2,1)), (hadoop,(6,1)), (hadoop,(4,1)), (spark,(6,1)))
上面语句中，collect()是一个行动操作，功能是以数组的形式返回数据集中的所有元素，当我们要实时查看一个RDD中的元素内容时，就可以调用collect()函数。

（3）然后，再对上一步得到的RDD调用reduceByKey()函数，在spark-shell中演示如下：

 
  1. scala> rdd.mapValues(x => (x,1)).reduceByKey((x,y) => (x._1+y._1,x._2 + y._2)).collect()
  2. res24: Array[(String, (Int, Int))] = Array((spark,(8,2)), (hadoop,(10,2)))

scala

这里，必须要十分准确地理解reduceByKey()函数的功能。可以参考上面我们对该函数的介绍，reduceByKey(func)的功能是使用func函数合并具有相同键的值。这里的func函数就是Lamda表达式(x,y) => (x._1+y._1,x._2 + y._2)，这个表达式中，x和y都是value，而且是具有相同key的两个键值对所对应的value，比如，在这个例子中， (“hadoop”,(6,1))和(“hadoop”,(4,1))这两个键值对具有相同的key，所以，对于函数中的输入参数(x,y)而言，x就是(6,1)，x._1表示这个键值对中的第1个元素6，x._2表示这个键值对中的第二个元素1，y就是(4,1)，y._1表示这个键值对中的第1个元素4，y._2表示这个键值对中的第二个元素1，所以，函数体(x._1+y._1,x._2 + y._2)，相当于生成一个新的键值对(key,value)，其中，key是x._1+y._1，也就是6+4=10，value是x._2 + y._2，也就是1+1=2，因此，函数体(x._1+y._1,x._2 + y._2)执行后得到的value是(10,2)，但是，要注意，这个(10,2)是reduceByKey()函数执行后，”hadoop”这个key对应的value，也就是，实际上reduceByKey()函数执行后，会生成一个键值对(“hadoop”,(10,2))，其中，10表示hadoop书籍的总销量，2表示两天。同理，reduceByKey()函数执行后会生成另外一个键值对(“spark”,(8,2))。

(4)最后，就可以求出最终结果。我们可以对上面得到的两个键值对(“hadoop”,(10,2))和(“spark”,(8,2))所构成的RDD执行mapValues()操作，得到每种书的每天平均销量。当第一个键值对(“hadoop”,(10,2))输入给mapValues(x => (x._1 / x._2))操作时，key是”hadoop”，保持不变，value是(10,2)，会被赋值给Lamda表达式x => (x._1 / x._2中的x，因此，x的值就是(10,2)，x._1就是10，表示hadoop书总销量是10，x._2就是2，表示2天，因此，hadoop书籍的每天平均销量就是x._1 / x._2，也就是5。mapValues()输出的一个键值对就是(“hadoop”,5)。同理，当把(“spark”,(8,2))输入给mapValues()时，会计算得到另外一个键值对(“spark”,4)。在spark-shell中演示如下：

 
  1. scala> rdd.mapValues(x => (x,1)).reduceByKey((x,y) => (x._1+y._1,x._2 + y._2)).mapValues(x => (x._1 / x._2)).collect()
  2. res25: Array[(String, Int)] = Array((spark,4), (hadoop,5))

 

 

 

 

第一次接触王老师的大数据课程是在2014年底，当时在51CTO上有了spark六阶段，当时真的太吸引我了，但是由于是学生，所以没那么多钱去买教程，真的太后悔了，但是呢！后来看到了《大数据不眠夜：Spark内核天机解密（共100讲）》：http://pan.baidu.com/s/1eQsHZAq和《Scala深入浅出实战经典》http://pan.baidu.com/s/1sjDWG25   ，觉得希望来了，于是自己开始了spark的学习，从scala的一窍不通，到现在可以写一些scala的函数，实现一些业务逻辑，真的太感谢王老师了！也从spark的一窍不通，到现在虽然不算高手吧，但还是算得上半个高手的，真的发现spark太强大了，完全超乎自己的想像！王老师，我一定一定会好好跟着您的脚步，把spark学到手，然后分享给身边的朋友！

 

现在给大家分享王老师的一些免费视频，希望的大家能好好学一下，中国的下一代人才就从王老师这里开始了！

 

王家林的第一个中国梦：免费为全社会培养100万名优秀的大数据从业人员！

您可以通过王家林老师的微信号18610086859发红包捐助大数据、互联网+、O2O、工业4.0、微营销、移动互联网等系列免费实战课程， 目前已经发布的王家林免费视频全集如下：

1，《大数据不眠夜：Spark内核天机解密（共100讲）》：http://pan.baidu.com/s/1eQsHZAq  

2，《Hadoop深入浅出实战经典》http://pan.baidu.com/s/1mgpfRPu 

3，《Spark纯实战公益大讲坛》http://pan.baidu.com/s/1jGpNGwu 

4，《Scala深入浅出实战经典》http://pan.baidu.com/s/1sjDWG25 

5，《Docker公益大讲坛》http://pan.baidu.com/s/1kTpL8UF 

6，《Spark亚太研究院Spark公益大讲堂》http://pan.baidu.com/s/1i30Ewsd 

7，DT大数据梦工厂Spark、Scala、Hadoop的所有视频、PPT和代码在百度云网盘的链接：

http://pan.baidu.com/share/home?uk=4013289088#category/type=0&qq-pf-to=pcqq.group 

王家林免费在51CTO发布的1000集合大数据spark、hadoop、scala、docker视频： 

1，《Scala深入浅出实战初级入门经典视频课程》http://edu.51cto.com/lesson/id-66538.html 

2，《Scala深入浅出实战中级进阶经典视频课程》http://edu.51cto.com/lesson/id-67139.html 

3，《Akka深入浅出实战经典视频课程》http://edu.51cto.com/lesson/id-77672.html 

4，《Spark亚太研究院决胜大数据时代公益大讲堂》http://edu.51cto.com/lesson/id-30815.html 

5，《云计算Docker虚拟化公益大讲坛 》http://edu.51cto.com/lesson/id-61776.html 

6，《Spark 大讲堂（纯实战手动操作）》http://edu.51cto.com/lesson/id-78653.html 

7，《Hadoop深入浅出实战经典视频课程-集群、HDFS、Yarn、MapReduce》http://edu.51cto.com/lesson/id-77141.html 

8，《从技术角度思考Hadoop到底是什么》http://edu.51cto.com/course/course_id-1151.html 

 

“DT大数据梦工厂”团队第一个中国梦：免费为社会培养100万名优秀的大数据从业人员。每天早上4点起持续分享大数据、互联网+、O2O、工业4.0、微营销、移动互联网等领域的

精华内容，帮助您和公司在DT时代打造智慧大脑，将生产力提高百倍以上！

DT大数据梦工厂微信公众号：DT_Spark

lovezhaohaimig
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
RDD常用操作，及结果展示
weixin_46227398的博客
06-17 3555
首先简单介绍一下，HDFS的相关操作： 1、在HDFS上创建文件夹 hdfs dfs -mkdir /path 2、将本地文件拷贝到HDFS上 hdfs dfs -copyFromLocal local_file /dstpath hdfs dfs -put local_file /dstpath 3、将HDFS上的文件拷贝到本地 hdfs dfs -copyToLocal /dstpath local_path hdfs dfs -get /dstpath l
Spark大数据分与实践笔记（第三章 Spark RDD 弹性分布式数据集-02）
Lydia868的专栏
08-19 1035
Spark用Scala语言实现了RDD的API，程序开发者可以通过调用API对RDD进行操作处理。
第二章：《Spark之-----RDD编程》摘要
weixin_45014721的博客
11-16 317
一、普通RDD 一、从文件系统中加载数据创建RDD 1.读取本地文件： scala> val lines = sc.textFile("file:///usr/local/spark/mycode/rdd/word.txt") 2.读取HDFS里面的文件 scala> val lines = sc.textFile("hdfs://localhost:9000/user/hadoop/word.txt") 二、通过并行集合（数组）创建RDD 从数组中创建： scala>val arra
CDR2024最新官方无限试用体验版CorelDRAW安装包下载无需激活码序列号
最新发布
FLflStudio的博客
06-04 345
无论是打开大型文件，还是进行复杂的操作，软件都能保持流畅的运行状态，不会出现卡顿或者崩溃的情况。在设计的世界里，有一款软件以其强大的矢量绘图和版面设计能力，以及丰富的模板和素材资源，赢得了众多设计师的青睐。因此，我希望通过这篇详细的试用体验和专业的评测分析，帮助读者全面了解CorelDRAW2024试用体验版的使用效果、性能特点以及适用场景。同时，我也希望通过这篇评测，引导读者思考如何根据自己的实际需求，选择最适合自己的设计工具，提升自己的设计效率和质量。这种人性化的设计，无疑为使用者提供了极大的便利。
Spark面试题（一）
辛聪明的博客
01-02 6013
目录 一、单项选择题 二、不定项选题   三、填空题 四、判断题 五、简答题 六、编程题 一、单项选择题 1、下面哪个操作是窄依赖？（） join filter group sort RDD之间的血缘关系又称依赖，包括两种，一种是窄依赖，RDDs之间分区是一一对应的，另一种是宽依赖，下游RDD的每个分区与上游RDD(也称之为父RDD)的每个分区都有关，是多对多...
百度云网盘svip超级会员激活码2024
FLflStudio的博客
04-04 4万+
此时，如果您网盘中的文件超出了普通会员的存储容量限制，虽然文件不会被删除，但您将无法继续向网盘中上传文件，也无法使用转存、离线下载等会员功能，直至您再次续费成为超级会员或清理文件至普通会员存储容量限制以下。请注意，如果您在会员到期前没有及时续费，您的会员等级将会自动降级为普通用户，此时再续费可能无法立即恢复所有超级会员特权，因此建议您在会员到期前进行续费操作。首先，SVIP会员可以享受超大的存储空间，容量高达5T，让用户无需担心存储空间不足的问题，轻松存储大量的文件和数据。连续包月的价格大约是18元。
Spark-RDD
Alkaid的博客
06-30 340
RDD的特性 RDD的3种基本运算 RDD运算类型 说明 “转换”运算 会产生另外一个RDD的运算是“转换”运算，具有lazy特性，等到执行“动作”运算时才会执行 “动作”运算 不产生另外一个RDD，而是产生数值、数组或其他动作的运算 “持久化” 对于会重复使用的RDD，可以将RDD存入内存中作为后续使用，提高执行性能 RDD的容错性 Lineage机制：会记录每个R...
Spark-RDD.md
08-09
Spark_RDD
spark-rdd-sample1
04-29
在这个名为"spark-rdd-sample1"的示例中，我们很可能是要探讨如何在Java环境中使用Spark的RDD API进行编程。下面我们将深入理解Spark RDD的基本原理，以及如何在Java中应用这些概念。 1. **RDD定义**：RDD...
spark-rdd-APi
12-14
内容根据spark rdd.scala和ParRDDFunctions.scala源码中rdd顺序整理，包含rdd功能解释。对熟悉spark rdd很有用
spark-RDD的特性介绍及源码阅读必备基础
04-07
Spark中的弹性分布式数据集（Resilient Distributed Dataset, RDD）是其核心抽象概念，它代表了一个不可变、分区的记录集合，可以在集群中并行处理。RDD的主要特性包括以下几个方面： 1. **分片列表**：RDD是由多个...
playing-with-spark-rdd:Apache Spark RDD示例
03-21
项目中的"playing-with-spark-rdd-master"可能包含一系列示例代码，展示了如何创建、操作和转换RDD。这些示例可能涵盖以下内容： 1. **创建RDD**：RDD可以通过加载文件（如文本文件、CSV、JSON等）或者通过并行化...
2020-12-16
J1ngTu的博客
12-17 111
什么是resful？对resful的理解 1.restful是一种设计风格，不能以动词开头， 2.面向资源编程 3.资源的复数来命名url, 4.用post,get,put,delete来对应增删改查四种操作 5.符合Http状态码的返回规范， 6.通过url来进行参数传递 7.不需要与restful风格保持高度一致 APIView如何获取http里的数据？ request.GET.get 可以获取 http中的get请求数据。 post请求数据乙多种方法，request.POST，request.dat
转：spark的练习题（6）
10-17 904
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/qq_42721694/article/details/85001578 1.排序： 定义三个文件对文件内容进行排序（数字） package com.hyxy.spark01 import org.apache.spar...
百度网盘2024svip免费1天会员获取教程
热门推荐
FLflStudio的博客
04-15 5万+
我们平时使用百度网盘有时候偶尔会下载一些文件，但是不开通会员下载又很慢，开通一个月吧又觉得下载几个文件开通一个月比较浪费，就拿下载个5G左右的文件来说，不开通会员正常下载速度基本上在300-500KB徘徊，这速度可能还算好的，有的甚至是100KB左右爬行，下载这个5G左右的文件需要10来个小时甚至更多时间，根本等不了，这时候我们就需要临时开通几个小时或者一两天的超级会员下载可以说是非常不错的选择。输入激活码和验证码后，您将看到有关会员类型和时长的详细信息。在激活码页面，您需要手动输入一个16位的激活码。
EasyRecovery2024破解版本百度网盘下载附激活码
CaiHuaZeiPoJie的博客
04-14 1043
具体来说，它能够恢复包括文档、表格、图片、音视频等各种文件类型，无论是从传统的硬盘驱动器，还是存储卡、USB硬盘驱动器和USB闪存驱动器上丢失的文件，它都能有效执行安全、精确的恢复。请注意，尽管EasyRecovery功能强大，但数据恢复的成功率并不总是100%，它取决于多种因素，如数据丢失的时间长短、存储设备是否遭受物理损坏等。总的来说，EasyRecovery是一款功能全面、操作简便的数据恢复软件，能够支持多种存储设备格式和文件系统，为用户提供高效、可靠的数据恢复服务。
EasyRecovery15mac破解版激活码序列号
ehviewer2023的博客
04-15 1124
此外，对于音频文件，EasyRecovery同样支持丰富的格式，如MP3、WMA、WAV、SFK等。对于图片文件，无论是常见的JPG、PNG格式，还是其他专业或特殊的图像格式，EasyRecovery都有能力进行恢复。请注意，尽管EasyRecovery支持多种文件格式，但数据恢复的成功率并不总是100%，它取决于多种因素，如数据丢失的时间长短、存储设备是否遭受物理损坏等。此外，为了获得更好的恢复效果，建议在使用EasyRecovery之前，先停止对丢失数据的存储设备进行任何写入操作，以防止数据被覆盖。
【亲测有效】Tuxera ntfs 2023破解版|激活码|注册码分享 破解教程 Tuxera ntfs 2023百度云下载
软妹子的博客
04-20 3322
今天为大家带来一款好用的读写软件，2023全新Tuxera ntfs for mac破解版是一款Mac完全读写软件，具备丰富的磁盘管理功能，非常方便实用，有兴趣的小伙伴不妨来下载试试，亲测有效，已成功激活。相信这款全新Tuxera ntfs for mac2023破解版软件一定不会让你失望的。Tuxera ntfs 2023 版支持各个版本的Mac系统，同时Tuxera NTFS for Mac还具备Tuxera特有的先进功能，如支持NTFS拓展属性。
【Spark】Spark-空RDD判断与处理
05-25
在Spark中，我们可以使用空RDD来表示一个空的数据集。空RDD没有任何数据分区，因此不包含任何记录。在Spark中，我们可以使用以下方法来创建一个空RDD： ```scala val emptyRDD = spark.sparkContext.emptyRDD ``` ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值