键值对RDD

最新推荐文章于 2024-07-15 16:53:59 发布
最新推荐文章于 2024-07-15 16:53:59 发布
阅读量1k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hb707934728/article/details/53635918
版权

键值对RDD也就是JavaPairRDD,键值对RDD通常用来进行聚合计算

键值对RDD的创建,及常用操作

/**
 * Created by hbin on 2016/12/9.
 */
import java.io.Serializable;
import java.util.Arrays;
import java.util.List;

import breeze.optimize.linear.LinearProgram;
import io.netty.util.internal.StringUtil;
import org.apache.commons.lang.StringUtils;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaDoubleRDD;
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.*;
import scala.Tuple2;


/**
 * spark对数据的核心抽象  RDD（弹性分布式数据集）
 * RDD就是分布式的元素集合,在spark中对数据的所有操作不外乎创建RDD
 * 转化已有RDD以及调用RDD操作进行求值,spark会自动将RDD中的数据分发到集群上，
 * 并将操作并行化
 */
public class BasicMap {
    public static void main(String[] args) throws Exception {
        SparkConf sparkConf = new SparkConf().setAppName("JavaSparkPi");
        JavaSparkContext jsc = new JavaSparkContext(sparkConf);

        JavaRDD<String> RDD1=jsc.parallelize(Arrays.asList("1","2","3","4","5","6","7","8","9"),6);// 并行化

        PairFunction<String,String,String> keyData=new PairFunction<String, String, String>() {
            @Override
            public Tuple2<String, String> call(String s) throws Exception {
                return new Tuple2<>(s.split(" ")[0],s);
            }
        };
        JavaPairRDD<String,String> pairs=RDD1.mapToPair(keyData);

        JavaPairRDD<String,String> newPairs=pairs.mapValues(new Function<String, String>() {
           @Override
           public String call(String s) throws Exception {
               return s+"*";
           }
        });
        System.out.println("newPairs="+newPairs.collect());
        System.out.println(" pairs.collect()="+pairs.collect()+" RDD1="+RDD1.collect());
        System.out.println(" groupByKey()="+pairs.groupByKey().collect());
        System.out.println("keys()="+pairs.keys().collect());
        System.out.println("values()="+pairs.values().collect());
        System.out.println("sortByKey()="+pairs.sortByKey().collect());

    }
}
执行结果:

newPairs=[(1,1*), (2,2*), (3,3*), (4,4*), (5,5*), (6,6*), (7,7*), (8,8*), (9,9*)]

pairs.collect()=[(1,1), (2,2), (3,3), (4,4), (5,5), (6,6), (7,7), (8,8), (9,9)] RDD1=[1, 2, 3, 4, 5, 6, 7, 8, 9]

groupByKey()=[(6,[6]), (7,[7]), (1,[1]), (8,[8]), (2,[2]), (9,[9]), (3,[3]), (4,[4]), (5,[5])]

keys()=[1, 2, 3, 4, 5, 6, 7, 8, 9]

values()=[1, 2, 3, 4, 5, 6, 7, 8, 9]

sortByKey()=[(1,1), (2,2), (3,3), (4,4), (5,5), (6,6), (7,7), (8,8), (9,9)]



针对两个pair RDD的转化操作


代码示例

/**
 * Created by hbin on 2016/12/9.
 */
import java.io.Serializable;
import java.util.Arrays;
import java.util.List;

import breeze.optimize.linear.LinearProgram;
import io.netty.util.internal.StringUtil;
import org.apache.commons.lang.StringUtils;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaDoubleRDD;
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.*;
import scala.Tuple2;


/**
 * spark对数据的核心抽象  RDD（弹性分布式数据集）
 * RDD就是分布式的元素集合,在spark中对数据的所有操作不外乎创建RDD
 * 转化已有RDD以及调用RDD操作进行求值,spark会自动将RDD中的数据分发到集群上，
 * 并将操作并行化
 */
public class BasicMap {
    public static void main(String[] args) throws Exception {
        SparkConf sparkConf = new SparkConf().setAppName("JavaSparkPi");
        JavaSparkContext jsc = new JavaSparkContext(sparkConf);

        JavaRDD<String> RDD1=jsc.parallelize(Arrays.asList("1","2","3","4","5","6","7","8","9"),6);// 并行化
        JavaRDD<String> RDD2=jsc.parallelize(Arrays.asList("A","B","C","D","E","F","G","H","J","1","2","3","4","5","6","7"),6);// 并行化

        PairFunction<String,String,String> keyData1=new PairFunction<String, String, String>() {
            @Override
            public Tuple2<String, String> call(String s) throws Exception {
                return new Tuple2<>(s.split(" ")[0],s);
            }
        };

        PairFunction<String,String,String> keyData2=new PairFunction<String, String, String>() {
            @Override
            public Tuple2<String, String> call(String s) throws Exception {
                return new Tuple2<>(s.split("")[0],s);
            }
        };

        JavaPairRDD<String,String> pairsRDD1=RDD1.mapToPair(keyData1);
        JavaPairRDD<String,String> parirsRDD2=RDD2.mapToPair(keyData2);

        System.out.println("pairsRDD1="+pairsRDD1.collect());
        System.out.println("pairsRDD2="+parirsRDD2.collect());
        System.out.println("pairsRDD1.subtractByKey(parirsRDD2).collect()="+pairsRDD1.subtractByKey(parirsRDD2).collect());
        System.out.println("pairsRDD1.join(parirsRDD2)="+pairsRDD1.join(parirsRDD2).collect());
        System.out.println("pairsRDD1.rightOuterJoin(parirsRDD2)="+pairsRDD1.rightOuterJoin(parirsRDD2).collect());
        System.out.println("pairsRDD1.leftOuterJoin(parirsRDD2)="+pairsRDD1.leftOuterJoin(parirsRDD2).collect());
        System.out.println("pairsRDD1.cogroup(parirsRDD2)="+pairsRDD1.cogroup(parirsRDD2).collect());


    }
}
执行结果:

pairsRDD1=[(1,1), (2,2), (3,3), (4,4), (5,5), (6,6), (7,7), (8,8), (9,9)]
pairsRDD2=[(A,A), (B,B), (C,C), (D,D), (E,E), (F,F), (G,G), (H,H), (J,J), (1,1), (2,2), (3,3), (4,4), (5,5), (6,6), (7,7)]

pairsRDD1.subtractByKey(parirsRDD2).collect()=[(8,8), (9,9)]

pairsRDD1.join(parirsRDD2)=[(6,(6,6)), (7,(7,7)), (1,(1,1)), (2,(2,2)), (3,(3,3)), (4,(4,4)), (5,(5,5))]

pairsRDD1.rightOuterJoin(parirsRDD2)=[(B,(Optional.absent(),B)), (6,(Optional.of(6),6)), (H,(Optional.absent(),H)), (7,(Optional.of(7),7)), (C,(Optional.absent(),C)), (1,(Optional.of(1),1)), (2,(Optional.of(2),2)), (J,(Optional.absent(),J)), (D,(Optional.absent(),D)), (3,(Optional.of(3),3)), (E,(Optional.absent(),E)), (4,(Optional.of(4),4)), (F,(Optional.absent(),F)), (G,(Optional.absent(),G)), (5,(Optional.of(5),5)), (A,(Optional.absent(),A))]


pairsRDD1.leftOuterJoin(parirsRDD2)=[(6,(6,Optional.of(6))), (7,(7,Optional.of(7))), (1,(1,Optional.of(1))), (8,(8,Optional.absent())), (2,(2,Optional.of(2))), (9,(9,Optional.absent())), (3,(3,Optional.of(3))), (4,(4,Optional.of(4))), (5,(5,Optional.of(5)))]


pairsRDD1.cogroup(parirsRDD2)=[(B,([],[B])), (6,([6],[6])), (H,([],[H])), (7,([7],[7])), (C,([],[C])), (1,([1],[1])), (8,([8],[])), (2,([2],[2])), (J,([],[J])), (D,([],[D])), (9,([9],[])), (3,([3],[3])), (E,([],[E])), (4,([4],[4])), (F,([],[F])), (G,([],[G])), (5,([5],[5])), (A,([],[A]))]


hb707934728
关注
专栏目录
3.9 Spark 键值对RDD编程
炫云云
03-30 730
感谢你的阅读，专栏文章持续更新，希望感兴趣的伙伴点个赞，关注不迷路！你的支持是我前进的动力！ 带你全面理解Spark大数据。 键值对RDD的创建 常用的键值对RDD转换操作 reduceByKey和groupByKey的区别 一个综合实例 深耕于机器学习算法、深度学习、数据分析等领域，希望我这微不足道的知识能帮到您。
Spark RDD(三) 键值对RDD相关的转换和动作操作
the_conquer_zzy的专栏
05-02 1483
Spark RDD(三) 键值对RDD相关的转换和动作操作 本篇文章主要介绍和key/value pair RDD相关的转换(transformation)和动作(action)操作。 键值对RDD和普通RDD不同，在普通RDD中，一行数据代表一个单独的值，比如一个整数或者一个字符串。 而键值对RDD中一行数据是一个元组，在元组中第一个元素是key值，第二个元素值vaule值。 key和value...
Spark系列五：键值对RDD
zqzwzd的博客
03-22 478
Spark系列四： 基本RDD----行动操作 键值对RDD通常用来进行聚合计算。 一般通过一些初试ETL（抽取、转化、装载）操作来将数据转化为键值对形式。
Python键值对是什么意思?
最新发布
oldboyedu1的博客
07-15 117
Python中的键值对是一种基本的数据结构，由一个键和一个与之对应的值组成。这种数据结构在计算机科学中广泛用于存储和组织数据，其中键用于唯一标识数据对，而值是与键相关联的数据。Python中的键值对是一种数据结构，它将一个键与一个值关联在一起。对象属性：表示对象的属性，例如用户字典中的{"name":"John","age":30}。值：与键关联的数据项，可以是任何Python对象，包括其他字典。键：唯一标识键值对的不可变对象，通常是字符串或数字。数据聚合：通过键聚合数据，例如统计每个类别的销售量。
Spark核心-键值对RDD
dhylanyu1的博客
07-21 168
Spark核心-键值对RDD概述Pair RDD并行化调优从分区中获益影响分区的操作 概述 键值对RDD一般通过初始化操作将数据转换成K-V形式，使用可控的分区方式把常被一起访问的数据放在同一个节点上，可以大大减少应用的通信开销。 Pair RDD 当从内存数据集创建pairRDD时，需要调用sparkContext.parallelizePairs 如{(1,2), (3,4), (3,6)} 函数 描述 注意 示例 reduceByKey 合并具有相同key的值 {(1,2), (3,
Spark入门（五）：键值对RDD
源码有毒的专栏
08-14 1124
1.创建PairRDD普通RDD转Pair RDD val rdd = sc.parallelize(Array("java","scala")) rdd.foreach(println) //java //scala val pairRdd = rdd.map(w => (w,"编程语言")) pairRdd.foreach(print) //(java,编程语言) //(scala,编程语言)2
Spark 键值对RDD的操作
晓晓的天空
03-11 1480
Spark 键值对RDD的操作
3.SparkCore-键值对RDD
weixin_44085996的博客
09-16 263
键值对 RDD 是 Spark 中许多操作所需要的常见数据类型。 本章做特别讲解。除了在基础RDD类中定义的操作之外，Spark 为包含键值对类型的 RDD 提供了一些专有的操作 在PairRDDFunctions专门进行了定义。这些 RDD 被称为 pair RDD。RDD当中非常常见的PairRDD，也叫做键值对RDD，可以理解成KVRDD。 有很多种方式创建pair RDD，在输入输出章节会讲解。一般如果从一个普通的RDD转 为pair RDD时，可以调用map()函数来实现，传递的函数需要返回键值
创建键值对RDD
一碗竹叶青的博客
10-30 792
键值对RDD的创建 第一种创建方式：从文件中加载（map函数实现） scala> val lines = sc.textFile("file:///usr/local/spark/mycode/pairrdd/word.txt") lines: org.apache.spark.rdd.RDD[String] = file:///usr/local/spark/mycode/pairrdd/word.txt MapPartitionsRDD[1] at textFile at <conso
3. 键值对RDD
weixin_30666753的博客
07-08 235
　　　　　　键值对RDD是Spark中许多操作所需要的常见数据类型。除了在基础RDD类中定义的操作之外，Spark为包含键值对类型的RDD提供了一些专有的操作在PairRDDFunctions专门进行了定义。这些RDD被称为pairRDD 　　　　　　有很多中方式创建pairRDD，一般如果从一个普通的RDD转为pairRDD时，可以调用map()函数来实现，传递的函数需要返回键值对 va...
键值对RDD的创建方式
NON blog
09-06 1189
键值对RDD是对Spark中许多操作所需要的常见数据类型，通常用于聚合计算。先通过ETL（抽取，转换，装载）操作来将数据转化为键值对形式。 1.创建Pair RDD 在scala中使用第一个单词作为key，创建一个pairRDD val lines=sc.textFile("input/1.txt") val pairs = lines.map(x => (x.split(" ")
spark之键值对RDD
霜叶的博客
10-01 910
1、键值对RDD生成方式 1.1、通过map函数来生成 通过map函数将x映射为(x,1) #在本地进行操作 textFile = sc.textFile("file:///home/jsy/spark_test/test.txt") wordCount = textFile.flatMap(lambda line: line.split(" ")).map(lambda x:(x,1)) 2、常用键值对转换方式 常用的键值对转换操作包括reduceByKey()、groupByKey()、so
Spark【RDD编程（三）键值对RDD的创建、转换操作】
功不唐捐，玉汝于成
09-05 1584
键值对RDD常用的键值对RDD转换操作
大数据——Spark RDD算子（四）创建键值对RDD mapToPair、flatMapToPair
蜂蜜柚子加苦茶
11-05 454
大数据——Spark RDD算子（四）创建键值对RDD mapToPair、flatMapToPair示例文件mapToPairScala版本Java版本flatMapToPairScala版本Java版本，Spark2.0以上 示例文件 在同级目录下有一个文件夹in，文件夹in下有一个sample.txt，内容如下 aa bb cc aa aa aa dd dd ee ee ee ee ff aa bb zks ee kks ee zz zks mapToPair Scala版本 Scala中是
键值对操作
BGoodHabit的博客
11-22 1760
目录1 Pair RDD2 创建Pair RDD3 Pair RDD的转化操作 1 Pair RDD 键值对RDD是Spark中许多操作所需要的常见数据类型。spark为包含键值对类型的RDD提供了一些专有的操作，这些RDD被称为pair RDD。比如，pair RDD提供reduceByKey()方法，可以分别归约每个键对应的数据。 在spark中有很多种创建pair RDD的方式，比如很多存储键值对的数据格式会在读取时直接返回由其健值对数据组成的pair RDD。此外，当需要把一个普通的RDD转为pai
RDD的5大特点
Mercy007的博客
01-08 8131
1）有一个分片列表，就是能被切分，和Hadoop一样，能够切分的数据才能并行计算。 一组分片（partition），即数据集的基本组成单位，对于RDD来说，每个分片都会被一个计算任务处理，并决定并行计算的粒度。用户可以在创建RDD时指定RDD的分片个数，如果没有指定，那么就会采用默认值。默认值就是程序所分配到的CPU Core的数目。每个分配的存储是由BlockManager实现的，每个分区
键值对RDD的特点和作用有哪些
05-31
键值对RDD是指将数据集中的每个元素看作是一个键值对的形式来存储和处理的RDD。它的特点和作用如下： 1. 适用范围广：键值对RDD可以用于广泛的场景中，如数据聚合、连接、分组、排序等。 2. 数据划分更加灵活：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值