Spark RDD 转换算子

最新推荐文章于 2024-01-03 23:19:48 发布
最新推荐文章于 2024-01-03 23:19:48 发布
阅读量215 收藏
点赞数
分类专栏： spark 文章标签： spark 大数据 hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55834564/article/details/125456669
版权

RDD 根据数据处理方式的不同将算子整体上分为 Value 类型、双 Value 类型和 Key-Value 类型

一、Value 类型

1.map

函数签名：def map[U: ClassTag](f: T => U): RDD[U]

将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。

代码：

object RddMapTest {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    var rdd = sc.makeRDD(List(1,2,3,4))
    //var rdd2 = rdd.map(x=>x*2)
    var rdd2 = rdd.map(_*2)
    rdd2.saveAsTextFile("outMap")
  }

}

2.mapPartitions

函数签名 def mapPartitions[U: ClassTag](

f: Iterator[T] => Iterator[U],

preservesPartitioning: Boolean = false): RDD[U]

代码：

object RddMapTest2{
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test2").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(List(5,6,7,8))
    val rdd2 = rdd.mapPartitions(datas=>{
      datas.map(_*2)
    })
    rdd2.saveAsTextFile("outMap2")
  }
}

 3.map 和 mapPartitions 的区别？

  • 数据处理角度

Map 算子是分区内一个数据一个数据的执行，类似于串行操作。而 mapPartitions 算子 是以分区为单位进行批处理操作。

  • 功能的角度

Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。 MapPartitions 算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变， 所以可以增加或减少数据

  • 性能的角度

Map 算子因为类似于串行操作，所以性能比较低，而是 mapPartitions 算子类似于批处 理，所以性能较高。但是 mapPartitions 算子会长时间占用内存，那么这样会导致内存可能 不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。使用 map 操作。

4.mapPartitionsWithIndex

函数签名

def mapPartitionsWithIndex[U: ClassTag](

f: (Int, Iterator[T]) => Iterator[U],

preservesPartitioning: Boolean = false): RDD[U] 

代码：

/**需求，RddMapTest的0分区乘与2；1分区不动
 *
 */
object RddMapTest{
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test3").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(List(4,5,8,9),2)
    val rdd2:RDD[(Int)] = rdd.mapPartitionsWithIndex((index,datas)=>{
      index match {
        case 0 => datas.map(_*2)
        case _ => datas
      }
    })
    rdd2.saveAsTextFile("outMap4")
  }
}

 5.flatMap

函数签名 def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]

将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射

代码：

object FlatMapDemo {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(List(List(1,2),List(3,4),List(5,6)))
    rdd.flatMap(list => list).collect().foreach(println)
  }

}

 6.glom

函数签名 def glom(): RDD[Array[T]]

将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变

代码： 

/**
 * 分区内取最大值，分区间最大值求和
 */
object glomDemo {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.textFile("input\\word.txt",3)
    val rdd2 = rdd.flatMap(line =>{
      line.split(",")
    })
    val rdd3 = rdd2.map(
      value=>{
        Integer.parseInt(value)
    }).glom().map(arr=>arr.max)
    rdd3.saveAsTextFile("out10")
  }

}

word.txt的数据

1,5,6,7,100
-1,50,14,1000
6,5,-100,20

 7.groupBy

函数签名 def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]

代码： 

object groupByDemo {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.textFile("input\\word.txt",2)
    val rdd2 = rdd.flatMap(_.split(",")).map(Integer.parseInt(_)).groupBy(_%2)
    rdd2.saveAsTextFile("out11")
  }

}

8.filter

函数签名 def filter(f: T => Boolean): RDD[T]

代码：

/**
 * 过滤字符串
 */
object FilterDemo2 {
  def main(args: Array[String]): Unit = {
    //创建SparkConfig
    var sparkConf = new SparkConf().setAppName("text").setMaster("local[*]")
    //创建SparkContext
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(Array("java","js","python","php"))
    rdd.filter(_.charAt(0)=='j').collect().foreach(println)
  }

}

9.sample

函数签名 def sample( withReplacement: Boolean, fraction: Double, seed: Long = Utils.random.nextLong): RDD[T] 

 代码：

object SampleDemo {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd:RDD[Long]=sc.range(1,100)
    //放回抽样
//    val rdd2 = rdd.sample(true,0.3)
    //不放回抽样
    val rdd2 = rdd.sample(false,0.3)
    print(rdd2.collect().mkString(","))
  }
}

/**
 *循环抽样
 */
object SampleDemo2 {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd:RDD[Long]=sc.range(1,100)
    for(a <- 1 to 10){
      //不放回抽样
      val rdd2 = rdd.sample(false,0.3,1)
      println(rdd2.collect().mkString(","))
    }

  }
}

/**
 * 数据倾斜
 */
object SampleDemo3 {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(Array("A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A",
      "A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A",
      "A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A",
      "B","B","B","B","B","B","B","B","C","D","E","F","G"))
    val rdd2 = rdd.map((_,1)).sample(true,0.3).reduceByKey(_+_).map(line=>(line._2,line._1)).sortBy(_._1,false).take(1)
    rdd2.foreach(line =>{
      println(line._1,line._2)
    })
    sc.stop()
  }
}

10.distinct

函数签名

def distinct()(implicit ord: Ordering[T] = null): RDD[T]

def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

代码：

object DistinctDemo {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(Array(1,2,3,1,1,2,2,3,3,5))
    //第一种去重
//    val rdd2 = rdd.distinct()
    //第二种去重
//    val rdd2 = rdd.map(x => (x,null)).reduceByKey((x,y)=> x,8).map(_._1)
    //对RDD采用多个Task去重，提高并发度
    val rdd2 = rdd.distinct(5)
    rdd2.foreach(println)
  }

}

 11.coalesce

函数签名

def coalesce(numPartitions: Int,

shuffle: Boolean = false,

partitionCoalescer: Option[PartitionCoalescer] = Option.empty)

(implicit ord: Ordering[T] = null) : RDD[T]

函数说明

根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率 当 spark 程序中，存在过多的小任务的时候，可以通过 coalesce 方法，收缩合并分区，减少 分区的个数，减小任务调度成本

代码：

object coalesceDemo {//执行Shuffle
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(Array(1,2,3,4,5,6),3)
    val rdd2 = rdd.mapPartitionsWithIndex((index,datas)=>{
      datas.foreach(data=>{
        println(s"${index}->${data}")
      })
      datas
    })
    rdd2.collect()

    //缩减分区至2个,
//    val rdd3 = rdd.coalesce(2)默认不Shuffle，
    val rdd3 = rdd.coalesce(2,true)执行Shuffle
    val rdd4 = rdd3.mapPartitionsWithIndex((index,datas)=>{
      datas.foreach(data=>{
        println(s"${index}->${data}")
      })
      datas
    })
    rdd4.collect()
  }

}

12.repartition

函数签名 def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

函数说明

该操作内部其实执行的是 coalesce 操作，参数 shuffle 的默认值为 true。无论是将分区数多的 RDD 转换为分区数少的 RDD，还是将分区数少的 RDD 转换为分区数多的 RDD，repartition 操作都可以完成，因为无论如何都会经 shuffle 过程。

代码：

/**
 * repartition()重新分区,可以大转小，小转大
 */
object coalesceDemo2 {//执行Shuffle
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(Array(1,2,3,4,5,6),2)
    val rdd2 = rdd.mapPartitionsWithIndex((index,datas)=>{
      datas.foreach(data=>{
        println(s"${index}->${data}")
      })
      datas
    })
    rdd2.collect()


    val rdd3 = rdd.repartition(3)//执行Shuffle
    val rdd4 = rdd3.mapPartitionsWithIndex((index,datas)=>{
      datas.foreach(data=>{
        println(s"${index}->${data}")
      })
      datas
    })
    rdd4.collect()
  }

}

 13.sortBy

函数签名 def sortBy[K]( f: (T) => K,ascending: Boolean = true, numPartitions: Int = this.partitions.length) (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]

代码： 

object sortByDemo {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(Array(1,2,3,4,5,6),3)
    rdd.sortBy(a=>a,false).collect().foreach(println)
  }

}

二、双 Value 类型

 14.intersection

函数签名 def intersection(other: RDD[T]): RDD[T]

代码：

/**
 * intersection()交集
 * 共同的元素
 */
object IntersectionDemo {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd1 =  sc.makeRDD(Array(1,2,3),3)
    val rdd2 = sc.makeRDD(Array(3,4,5),3)
    val rdd3 = rdd1.intersection(rdd2)
    //打印分区号和数据
    val rdd4 = rdd3.mapPartitionsWithIndex((index,datas)=>{
      datas.foreach(data=>{
        println(s"${index}->${data}")//1->1 2->2
      })
      datas
    })
    rdd4.collect()
  }

}

15.union

函数签名 def union(other: RDD[T]): RDD[T]

代码：

object UnionDemo {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd1 =  sc.makeRDD(Array(1,2,3),3)
    val rdd2 = sc.makeRDD(Array(3,4,5),3)
//    rdd1.union(rdd2).collect().foreach(println)//1,2,3,3,4,5
    val rdd3 = rdd1.union(rdd2)
//    rdd3.saveAsTextFile("out\\out13")
    //打印分区号和数据
    val rdd4 = rdd3.mapPartitionsWithIndex((index,datas)=>{
      datas.foreach(data=>{
        println(s"${index}->${data}")
      })
      datas
    })
    rdd4.collect()
  }

}

 16.subtract

函数签名 def subtract(other: RDD[T]): RDD[T]

代码：

/**
 * subtract ()差集
 * rdd1->rdd2 1,2
 * rrd2 ->rdd1 4,5
 */
object SubtractDemo {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd1 =  sc.makeRDD(Array(1,2,3),3)
    val rdd2 = sc.makeRDD(Array(3,4,5),3)
    val rdd3 = rdd1.subtract(rdd2)
    //打印分区号和数据
    val rdd4 = rdd3.mapPartitionsWithIndex((index,datas)=>{
      datas.foreach(data=>{
        println(s"${index}->${data}")//1->1 2->2
      })
      datas
    })
    rdd4.collect()
  }

}

 17.zip

函数签名 def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]

代码：

object ZipDemo {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd1 =  sc.makeRDD(Array("zhangsan","lisi","wangwu"),3)
    val rdd2 = sc.makeRDD(Array(20,18,21),3)
    val rdd3 = rdd1.zip(rdd2)
    rdd3.collect().foreach(println)
  }

}

三、Key - Value 类型

18.partitionBy

函数签名 def partitionBy(partitioner: Partitioner): RDD[(K, V)]

代码：

object ParTest {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(Array((1,"a"),(2,"b"),(3,"c")))
    var rdd2 = rdd.partitionBy(new HashPartitioner(2))
    rdd2.saveAsTextFile("out\\out14")
    sc.stop()
  }

}

 19.reduceByKey

函数签名

def reduceByKey(func: (V, V) => V): RDD[(K, V)]

def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]

代码：

/**
 * reduceByKey()按照K聚合V
 */
object ParTest2{
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(Array((1,"a"),(1,"b"),(3,"c"),(3,"d"),(3,"k")))
    val rdd2 = rdd.reduceByKey((x,y) =>x +y)
    rdd2.saveAsTextFile("out\\out15")
    sc.stop()
  }
}

 20.groupByKey

函数签名

def groupByKey(): RDD[(K, Iterable[V])]

def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])]

def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])]

代码：

/**
 *groupByKey()按照K重新分组,求value的最大值
 */
object ParTest3{
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(List(("a",1),("b",5),("a",5),("b",2)))
    val rdd2 = rdd.groupByKey()
    rdd2.map(line =>(line._1,line._2.max)).collect().foreach(println)
    sc.stop()
  }
}

 21.reduceByKey 和 groupByKey 的区别？

  • 从 shuffle 的角度：

reduceByKey 和 groupByKey 都存在 shuffle 的操作，但是 reduceByKey 可以在 shuffle 前对分区内相同 key 的数据进行预聚合（combine）功能，这样会减少落盘的 数据量，而 groupByKey 只是进行分组，不存在数据量减少的问题，reduceByKey 性能比较 高。

  • 从功能的角度：

reduceByKey 其实包含分组和聚合的功能。GroupByKey 只能分组，不能聚 合，所以在分组聚合的场合下，推荐使用 reduceByKey，如果仅仅是分组而不需要聚合。那 么还是只能使用 groupByKey

 22.aggregateByKey

函数签名

def aggregateByKey[U: ClassTag](zeroValue: U)

(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]

代码：

/**
 * aggregateByKey()
 */
object aggregateByKeyTest {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(List(("a",1),("b",5),("a",5),("b",2)))
    rdd.aggregateByKey(0)(Math.max(_,_),_+_).collect().foreach(println)
    sc.stop()
  }

}

 23.foldByKey

函数签名 def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]

代码:

/***
 * foldByKey()分区内
 */
object foldByKeyTest{
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(List(("a",1),("b",5),("a",5),("b",2)))
    rdd.foldByKey(0)(_+_).collect().foreach(println)
    sc.stop()
  }
}

 24.combineByKey

函数签名

def combineByKey[C]( createCombiner: V => C,

mergeValue: (C, V) => C,

mergeCombiners: (C, C) => C): RDD[(K, C)]

代码： 

/**
 * combineByKey()转换结构后分区内和分区间操作
 */
object combineByKeyTest{
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(List(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98)))
    val rdd2 = rdd.combineByKey(
      (_,1),
      (acc:(Int,Int),v)=>(acc._1 + v,acc._2+1),
      (acc1:(Int,Int),acc2:(Int,Int))=>(acc1._1+acc2._1,acc1._2+acc2._2)
    )
    rdd2.map{
      case(key,value)=>{
        (key,value._1/value._2.toDouble)
      }
    }.collect().foreach(println)
    sc.stop()
  }
}

 25.sortByKey

函数签名

def sortByKey(ascending: Boolean = true,

numPartitions: Int = self.partitions.length) : RDD[(K, V)]

代码：

/**
 * sortByKey()按照K进行排序
 */
object sortByKeyTest{
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(Array((3,"aa"),(6,"cc"),(2,"bb"),(1,"dd")))
    rdd.sortByKey(true).collect().foreach(println)
  }
}

 26.join

函数签名 def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]

代码：

/**
 * join()连接 将相同key对应的多个value关联在一起
 */
object joinTest{
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd:RDD[(Int,String)]= sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
    val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (4, 6)))
    rdd.join(rdd1).collect().foreach(println)
    sc.stop()
  }
}

 27.cogroup

函数签名 def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]

代码： 

/**
 * cogroup() 类似全连接，但是在同一个RDD中对key聚合
 */
object cogroupTest{
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val rdd:RDD[(Int,String)]= sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
    val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (3, 6)))
    rdd.cogroup(rdd1).collect().foreach(println)
    sc.stop()
  }
}

 

lambda-小张
关注
专栏目录
SparkRDD——转换算子
tyh1579152915的博客
05-19 2979
转换算子 一、单value型转换算子（只使用1个RDD）： 1、map 将数据进行转换，数据量不会增加和减少 2、mapPartitions 以分区为单位将一个分区内的数据进行批处理操作，且可以执行过滤操作 3、mapPartitionsWithIndex 功能类似mapPartiutions算子，只是加入了每个分区的索引，可以选择性的对某些分区进行操作 4、flatMap 扁平化操作，即将集合嵌套类型的数
Spark RDD转换算子与行动算子
m0_51691291的博客
12-30 1282
Spark RDD转换算子与行动算子1、什么是RDD1.1、RDD五大核心属性2、RDD转换算子2.1、单value2.2、双value2.3、Key-Value3、RDD行为算子 1、什么是RDD   RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数据处理模型。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。 弹性 存储的弹性：内存与磁盘的自动切换； 容错的弹性：数据丢失可以自动恢复； 计算的弹性：计
Spark的RDD转换算子
Faith_xzc
08-16 618
目录RDD转换算子Value 类型1. map函数定义案例实操2. mapPartitions函数定义案例实操map 和mapPartitions 的区别3. mapPartitionsWithIndex函数定义案例实操4. flatMap函数定义案例实操5. glom函数定义案例实操6. groupBy函数定义案例实操7. filter函数定义案例实操8. sample函数定义案例实操9. distinct函数定义案例实操10. coalesce函数定义案例实操11. repartition函数定义案例实
Spark之RDD转换算子
lslslslslss的博客
02-11 1020
目录 一.value类型 1.map() 2.mapPartitions() 3.mapPartitionsWithIndex() 4.flatMap()扁平化 5.glom() 6.groupBy() 7.filter() 8.sample() 9. distinct() 10.coalesce() 11.repartition() 12.sortBy() 13. pipe() 二、双value 1.intersection() 2.union() 3.s...
scala spark RDD max
QAQ_666666的博客
12-16 578
根据对象的日期属性，求出rdd 中最大日期的 那一个对象。 val maxOrder = orderRDD.max()(Ordering[Date].on(d => { DateTimeFormat.forPattern(yyyy-MM-dd).parseDateTime(d.createDate).toDate })) 搞定收工。
spark: rdd的应用(scala api)
eyeofeagle的博客
10-10 476
wordcount: 统计词频， 排序 历年温度最值： max, min, avg //word.txt var file=&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;/home/wang/txt/word.txt&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;quot; //a b c e f e f import org.apache.spark.rdd.RDD v
sparkrdd转换算子
最新发布
03-18
以下是一些常见的Spark RDD转换算子： 1. map(func)：对RDD中的每个元素应用给定的函数，返回一个新的RDD，新RDD中的每个元素都是原RDD中元素经过函数处理后的结果。 2. filter(func)：对RDD中的每个元素应用给定...
Spark的RDD转换算子与行动算子
Laoddaaa的博客
08-20 572
Spark的RDD转换算子与行动算子
Spark之RDD转换算子（transformation）大全
zp17834994071的博客
08-07 4534
前面已经给大家讲过RDD原理，今天就给大家说说RDD的转换算子有哪些，以便大家理解。 对于转换操作，RDD的所有转换都不会直接计算结果，仅记录作用于RDD上的操作，当遇到动作算子（Action）时才会进行真正计算，理解了转换算子的用途，那么接下来就不能理解哪些是转换算子了，通俗的说只要没有经过聚合或计算的算子，都可以当作转换算子。 常用转换算子 map 对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD 任何原RDD中的元素在新RDD中都有且只有一个元素与之对应 输入分区与输出分区一一对应 案
Spark RDD的函数详解
Code_LT的博客
02-19 832
RDD支持两种操作：转换（transformation）从现有的数据集创建一个新的数据集；而动作（actions）在数据集上运行计算后，返回一个值给驱动程序。 区别是tranformation输入RDD，输出RDD，而action输入RDD，输出非RDD。transformation是缓释执行的，action是即刻执行的。例如，df1.map就是一种转换，它在使用时，并没有被调用，只有和df1相关...
三 Spark RDD函数讲解
张金玉的专栏
12-28 294
一 运维hadoop spark http://192.168.229.133:50070/dfshealth.html#tab-overview http://192.168.229.133:8080 停掉hadoop cd /usr/local/hadoop-2.6.5/sbin 停掉dfs[root@testceph sbin]# stop-dfs.sh 启动dfs[root@test...
Spark RDD常用的函数
nwpuxhld
04-25 1364
Spark RDD常用函数
Spark---RDD算子(单值类型转换算子)
weixin_47109902的博客
01-03 1645
RDD算子是用于对RDD进行转换（Transformation）或行动（Action）操作的方法或函数。转换算子用于从一个RDD生成一个新的RDD，但是原始RDD保持不变。常见的转换算子包括map、filter、flatMap等，它们通过对RDD的每个元素执行相应的操作来生成新的RDD。行动算子触发对RDD的实际计算，并返回计算结果或将结果写入外部存储系统。与转换算子不同，行动算子会导致Spark作业的执行。如collect方法。
Spark 之 RDD转换算子
向日葵的博客
12-02 806
RDD转换算子前言Spark 知识系列文章一、RDD的转换算子1.1 Value类型1.1.1 map(func)案例1.1.2 mapPartitions(func) 案例1.1.3 Map 和 MapPartition的区别1.1.4 flatMap(func) 案例1.1.5 glom案例1.1.6 groupBy(func)案例1.1.7 sample(withReplacement, fraction, seed) 案例1.1.8 distinct([numTasks])) 案例1.1.9 coa
Spark（二）----RDD
大数据
12-04 354
Spark是一个大数据分布式并行计算框架，不仅实现了MapReduce的算子，map函数和reduce函数形成了一个计算模型。还提供了更加丰富的算子，Spark中提到的算子的概念就可以简称为RDD。 RDD叫做分布式数据集，是Spark中最基本的数据抽象，它是一个不可变，可分区，里面的元素可以并行计算的集合。 RDD数据流模型的特点： 自动容错，位置感知和可伸缩，RDD允许在执行多个查询时显示的将...
【SparkCore】RDD常用方法以及使用
qq_41369191的博客
05-07 1061
目录 创建RDD 1.由外部存储系统的数据集创建，包括本地的文件系统，还有所有Hadoop支持的数据集，比如HDFS、Cassandra、HBase等 2.通过已有的RDD经过算子转换生成新的RDD 3.由一个已经存在的Scala集合创建 RDD的方法/算子分类 Transformation转换算子 Action动作算子 RDD分区的数据取决的因素 常用API 创建RDD 查...
Spark学习之路（六）——Spark编程基础（RDD）
Rong_Robot的博客
09-22 1553
1、RDD创建方式：①从文件系统中加载数据，②通过并行集合（数组）。 从文件系统中加载数据： Spark的SparkContext通过TextFile()读取数据生成内存中的RDD（字符串类型）。 .textFile()方法支持的数据类型：①本地文件系统(例：sc.textFile(“file:///usr/local/spark/readme.txt”)，注意：file后是3个“/”)；②分布式...
Spark的操作算子
js010111的博客
01-23 1778
Spark的操作算子 一、在Apache Spark中，RDD（弹性分布数据集）是一个非常重要的核心概念，很多计算必须依赖于RDD。一般来说，RDD包括两个操作算子： 1. 变换：变换算子的特点是**懒执行**，变换操作并不会立即执行，而是需要等到有**动作操作**的时候才会真正进行计算，并得到结果。 2. 动作：动作算子的特点是**立即执行**，动作算子会对`RDD`计算出一个结果，并把结果返回到**驱动器程序**中，或把结果存储到**外部存储系统**（如`HDFS`）中。 二、Spark的操作算子（以
Spark核心编程—RDD算子(转换算子)
weixin_42570840的博客
06-13 1791
Spark核心编程、RDD转换算子
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lambda-小张

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值