2020.11.6课堂笔记(spark常用RDD算子2)

最新推荐文章于 2021-01-31 17:55:53 发布
最新推荐文章于 2021-01-31 17:55:53 发布
阅读量164 收藏
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48758256/article/details/109591314
版权

reduceByKey

接收一个函数，按照相同的key进行reduce操作，类似于scala的reduce的操作

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object ReduceByKeyDemo {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setAppName("reducebykey11").setMaster("local[*]")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[String] = sc.textFile("in/sample.txt")
    val rdd2: RDD[String] = rdd.flatMap(x=>x.split("\\s+"))
    val rdd3: RDD[(String, Int)] = rdd2.map((_,1))
    val rdd4: RDD[(String, Int)] = rdd3.reduceByKey(_+_)
    rdd4.collect.foreach(println)
  }
}

java版本：

/**
 * Merge the values for each key using an associative and commutative reduce function. This will
 * also perform the merging locally on each mapper before sending results to a reducer, similarly
 * to a "combiner" in MapReduce. Output will be hash-partitioned with the existing partitioner/
 * parallelism level.
 */
def reduceByKey(func: JFunction2[V, V, V]): JavaPairRDD[K, V] = {
  fromRDD(reduceByKey(defaultPartitioner(rdd), func))
}

def fromRDD[K: ClassTag, V: ClassTag](rdd: RDD[(K, V)]): JavaPairRDD[K, V] = {
  new JavaPairRDD[K, V](rdd)
}

代码实现：

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import scala.Tuple2;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @Author: ChaoKeAiMuZhi
 * @Date: 2020/11/10 8:40
 * @Description:
 **/
public class ReduceByKeyJava {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("reduceByKey");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<String> stringJavaRDD = sc.textFile("in/sample.txt");
        JavaRDD<Tuple2<String, Integer>> tuple2JavaRDD = stringJavaRDD.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Iterator<Tuple2<String, Integer>> call(String s) throws Exception {
                String[] split = s.split("\\s+");
                ArrayList<Tuple2<String, Integer>> tuple2 = new ArrayList<>();
                for (int i = 0; i < split.length; i++) {
                    Tuple2<String, Integer> tp2 = new Tuple2<>(split[i], 1);
                    tuple2.add(tp2);
                }
                return tuple2.iterator();
            }
        });
        JavaPairRDD<String, Integer> javaPairRDD = JavaPairRDD.fromJavaRDD(tuple2JavaRDD);
        JavaPairRDD<String, Integer> reduceByKeyRdd = javaPairRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });
        //第一遍历方式，打印的是Tuple2类型
        List<Tuple2<String, Integer>> collect = reduceByKeyRdd.collect();
        for (Tuple2<String, Integer> stringIntegerTuple2 : collect) {
            System.out.println(stringIntegerTuple2);
        }
        //第二种打印方式,因为是键值对的形式，可以转换成Map
        System.out.println("--------------------------");
        Map<String, Integer> map = reduceByKeyRdd.collectAsMap();
        for (String s : map.keySet()) {
            System.out.println("("+s+","+map.get(s)+")");
        }
    }
}

foldByKey：

该函数用于RDD[K,V]根据K将V做折叠、合并处理，其中的参数zeroValue表示先根据映射函数将zeroValue应用于V,进行初始化V,再将映射函数应用于初始化后的V.
与reduce不同的是 foldByKey开始折叠的第一个元素不是集合中的第一个元素，而是传入的一个元素

在Scala中：PairRDDFunctions
/**
 * Merge the values for each key using an associative function and a neutral "zero value" which
 * may be added to the result an arbitrary number of times, and must not change the result
 * (e.g., Nil for list concatenation, 0 for addition, or 1 for multiplication.).
 */
def foldByKey(
    zeroValue: V,
    partitioner: Partitioner)(func: (V, V) => V): RDD[(K, V)] = self.withScope {
  // Serialize the zero value to a byte array so that we can get a new clone of it on each key
  val zeroBuffer = SparkEnv.get.serializer.newInstance().serialize(zeroValue)
  val zeroArray = new Array[Byte](zeroBuffer.limit)
  zeroBuffer.get(zeroArray)
  // When deserializing, use a lazy val to create just one instance of the serializer per task
  lazy val cachedSerializer = SparkEnv.get.serializer.newInstance()
  val createZero = () => cachedSerializer.deserialize[V](ByteBuffer.wrap(zeroArray))
  val cleanedFunc = self.context.clean(func)
  combineByKeyWithClassTag[V]((v: V) => cleanedFunc(createZero(), v),
    cleanedFunc, cleanedFunc, partitioner)
}
/**
 * Merge the values for each key using an associative function and a neutral "zero value" which
 * may be added to the result an arbitrary number of times, and must not change the result
 * (e.g., Nil for list concatenation, 0 for addition, or 1 for multiplication.).
 */
def foldByKey(zeroValue: V, numPartitions: Int)(func: (V, V) => V): RDD[(K, V)] = self.withScope {
  foldByKey(zeroValue, new HashPartitioner(numPartitions))(func)
}
/**
 * Merge the values for each key using an associative function and a neutral "zero value" which
 * may be added to the result an arbitrary number of times, and must not change the result
 * (e.g., Nil for list concatenation, 0 for addition, or 1 for multiplication.).
 */
def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)] = self.withScope {
  foldByKey(zeroValue, defaultPartitioner(self))(func)
}

//最终调用的方法combineByKeyWithClassTag
def combineByKeyWithClassTag[C](
    createCombiner: V => C,    //(v: V) => cleanedFunc(createZero(), v)
    mergeValue: (C, V) => C,    //cleanedFunc = self.context.clean(func)
    mergeCombiners: (C, C) => C,    //cleanedFunc = self.context.clean(func)
    partitioner: Partitioner,    //partitioner
    mapSideCombine: Boolean = true,
    serializer: Serializer = null)(implicit ct: ClassTag[C]): RDD[(K, C)] = self.withScope {
  require(mergeCombiners != null, "mergeCombiners must be defined") // required as of Spark 0.9.0
  if (keyClass.isArray) {
    if (mapSideCombine) {
      throw new SparkException("Cannot use map-side combining with array keys.")
    }
    if (partitioner.isInstanceOf[HashPartitioner]) {
      throw new SparkException("HashPartitioner cannot partition array keys.")
    }
  }
  val aggregator = new Aggregator[K, V, C](
    self.context.clean(createCombiner),
    self.context.clean(mergeValue),
    self.context.clean(mergeCombiners))
  if (self.partitioner == Some(partitioner)) {
    self.mapPartitions(iter => {
      val context = TaskContext.get()
      new InterruptibleIterator(context, aggregator.combineValuesByKey(iter, context))
    }, preservesPartitioning = true)
  } else {
    new ShuffledRDD[K, V, C](self, partitioner)
      .setSerializer(serializer)
      .setAggregator(aggregator)
      .setMapSideCombine(mapSideCombine)
  }
}

代码：

scala> var rdd1 = sc.makeRDD(Array(("A",0),("A",2),("B",1),("B",2),("C",1)))
scala> rdd1.foldByKey(0)(_+_).collect
res75: Array[(String, Int)] = Array((A,2), (B,3), (C,1)) 
//将rdd1中每个key对应的V进行累加，注意zeroValue=0,需要先初始化V,映射函数为+操作，比如("A",0), ("A",2)，先将zeroValue应用于每个V,得到：("A",0+0), ("A",2+0)，即：
//("A",0), ("A",2)，再将映射函数应用于初始化后的V，最后得到(A,0+2),即(A,2)
scala> rdd1.foldByKey(2)(_+_).collect
res76: Array[(String, Int)] = Array((A,6), (B,7), (C,3))
//先将zeroValue=2应用于每个V,得到：("A",0+2), ("A",2+2)，即：("A",2), ("A",4)，再将映射函数应用于初始化后的V，最后得到：(A,2+4)，即：(A,6)
scala> rdd1.foldByKey(0)(_*_).collect
res77: Array[(String, Int)] = Array((A,0), (B,0), (C,0))
//先将zeroValue=0应用于每个V,注意，这次映射函数为乘法，得到：("A",0*0), ("A",2*0)，
//即：("A",0), ("A",0)，再将映射函//数应用于初始化后的V，最后得到：(A,0*0)，即：(A,0)
//其他K也一样，最终都得到了V=0
scala> rdd1.foldByKey(1)(_*_).collect
res78: Array[(String, Int)] = Array((A,0), (B,2), (C,1))
//映射函数为乘法时，需要将zeroValue设为1，才能得到我们想要的结果。

java中：

在JavaPairRDD中：
/**
 * Merge the values for each key using an associative function and a neutral "zero value" which
 * may be added to the result an arbitrary number of times, and must not change the result
 * (e.g ., Nil for list concatenation, 0 for addition, or 1 for multiplication.).
 */
def foldByKey(zeroValue: V, partitioner: Partitioner, func: JFunction2[V, V, V])
: JavaPairRDD[K, V] = fromRDD(rdd.foldByKey(zeroValue, partitioner)(func))

/**
 * Merge the values for each key using an associative function and a neutral "zero value" which
 * may be added to the result an arbitrary number of times, and must not change the result
 * (e.g., Nil for list concatenation, 0 for addition, or 1 for multiplication.).
 */
def foldByKey(
    zeroValue: V,
    partitioner: Partitioner)(func: (V, V) => V): RDD[(K, V)] = self.withScope {
  // Serialize the zero value to a byte array so that we can get a new clone of it on each key
  val zeroBuffer = SparkEnv.get.serializer.newInstance().serialize(zeroValue)
  val zeroArray = new Array[Byte](zeroBuffer.limit)
  zeroBuffer.get(zeroArray)
  // When deserializing, use a lazy val to create just one instance of the serializer per task
  lazy val cachedSerializer = SparkEnv.get.serializer.newInstance()
  val createZero = () => cachedSerializer.deserialize[V](ByteBuffer.wrap(zeroArray))
  val cleanedFunc = self.context.clean(func)
  combineByKeyWithClassTag[V]((v: V) => cleanedFunc(createZero(), v),
    cleanedFunc, cleanedFunc, partitioner)
}

java代码实现：

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function2;
import scala.Tuple2;

import java.util.Arrays;
import java.util.Map;

/**
 * @Author: ChaoKeAiMuZhi
 * @Date: 2020/11/10 9:51
 * @Description:
 **/
public class FoldByKeyJava {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("foldbykey");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<Tuple2<String, Integer>> rdd = sc.parallelize(Arrays.asList(
                new Tuple2<>("A", 2),
                new Tuple2<>("A", 3),
                new Tuple2<>("A", 4),
                new Tuple2<>("B", 5),
                new Tuple2<>("A", 6)
        ));
        JavaPairRDD<String, Integer> javaPairRDD = JavaPairRDD.fromJavaRDD(rdd);
        JavaPairRDD<String, Integer> foldByKeyRDD = javaPairRDD.foldByKey(1, new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                System.out.println("v1的值是："+v1+"，v2的值是："+v2);
                return v1 + v2;
            }
        });
        Map<String, Integer> map = foldByKeyRDD.collectAsMap();
        for (String s : map.keySet()) {
            System.out.println("("+s+","+map.get(s)+")");
        }
    }
}

sortByKey

SortByKey用于对pairRDD按照key进行排序，第一个参数可以设置true或者false，默认是true

/**
 * Sort the RDD by key, so that each partition contains a sorted range of the elements. Calling
 * `collect` or `save` on the resulting RDD will return or output an ordered list of records
 * (in the `save` case, they will be written to multiple `part-X` files in the filesystem, in
 * order of the keys).
 */
// TODO: this currently doesn't work on P other than Tuple2!
def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length)
    : RDD[(K, V)] = self.withScope
{
  val part = new RangePartitioner(numPartitions, self, ascending)
  new ShuffledRDD[K, V, V](self, part)
    .setKeyOrdering(if (ascending) ordering else ordering.reverse)
}

scala代码：

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object SortByKey {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("sortbykey")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[(String, Int)] = sc.parallelize(List(("A",1),("B",2),("C",3),("D",4),("E",5)))
    val rdd2: RDD[(String, Int)] = rdd.sortByKey(false)
    rdd2.collect.foreach(println)
  }
}

注意：最终结果生成的是ShuffledRDD，sortByKey是转换算子
java实现：

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;

import java.util.Arrays;
import java.util.Map;

/**
 * @Author: ChaoKeAiMuZhi
 * @Date: 2020/11/10 11:06
 * @Description:
 **/
public class SortByKeyJava {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("sortbykey");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<Tuple2<String, Integer>> rdd = sc.parallelize(Arrays.asList(
                new Tuple2<>("A", 1),
                new Tuple2<>("C", 2),
                new Tuple2<>("D", 3),
                new Tuple2<>("E", 4)));
        JavaPairRDD<String, Integer> javaPairRDD = JavaPairRDD.fromJavaRDD(rdd);
        JavaPairRDD<String, Integer> sortByKeyRdd = javaPairRDD.sortByKey();
        Map<String, Integer> map = sortByKeyRdd.collectAsMap();
        for (String s : map.keySet()) {
            System.out.println("("+s+","+map.get(s)+")");
        }
    }
}

将JavaRDD转成JavaPairRDD的两种写法：
第一种：

JavaPairRDD<String, Integer> javaPairRDD = rdd.mapToPair(new PairFunction<Tuple2<String, Integer>, String, Integer>() {
    @Override
    public Tuple2<String, Integer> call(Tuple2<String, Integer> stringIntegerTuple2) throws Exception {
        return stringIntegerTuple2;
    }
});

第二种

JavaPairRDD<String, Integer> javaPairRDD = JavaPairRDD.fromJavaRDD(rdd);
超可爱慕之
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark零基础入门实战（二）Scala集合之元组、Set
大数据实战派
12-08 735
元组是一个可以存放不同类型对象的集合，元组中的元素不可以修改。例如，定义一个元组t： 也可以使用以下方式定义元组，其中Tuple3是一个元组类，代表元组的长度为3： 目前，Scala 支持的元组最大长度为22，即可以使用Tuple1到Tuple22。元组的实际类型取决于元素数量和元素的类型。例如，(20,"shanghai")的类型是Tuple2[Int,String]，(10,20,"beijing","shanghai","guangzhou")的类型是Tuple5[Int,Int,String
Spark常用的算子以及Scala函数总结.pdf
05-17
Spark RDD 算子说明，分别讲述了Transformation和Action这两类的算子。
Spark RDD（2）
qq_33431394的博客
10-22 367
Spark core Insight 目标 深入理解 RDD 的内在逻辑 能够使用 RDD 的算子 理解 RDD 算子的 Shuffle 和缓存 理解 RDD 整体的使用流程 理解 RDD 的调度原理 理解 Spark 中常见的分布式变量共享方式 1. 深入 RDD 目标 深入理解 RDD 的内在逻辑, 以及 RDD 的内部属性(RDD 由什么组成) 1.1. 案例 需求 给定一个网站的访问记录, 俗称 Access log 计算其中出现的独立 IP, 以及其访问的次数 val config =
LearningSpark(3)：常用RDD操作
lzw2016的博客
03-06 290
键值对RDD上的操作 隐式转换 shuffle操作中常用针对某个key对一组数据进行操作，比如说groupByKey、reduceByKey这类PairRDDFunctions中需要启用Spark的隐式转换，scala就会自动地包装成元组 RDD。导入 org.apache.spark.SparkContext._即可 没啥意思，就是记着导入import org.apache.spark.Spar...
Spark Core —— RDD
code_for_god
01-31 58
RDD 概念理解入门
Spark（三）RDD与广播变量、累加器
weixin_42073629的博客
10-04 240
一、RDD的概述 1.1 什么是RDD RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。RDD具有数据流模型的特点：自动容错、位置感知性调度和可伸缩性。RDD允许用户在执行多个查询时显式地将工作集缓存在内存中，后续的查询能够重用工作集，这极大地提升了查询速度。 1.2 RDD的属性 （1）一组分片（Partition），即数据集的基本组成单位。对于RDD来说，每个分片都会.
Spark1.4.1 RDD算子详解
03-02
结合代码详细描述RDD算子的执行流程，并配上执行流程图
java-spark中各种常用算子的写法示例
08-27
下面我们将通过示例代码来介绍一些常用的 Spark 算子写法。 1. map 算子 map 算子是 Spark 中最基本的算子之一，它可以将一个 RDD 转换成另一个 RDD。map 算子需要定义一个转换函数，该函数将输入数据转换成输出...
Spark算子.pdf
05-05
Spark对于大数据行业的实时处理数据来说，有着举足轻重的位置，特此学习整理了RDD 算子的各个含义，希望各位读者能够喜欢。谢谢
Spark-RDD.md
最新发布
08-09
Spark_RDD
Spark之RDD实战篇3
菜鸟清风http://www.hphblog.cn/
05-29 533
键值对RDD、数据读取与保存、累加器、广播变量： 键值对RDDSpark 为包含键值对类型的 RDD 提供了一些专有的操作 在PairRDDFunctions专门进行了定义。这些 RDD 被称为 pair RDD。有很多种方式创建pair RDD，在输入输出章节会讲解。一般如果从一个普通的RDD转 为pair RDD时，可以调用map(...
flask 运行 flask db init 报错，init-db 命令找不到
Rao的博客
02-14 1万+
官网中的示例代码 flask init-db 结果是 `Error: No such command “init-db”. 那是因为init-db 已经被 flask db init 给代替了 运行 flask db init 报错 Usage: flask db init [OPTIONS] Error: Failed to find Flask application or fa...
scala（Row、Array、Tuple、Class、RDD、DF之间类型转换）
热门推荐
yyoc97的专栏
10-25 1万+
前言 spark中因为Rdd和Dataframe的一些分装函数处理，经常会遇到类型的相关转换，今天就记录些常见的几种类型转换。 Array => Row val arr = Array("aa/2/cc/10","xx/3/nn/30","xx/3/nn/20") // val row = Row.fromSeq(arr) val row = RowFactory.create(arr) Row => Array val a:Array[Any] = row.toSeq.toArray 有时
spark自带demo的详解
俺叫赵小邪的博客
11-21 6975
import scala.Tuple2;import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaPairRDD; import org.apache.spark.api.java.JavaRDD; import org.apache.spark.api.java.JavaSparkContext; import
SparkSQL读取Tuple类型的Dataset加载DatFrame
yj2434的博客
11-04 368
测试数据： 146.202.84.90 江西 2020-10-28 1603879301437 6285032924209569490 www.jd.com Login 146.202.84.90 江西 2020-10-28 1603879301438 6285032924209569490 www.gome.com.cn Login 146.202.84.90 江西 2020-10-28 1603879301438 6285032924209569490 www.taobao.com Comment 11
Spark学习（7）——scala的Map与Tuple
wangzq2213的博客
07-31 1746
创建Map 创建一个不可变的Map，immutable不可变的，默认的Map是immutable 根据键名获取map的值 创建一个可变的Map，可以改变某个值 使用另外一种方式定义Map元素 创建一个空的HashMap 访问Map的元素 获取指定key对应的value，如果key不存在，会报错 获取不存在的key 使用contains函数检查key是否...
spark数据倾斜处理
郭首志的博客
08-08 294
w &gt;&gt; call（Tuple2 &lt;Long，String&gt; tuple）                         抛出异常{                     //在算子函数中，通过广播变量，获取到本地Executor中的rdd1数据。                     List &lt;Tuple2 &lt;Long，Row &gt;&gt; ...
scala 元组tuple的几个知识点
iteye_6988的博客
12-04 760
通过下标_n取数据不多说了，下面是几个比较有意思的知识点    知识点 1、Tuple 和Function 和Producct一样最多只支持22个元素       比如 (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21) 这样是没问题的       但是(0,1,2,3,4,5,6,7,8,9,10,11,12,13,1...
spark 2.2.0 各个计算因子的使用方法 java版
豆筱豆的博客
01-12 662
map: private static void map(){ SparkConf conf =new SparkConf().setAppName("map").setMaster("local"); JavaSparkContext sc =new JavaSparkContext(conf); List numbers = Arrays.asList(1,2,3,4,5);
spark RDD常用算子
07-15
RDD算子调优是Spark性能调优的重要方面之一。以下是一些常见的RDD算子调优技巧： 1. 避免使用过多的shuffle操作，因为shuffle操作会导致数据的重新分区和网络传输，从而影响性能。 2. 尽量使用宽依赖操作（如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值