スパークエントリー（7） - 交差点、減算、労働組合とdistincのスパーク

その他 2020-01-12 02:17:57 訪問数: null

交差点のスパーク

交差点の名前は、彼がクロスを指し、示唆しています。2は、RDDの交差点だったとき、それは両方に共通のままになります。したがってRDD1.intersection（RDD2）とRDD2.intersection（RDD1）のために。それは一貫している必要があります。

例えば、リスト1 = {1,2,3,4,5}とリスト1 = {3,4,5,6,7}、RDDは、リストの両方が含まれているため、それらがなければならない交差点結果一度= {3,4,5}

スパークの減算

減算との交点が異なっている、彼は2間の不整合を発見するコンテンツです。

例えば、リスト1 = {1,2,3,4,5}、それらはリスト1 = {3,4,5,6,7}は減算結果を関連配列で得られます。

list1.subtract(list2)

結果がでなければなりません

1 2

以下のために

list2.subtract(list1)

結果がでなければなりません

6 7

労働組合のスパーク

組合が最もよく理解され、彼は重複に関係なく、2つのRDDを統合することです。例えば、リスト1 = {1,2,3,4,5}およびそれらのList1 = {3,4,5,6,7}組合順序で得られた結果は無関係で一度。結果がでなければなりません

result = {1,2,3,4,5,3,4,5,6,7}

明確なのスパーク

distinc RDDは削除重複コンテンツ、この淘汰プロセスが重複していない要素が削除されていることに注意してくださいですが、唯一の重複要素を保持します。これは、もちろんよく、このような結果は、= {1,2,3,4,5,3,4,5,6,7}は、DISTINCTと、{1,2,3,4,5,6を得られることが理解されます7}

総合的な例

交差点、減算、組合別個より一般的に考慮すると、1つの場合に、その特性を十分に反映することができます。我々は、このデータセットを取得するように、2つのコース、lesson1とlesson2です。10の学生がありますlesson1、各学生は、多くの評価の能力を持って、評価は、データ型intです。同様でlesson2。二つのデータのためにセットがでlesson1とlesson2に私の中に入れました。データセットと次のコードは、にすることができgithubのの検索とダウンロード。

データセットの分析

lesson1のために、何回も各学生の評価に能力があり、多くの学生があります。でスパークエントリ（6） - combineByKeyのスパーク、sortBykeyはすでにので、この取引をしない、ポイントを平均し一人一人のスコアに言及しました。

我々は、次の質問に対処し、これら二つのデータセット：

  • 各学生の総評価額の0、計算lesson1とlesson2能力
  • すべての生徒lesson1見つけるための1、（繰り返しません）
  • 2、すべての学生（ないリピート）lesson2見つけます
  • 3、検索する学生は2つのコースを選択しました
  • 4、lesson2でlesson1の学生を識別するだけでなく、
  • 5、lesson1でlesson2の学生を識別するだけでなく、

データショーの一部

 

 

最初の質問については0、コンテンツがこのセクションで使用されていないので、したがって、標識された0。総評価額は、各コースの各学生の能力を必要とし、我々は最初のデータを処理しなければならない、スペース分割を押してください。次いで、データを分割タプルの（名前、分数）、名前によって累積スコアでなければなりません。

  • 最初の質問は限り各学生の総評価額が得点を除去する能力を得たとして、あなたはlesson1学生のすべてを知ることができ、すべての学生lesson1見つけるします。

  • 2番目の質問と同じ方法。

  • 学生は2つのコースを選んだ見つけるために3番目の質問、統合後はすべての学生のための2つのクラスがあり、重複データを排除し、あること、最初の労働組合その後、distincます

  • 第四の質問へは、II lesson1見つけていない授業で学生、限りlesson1の学生とlesson2学生がsubstractを実施します

  • 同様に第五のタイトル

達成SCALA


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

object SparkIntersectionAndSubtract {

  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setMaster("local").setAppName("SparkIntersectionAndSubtract")

    val sc = new SparkContext(conf)

    //课程一中的数据
    val lesson1Data = sc.textFile("./lesson1").map(line => (line.split(" ")(0),line.split(" ")(1).toInt)) //将课程一中每个人的分数相加 val lesson1Grade = lesson1Data.reduceByKey(_+_) val lesson1Student = lesson1Grade.map(x=>x._1) //课程二中的数据处理 val lesson2Data = sc.textFile("./lesson2").map(line => (line.split(" ")(0),line.split(" ")(1).toInt)) //将课程二中每个人的分数相加 val lesson2Grade = lesson2Data.reduceByKey((x,y)=>x+y) val lesson2Student = lesson2Grade.map(x=>x._1) //在课程一中的人且在课程二中的人的集合 println("Students On Lesson1 And On Lesson2") lesson1Student.intersection(lesson2Student).foreach(println) //在课程二中的人且在课程一中的人的集合，与上面的结果一致 println("Students On Lesson1 And On Lesson2") lesson2Student.intersection(lesson1Student).foreach(println) //在课程一中的人但不在课程二中的人的集合 println("Students Only In Lesson1") val onlyInLesson1 = lesson1Student.subtract(lesson2Student) onlyInLesson1.foreach(println) //在课程二中的人但不在课程二中的人的集合 println("Students Only In Lesson2") val onlyInLesson2 = lesson2Student.subtract(lesson1Student) onlyInLesson2.foreach(println) //只选了一门课的同学 println("Students Only Choose One Lesson") lesson1Student.union(lesson2Student).foreach(println) //两门课所有学生（不重复） println("All the students") lesson1Student.union(lesson2Student).distinct().foreach(print) } }

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.Function;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;

public class SparkIntersectionAndSubtractJava {

    public static void main(String[] args){

        SparkConf conf = new SparkConf().setMaster("local").setAppName("SparkIntersectionAndSubtractJava");

        JavaSparkContext sc = new JavaSparkContext(conf);

        //java7实现
        intersectionAndSubtractJava(sc);

        //java8实现
        intersectionAndSubtractJava8(sc);
    }


    public static void intersectionAndSubtractJava(JavaSparkContext sc){

        JavaRDD<String> lesson1Data = sc.textFile("./lesson1");

        JavaRDD<String> lesson2Data = sc.textFile("./lesson2");

        JavaPairRDD<String,Integer> lesson1InfoData = lesson1Data.mapToPair(new PairFunction<String, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(String s) throws Exception {
                return new Tuple2<>(s.split(" ")[0],Integer.parseInt(s.split(" ")[1])); } }); JavaPairRDD<String,Integer> lesson2InfoData = lesson2Data.mapToPair(new PairFunction<String, String, Integer>() { @Override public Tuple2<String, Integer> call(String s) throws Exception { return new Tuple2<>(s.split(" ")[0],Integer.parseInt(s.split(" ")[1])); } }); JavaPairRDD<String,Integer> lesson1Grades = lesson1InfoData.reduceByKey(new Function2<Integer, Integer, Integer>() { @Override public Integer call(Integer integer, Integer integer2) throws Exception { return integer+integer2; } }); JavaPairRDD<String,Integer> lesson2Grades = lesson2InfoData.reduceByKey(new Function2<Integer, Integer, Integer>() { @Override public Integer call(Integer integer, Integer integer2) throws Exception { return integer+integer2; } }); JavaRDD<String> lesson1Students = lesson1Grades.map(new Function<Tuple2<String, Integer>, String>() { @Override public String call(Tuple2<String, Integer> stringIntegerTuple2) throws Exception { return stringIntegerTuple2._1; } }); JavaRDD<String> lesson2Students = lesson2Grades.map(new Function<Tuple2<String, Integer>, String>() { @Override public String call(Tuple2<String, Integer> stringIntegerTuple2) throws Exception { return stringIntegerTuple2._1; } }); //既在lesson1中又在lesson2中的学生 System.out.println("Students On Lesson1 And On Lesson2"); lesson1Students.intersection(lesson2Students).foreach(new VoidFunction<String>() { @Override public void call(String s) throws Exception { System.out.println(s); } }); //既在lesson2中又在lesson1中的学生，与上面的结果一致 System.out.println("Students On Lesson1 And On Lesson2"); lesson2Students.intersection(lesson1Students).foreach(new VoidFunction<String>() { @Override public void call(String s) throws Exception { System.out.println(s); } }); //只在lesson1中而不在lesson2中的学生 JavaRDD<String> studensOnlyInLesson1 = lesson1Students.subtract(lesson2Students); System.out.println("Students Only In Lesson1"); lesson1Students.subtract(lesson2Students).foreach(new VoidFunction<String>() { @Override public void call(String s) throws Exception { System.out.println(s); } }); //只在lesson2中而不在lesson1中的学生 JavaRDD<String> studensOnlyInLesson2 = lesson2Students.subtract(lesson1Students); System.out.println("Students Only In Lesson2"); studensOnlyInLesson2.foreach(new VoidFunction<String>() { @Override public void call(String s) throws Exception { System.out.println(s); } }); //只选了一门课的学生 JavaRDD<String> onlyOneLesson = studensOnlyInLesson1.union(studensOnlyInLesson2); System.out.println("Students Only Choose One Lesson"); onlyOneLesson.foreach(new VoidFunction<String>() { @Override public void call(String s) throws Exception { System.out.println(s); } }); System.out.println("All the students"); lesson1Students.union(lesson2Students).distinct().foreach(new VoidFunction<String>() { @Override public void call(String s) throws Exception { System.out.println(s); } }); } public static void intersectionAndSubtractJava8(JavaSparkContext sc){ JavaRDD<String> lesson1Data = sc.textFile("./lesson1"); JavaRDD<String> lesson2Data = sc.textFile("./lesson2"); JavaPairRDD<String,Integer> lesson1InfoData = lesson1Data.mapToPair(line -> new Tuple2<>(line.split(" ")[0],Integer.parseInt(line.split(" ")[1]))); JavaPairRDD<String,Integer> lesson2InfoData = lesson2Data.mapToPair(line -> new Tuple2<>(line.split(" ")[0],Integer.parseInt(line.split(" ")[1]))); JavaPairRDD<String,Integer> lesson1Grades = lesson1InfoData.reduceByKey((x,y) -> x+y); JavaPairRDD<String,Integer> lesson2Grades = lesson2InfoData.reduceByKey((x,y) -> x+y); JavaRDD<String> studentsInLesson1 = lesson1Grades.map(x->x._1); JavaRDD<String> studentsInLesson2 = lesson2Grades.map(x->x._1); //既在lesson1中又在lesson2中的学生 studentsInLesson1.intersection(studentsInLesson2).foreach(name -> System.out.println(name)); //既在lesson2中又在lesson1中的学生，与上面的结果一致 studentsInLesson1.intersection(studentsInLesson2).foreach(name -> System.out.println(name)); //只在lesson1中的学生 JavaRDD<String> studentsOnlyInLesson1 = studentsInLesson1.subtract(studentsInLesson2); studentsOnlyInLesson1.foreach(name -> System.out.println(name)); //只在lesson2中的学生 JavaRDD<String> studentsOnlyInLesson2 = studentsInLesson2.subtract(studentsInLesson1); studentsOnlyInLesson2.foreach(name -> System.out.println(name)); //只选了一门课的学生 JavaRDD<String> studentsOnlyOneLesson = studentsOnlyInLesson1.union(studentsInLesson2); studentsOnlyOneLesson.foreach(name -> System.out.println(name)); studentsInLesson1.union(studentsInLesson2).distinct().foreach(name -> System.out.println(name)); } }

python实现

from pyspark import SparkConf,SparkContext

conf = SparkConf().setMaster("local").setAppName("SparkCombineByKey")

sc = SparkContext(conf=conf)

#lesson1数据
lesson1Data = sc.textFile("./lesson1").map(lambda x:(x.split(" ")[0],int(x.split(" ")[1]))) #lesson2数据 lesson2Data = sc.textFile("./lesson2").map(lambda x:(x.split(" ")[0],int(x.split(" ")[1]))) #lesson1中每个人的总分 lesson1InfoData = lesson1Data.reduceByKey(lambda x,y:x+y) #lesson2中每个人的总分 lesson2InfoData = lesson2Data.reduceByKey(lambda x,y:x+y) #lesson1中的学生 studentsInLesson1 = lesson1InfoData.map(lambda x:x[0]) #lesson2中的学生 studentsInLesson2 = lesson2InfoData.map(lambda x:x[0]) #在lesson1中且在lesson2中的学生 print("Students On Lesson1 And On Lesson2") studentsInLesson1.intersection(studentsInLesson2).foreach(print) #在lesson2中且在lesson1中的学生，与上面的结果一致 print("Students On Lesson1 And On Lesson2") studentsInLesson2.intersection(studentsInLesson1).foreach(print) #只在lesson1中的学生 print("Students Only In Lesson1") studensOnlyInLesson1 = studentsInLesson1.subtract(studentsInLesson2) studensOnlyInLesson1.foreach(print) #只在lesson2中的学生 print("Students Only In Lesson2") studensOnlyInLesson2 = studentsInLesson2.subtract(studentsInLesson1) studensOnlyInLesson2.foreach(print) #只选了一门课的学生 print("Students Only Choose One Lesson") studensOnlyInLesson1.union(studensOnlyInLesson2).foreach(print) #两门课所有学生（不重复） print("All the students") studentsInLesson1.union(studentsInLesson2).distinct().foreach(print)

运行得到结果

Students On Lesson1 And On Lesson2
Vicky
Amy
Lili
Bob
Coco

Students On Lesson1 And On Lesson2
Vicky
Amy
Lili
Coco
Bob

Students Only In Lesson1
Bill
David
Mike
Nancy
Lucy

Students Only In Lesson2
White
Jimmy
Jason
John
Frank

Students Only Choose One Lesson
Bill
David
Mike
Nancy
Lucy
White
Jimmy
Jason
John
Frank

All the students
Vicky
Bill
Amy
White
Jimmy
Jason
Lili
David
Bob
Mike
Coco
Nancy
Lucy
John
Frank

 

 

通过上面的例子，非常具体地应用了intersection、subtract、union和distinct来解决具体的问题。并且利用好这几个方法能够很快速地进行一些数据集之间的关系操作。事实上，直接利用这几种方法比我们自己动手实现要好很多，因为spark中对这几种方法进行了优化。

数据集和代码均可以在github上找到并下载



转自：https://juejin.im/post/5c7b92276fb9a049bb7d0d10

おすすめ

転載: www.cnblogs.com/tjp40922/p/12181639.html
おすすめ
Open Source Daily | Altman's Seven Deadly Sins、Microsoft Bing が世界的にダウン、PostgreSQL 17 を段階的に廃止。
ランキング
JSは、テキストファイルを変更するJava
Linux の共通手順 (概要)
iOS用アニメーション
自分で書いた愚かなXロジック
dockerが実行できない理由
kubernetesは、削除ノードの再起動を追加します
＃2485.党（カンプ）
SYSAUX表スペース統計データの異常成長が自動的にクリーンアップではありません
githubのは、リモートリモートリポジトリエラーGitリポジトリorgin追加します
Ubuntuのアップデート
アーカイブ
もっと
2024-05-24(11)
2024-05-23(35)
2024-05-22(9)
2024-05-21(36)
2024-05-20(5)
2024-05-19(0)
2024-05-18(30)
2024-05-17(6)
2024-05-16(24)
2024-05-15(5)

コードワールド

© 2018 codetd.com