RDD以及其特点

1、RDD是Spark提供的核心抽象，全称为Resillient Distributed Dataset，即弹性分布式数据集。
2、RDD在抽象上来说是一种元素集合，包含了数据。它是被分区的，分为多个分区，每个分区分布在集群中的不同节点上，从而让RDD中的数据可以被并行操作。（分布式数据集）
3、RDD通常通过Hadoop上的文件，即HDFS文件或者Hive表，来进行创建；有时也可以通过应用程序中的集合来创建。
4、RDD最重要的特性就是，提供了容错性，可以自动从节点失败中恢复过来。即如果某个节点上的RDD partition，因为节点故障，导致数据丢了，那么RDD会自动通过自己的数据来源重新计算该partition。这一切对使用者是透明的。
5、RDD的数据默认情况下存放在内存中的，但是在内存资源不足时，Spark会自动将RDD数据写入磁盘。（弹性）

要使用Spark，开发者需要编写一个Driver程序，它被提交到集群以调度运行Worker，如下图所示。
Driver中定义了一个或多个RDD，并调用RDD上的action；
Worker则执行RDD分区计算任务。

master：集群主节点；
worker：集群从节点；
Dirver： 驱动器节点；
Executor：执行器节点；

WorldCount实列

统计文件如下：

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.FlatMapFunction;
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;
import java.util.Arrays;
public class WordCountLocal_3 {
    public static void main(String[] args) {
        //编写Spark应用程序本地执行
        //第一步：创建SparkConf对象，设置Spark的应用信息
        //使用setMaster设置Spark应用程序要链接的集群master的url，
        //local代表本地运行
        SparkConf conf = new SparkConf()
                .setAppName("WordCountLocal_3")
                .setMaster("local");


        // 第二步：创建JavaSparkContext对象
        // 在Spark中，SparkContext是Spark所有功能的一个入口，你无论是用java、scala，甚至是python编写
        // 都必须要有一个SparkContext，它的主要作用，包括初始化Spark应用程序所需的一些核心组件，包括
        // 调度器（DAGSchedule、TaskScheduler），还会去到Spark Master节点上进行注册，等等
        // 一句话，SparkContext，是Spark应用中，可以说是最最重要的一个对象
        // 但是呢，在Spark中，编写不同类型的Spark应用程序，使用的SparkContext是不同的，如果使用scala，
        // 使用的就是原生的SparkContext对象
        // 但是如果使用Java，那么就是JavaSparkContext对象
        // 如果是开发Spark SQL程序，那么就是SQLContext、HiveContext
        // 如果是开发Spark Streaming程序，那么就是它独有的SparkContext
        // 以此类推
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 第三步：要针对输入源（hdfs文件、本地文件，等等），创建一个初始的RDD
        // 输入源中的数据会打散，分配到RDD的每个partition中，从而形成一个初始的分布式的数据集
        // 我们这里呢，因为是本地测试，所以呢，就是针对本地文件
        // SparkContext中，用于根据文件类型的输入源创建RDD的方法，叫做textFile()方法
        // 在Java中，创建的普通RDD，都叫做JavaRDD
        // 在这里呢，RDD中，有元素这种概念，如果是hdfs或者本地文件呢，创建的RDD，每一个元素就相当于
        // 是文件里的一行

        /*有几个事项是需要注意的：
        1、如果是针对本地文件的话，如果是在windows上本地测试，windows上有一份文件即可；如果是在spark集群上针对linux本地文件，那么需要将文件拷贝到所有worker节点上。
        2、Spark的textFile()方法支持针对目录、压缩文件以及通配符进行RDD创建。
        3、Spark默认会为hdfs文件的每一个block创建一个partition，但是也可以通过textFile()的第二个参数手动设置分区数量，只能比block数量多，不能比block数量少*/


        /*Spark的textFile()除了可以针对上述几种普通的文件创建RDD之外，还有一些特列的方法来创建RDD：

        1、SparkContext.wholeTextFiles()方法，可以针对一个目录中的大量小文件，返回<filename, fileContent>组成的pair，作为一个PairRDD，而不是普通的RDD。普通的textFile()返回的RDD中，每个元素就是文件中的一行文本。
        2、SparkContext.sequenceFile[K, V]()方法，可以针对SequenceFile创建RDD，K和V泛型类型就是SequenceFile的key和value的类型。K和V要求必须是Hadoop的序列化类型，比如IntWritable、Text等。
        3、SparkContext.hadoopRDD()方法，对于Hadoop的自定义输入类型，可以创建RDD。该方法接收JobConf、InputFormatClass、Key和Value的Class。
        4、SparkContext.objectFile()方法，可以针对之前调用RDD.saveAsObjectFile()创建的对象序列化的文件，反序列化文件中的数据，并创建一个RDD。*/
        JavaRDD<String> lines = sc.textFile("D:\\eclipse\\wc\\scalaworid\\spark.txt");


        // 第四步：对初始RDD进行transformation操作，也就是一些计算操作
        // 通常操作会通过创建function，并配合RDD的map、flatMap等算子来执行
        // function，通常，如果比较简单，则创建指定Function的匿名内部类
        // 但是如果function比较复杂，则会单独创建一个类，作为实现这个function接口的类

        // 先将每一行拆分成单个的单词
        // FlatMapFunction，有两个泛型参数，分别代表了输入和输出类型
        // 我们这里呢，输入肯定是String，因为是一行一行的文本，输出，其实也是String，因为是每一行的文本切分后的单词
        // 这里先简要介绍flatMap算子的作用，其实就是，将RDD的一个元素，给拆分成一个或多个元素

        JavaRDD<String> worlds = lines.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public Iterable<String> call(String line) throws Exception {
                return Arrays.asList(line.split(" "));
            }
        });

        // 接着，需要将每一个单词，映射为(单词, 1)的这种格式
        // 因为只有这样，后面才能根据单词作为key，来进行每个单词的出现次数的累加
        // mapToPair，其实就是将每个元素，映射为一个(v1,v2)这样的Tuple2类型的元素
        // 如果大家还记得scala里面讲的tuple，那么没错，这里的tuple2就是scala类型，包含了两个值
        // mapToPair这个算子，要求的是与PairFunction配合使用，第一个泛型参数代表了输入类型
        // 第二个和第三个泛型参数，代表的输出的Tuple2的第一个值和第二个值的类型
        // JavaPairRDD的两个泛型参数，分别代表了tuple元素的第一个值和第二个值的类型

        JavaPairRDD<String, Integer> pairs = worlds.mapToPair(new PairFunction<String, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(String word) throws Exception {
                return new Tuple2<String, Integer>(word, 1);
            }
        });

        // 接着，需要以单词作为key，统计每个单词出现的次数
        // 这里要使用reduceByKey这个算子，对每个key对应的value，都进行reduce操作
        // 比如JavaPairRDD中有几个元素，分别为(hello, 1) (hello, 1) (hello, 1) (world, 1)
        // reduce操作，相当于是把第一个值和第二个值进行计算，然后再将结果与第三个值进行计算
        // 比如这里的hello，那么就相当于是，首先是1 + 1 = 2，然后再将2 + 1 = 3
        // 最后返回的JavaPairRDD中的元素，也是tuple，但是第一个值就是每个key，第二个值就是key的value
        // reduce之后的结果，相当于就是每个单词出现的次数
        JavaPairRDD<String, Integer> wordcounts = pairs.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });

        // 到这里为止，我们通过几个Spark算子操作，已经统计出了单词的次数
        // 但是，之前我们使用的flatMap、mapToPair、reduceByKey这种操作，都叫做transformation操作
        // 一个Spark应用中，光是有transformation操作，是不行的，是不会执行的，必须要有一种叫做action
        // 接着，最后，可以使用一种叫做action操作的，比如说，foreach，来触发程序的执行
        wordcounts.foreach(new VoidFunction<Tuple2<String, Integer>>() {
            @Override
            public void call(Tuple2<String, Integer> t) throws Exception {
                System.out.println(t._1 + ":" + t._2);
            }
        });
    }
}

部分结果如下：

scala编写

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

object Wordcount {

  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setAppName("Wordcount")
      .setMaster("local")

    val sc = new SparkContext(conf)

    val lines: RDD[String] = sc.textFile("E:\\sparktext\\spark.txt")

    val worlds: RDD[String] = lines.flatMap(_.split(" "))

    //worlds.map((world:String) => (world,1))
    val worldAndOne: RDD[(String, Int)] = worlds.map((_,1))

    //worldAndOne.reduceByKey((v1:Int,v2:Int) => v1 + v2)
    //worldAndOne.reduceByKey( v1 + v2)
    val worldCount: RDD[(String, Int)] = worldAndOne.reduceByKey( _ + _)

    val unit: Unit = worldCount.foreach(wc => println(wc._1 + ":" + wc._2))
    //worldCount.foreach(println)


    
  }
}

scala一行代码

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

object Wordcount {

  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setAppName("Wordcount")
      .setMaster("local")

    val sc = new SparkContext(conf)
sc.textFile("E:\\sparktext\\spark.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).foreach(println)
  }
}

RDD创建

进行Spark核心编程时，首先要做的第一件事，就是创建一个初始的RDD。该RDD中，通常就代表和包含了Spark应用程序的输入源数据。然后在创建了初始的RDD之后，才可以通过Spark Core提供的transformation算子，对该RDD进行转换，来获取其他的RDD。

Spark Core提供了三种创建RDD的方式，包括：使用程序中的集合创建RDD；使用本地文件创建RDD；使用HDFS文件创建RDD。

个人理解
1、使用程序中的集合创建RDD，主要用于进行测试，可以在实际部署到集群运行之前，自己使用集合构造测试数据，来测试后面的spark应用的流程。
2、使用本地文件创建RDD，主要用于临时性地处理一些存储了大量数据的文件。
3、使用HDFS文件创建RDD，应该是最常用的生产环境处理方式，主要可以针对HDFS上存储的大数据，进行离线批处理操作。

并行化集合创建RDD

如果要通过并行化集合来创建RDD，需要针对程序中的集合，调用SparkContext。parallelize()方法。Spark会将集合中的数据拷贝到集群上去，形成一个分布式的数据集合，也就是一个RDD。相当于是，集合中的部分数据会到一个节点上，而另一部分数据会到其他节点上。然后就可以用并行的方式来操作这个分布式数据集合，即RDD。

// 案例：1到10累加求和
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val rdd = sc.parallelize(arr)
    val sum = rdd.reduce(_ + _)

调用parallelize()时，有一个重要的参数可以指定，就是要将集合切分成多少个partition。Spark会为每一个partition运行一个task来进行处理。Spark官方的建议是，为集群中的每个CPU创建2~4个partition。Spark默认会根据集群的情况来设置partition的数量。但是也可以在调用parallelize()方法时，传入第二个参数，来设置RDD的partition数量。比如parallelize(arr, 10)

扫描二维码关注公众号，回复： 7573583 查看本文章

使用本地文件和HDFS创建RDD

Spark是支持使用任何Hadoop支持的存储系统上的文件创建RDD的，比如说HDFS、Cassandra、HBase以及本地文件。通过调用SparkContext的textFile()方法，可以针对本地文件或HDFS文件创建RDD。

有几个事项是需要注意的：
1、如果是针对本地文件的话，如果是在windows上本地测试，windows上有一份文件即可；如果是在spark集群上针对linux本地文件，那么需要将文件拷贝到所有worker节点上。
2、Spark的textFile()方法支持针对目录、压缩文件以及通配符进行RDD创建。
3、Spark默认会为hdfs文件的每一个block创建一个partition，但是也可以通过textFile()的第二个参数手动设置分区数量，只能比block数量多，不能比block数量少。

import org.apache.spark.SparkConf;
import org.apache.spark.SparkContext;
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;


/**
 *  * 案例：统计文本文件字数
 */
public class LocalFile_5 {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf()
                .setMaster("local")
                .setAppName("LocalFile_5");

        JavaSparkContext sc = new JavaSparkContext(conf);

        // 使用SparkContext以及其子类的textFile()方法，针对本地文件创建RDD

        JavaRDD<String> Length = sc.textFile("D:\\eclipse\\wc\\scalaworid\\spark.txt");

        final JavaRDD<Integer> lines = Length.map(new Function<String, Integer>() {
            @Override
            public Integer call(String line) throws Exception {
                return line.length();
            }
        });

        Integer count = lines.reduce(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });
        System.out.println("文件出现单词的总数： " + count);
        sc.close();
    }
}

Spark的textFile()除了可以针对上述几种普通的文件创建RDD之外，还有一些特列的方法来创建RDD：

1、SparkContext.wholeTextFiles()方法，可以针对一个目录中的大量小文件，返回<filename, fileContent>组成的pair，作为一个PairRDD，而不是普通的RDD。普通的textFile()返回的RDD中，每个元素就是文件中的一行文本。
2、SparkContext.sequenceFileK, V方法，可以针对SequenceFile创建RDD，K和V泛型类型就是SequenceFile的key和value的类型。K和V要求必须是Hadoop的序列化类型，比如IntWritable、Text等。
3、SparkContext.hadoopRDD()方法，对于Hadoop的自定义输入类型，可以创建RDD。该方法接收JobConf、InputFormatClass、Key和Value的Class。
4、SparkContext.objectFile()方法，可以针对之前调用RDD.saveAsObjectFile()创建的对象序列化的文件，反序列化文件中的数据，并创建一个RDD。

transformation和action介绍

Spark支持两种RDD操作：transformation和action。transformation操作会针对已有的RDD创建一个新的RDD；而action则主要是对RDD进行最后的操作，比如遍历、reduce、保存到文件等，并可以返回结果给Driver程序。

例如，map就是一种transformation操作，它用于将已有RDD的每个元素传入一个自定义的函数，并获取一个新的元素，然后将所有的新元素组成一个新的RDD。而reduce就是一种action操作，它用于对RDD中的所有元素进行聚合操作，并获取一个最终的结果，然后返回给Driver程序。

transformation的特点就是lazy特性。lazy特性指的是，如果一个spark应用中只定义了，transformation操作，那么即使你执行该应用，这些操作也不会执行。也就是说，transformation是不会触发spark程序的执行的，它们只是记录了对RDD所做的操作，但是不会自发的执行。只有当transformation之后，接着执行了一个action操作，那么所有的transformation才会执行。Spark通过这种lazy特性，来进行底层的spark应用执行的优化，避免产生过多中间结果。

action操作执行，会触发一个spark job的运行，从而触发这个action之前所有的transformation的执行。这是action的特性。

常用transformation介绍

常用action介绍

常用transformation操作

map算子

import org.apache.spark.SparkConf;
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.VoidFunction;

import java.util.Arrays;
import java.util.List;

public class Transfromationa {
    public static void main(String[] args) {
        mymap();

    }
    /**
     * map算子：对每一个元素*2
     */
    private static void mymap(){
        SparkConf conf = new SparkConf()
                .setAppName("mymap")
                .setMaster("local");

        JavaSparkContext sc = new JavaSparkContext(conf);

        //构建集合
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        //并行化集合，初始RDD
        JavaRDD<Integer> numberRDD = sc.parallelize(list);
        JavaRDD<Integer> map = numberRDD.map(new Function<Integer, Integer>() {
            @Override
            public Integer call(Integer integer) throws Exception {
                return integer * 2;
            }
        });

        // 打印新的RDD中的内容
        map.foreach(new VoidFunction<Integer>() {
            @Override
            public void call(Integer integer) throws Exception {
                System.out.println(integer);
            }
        });
    }
}

filter算子

public class Transfromationa {
    public static void main(String[] args) {
        //mymap();
        myFileter();
    }
 /**
     * filter算子函数：过滤集合总的偶数
     */

    private static void myFileter(){
        SparkConf conf = new SparkConf()
                .setMaster("local")
                .setAppName("myFileter");
        //创建SparkContext
        JavaSparkContext sc = new JavaSparkContext(conf);

        //模拟集合
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 12);

        //并行化集合，初始化RDD
        JavaRDD<Integer> numberRDD = sc.parallelize(numbers);

        JavaRDD<Integer> filter = numberRDD.filter(new Function<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) throws Exception {
                return integer % 2 == 0;
            }
        });
        filter.foreach(new VoidFunction<Integer>() {
            @Override
            public void call(Integer integer) throws Exception {
                System.out.println(integer);
            }
        });
 		sc.close();
    }
}

flapMap算子

public class Transfromationa {
    public static void main(String[] args) {
        //mymap();
        //myFileter();
        myFlatMap();
    }
/**
     * flapMap案例：将文本拆分成多个单词
     */
    private static void myFlatMap(){
        SparkConf conf = new SparkConf()
                .setAppName("myFlatMap")
                .setMaster("local");

        JavaSparkContext sc = new JavaSparkContext(conf);
        //模拟集合
        List<String> list = Arrays.asList("hello tom", "hello word", "hello kangkang");
        JavaRDD<String> linesRDD = sc.parallelize(list);

        // 对RDD执行flatMap算子，将每一行文本，拆分成多个单词
        // flatMap算子，在java中，接受的参数是flatMapFunction
        // 我们需要自己定义FlatMapFunction的第二个泛型类型，即，代表了返回的新元素的类型
        // call()方法，返回类型，不是Object。而是Iterable<Object>,这里的Object也与第二个泛型类型相同
        // flatMap其实就是，接受原始RDD中的每个元素，并进行各种逻辑计算和处理。返回多个元素
        // 多个元素，即封装在Iterable中，可以使用ArrayList等集合
        JavaRDD<String> stringJavaRDD = linesRDD.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public Iterable<String> call(String s) throws Exception {
                return Arrays.asList(s.split(" "));
            }
        });
        stringJavaRDD.foreach(new VoidFunction<String>() {
            @Override
            public void call(String s) throws Exception {
                System.out.println(s);
            }
        });
        sc.close();
    }

groupByKey算子

public class Transfromationa {
    public static void main(String[] args) {
        //mymap();
        //myFileter();
        //myFlatMap();
        myGroupByKey();

    }


    /**
     * groupByKey案例：安装班级对成绩进行分类
     */
    private static void myGroupByKey(){
        SparkConf conf = new SparkConf()
                .setMaster("local")
                .setAppName("myGroupByKey");

        JavaSparkContext sc = new JavaSparkContext(conf);

        List<Tuple2<String,Integer>> objects = Arrays.asList(
                new Tuple2<String, Integer>("class1",72),
                new Tuple2<String, Integer>("class2",67),
                new Tuple2<String, Integer>("class1",89),
                new Tuple2<String, Integer>("class2",45)
        );

        JavaPairRDD<String, Integer> groupByscoure = sc.parallelizePairs(objects);

        final JavaPairRDD<String, Iterable<Integer>> scores = groupByscoure.groupByKey();

        scores.foreach(new VoidFunction<Tuple2<String, Iterable<Integer>>>() {
            @Override
            public void call(Tuple2<String, Iterable<Integer>> tuple2) throws Exception {
                System.out.println("班级：" + tuple2._1);
                Iterator<Integer> iterator = tuple2._2.iterator();
                while (iterator.hasNext()){
                    System.out.println(iterator.next());
                }
                System.out.println("------------");
            }
        });
        sc.close();
    }

reduceByKey算子

public class Transfromationa {
    public static void main(String[] args) {
        //mymap();
        //myFileter();
        //myFlatMap();
        //myGroupByKey();
        myReduceByKey();
    }

   /**
     * reduceByKey:统计每个班级的总分
     */
    private static void myReduceByKey(){
        SparkConf conf = new SparkConf()
                .setAppName("myReduceByKey")
                .setMaster("local");

        JavaSparkContext sc = new JavaSparkContext(conf);

        List<Tuple2<String, Integer>> scoresClass = Arrays.asList(
                new Tuple2<String, Integer>("class2",45),
                new Tuple2<String, Integer>("class4",67),
                new Tuple2<String, Integer>("class2",76),
                new Tuple2<String, Integer>("class4",84)
        );

        JavaPairRDD<String, Integer> scoreRDD = sc.parallelizePairs(scoresClass);

        // 针对scores DRR 执行reduceByKey
        // reduceByKey，接受的参数是Function2类型，他有三个参数，实际上代表三个值
        // 第一个泛型类型和第二个泛型类型，代表原始RDD中的元素value的类型
        // 因此对每个key进行redce，都会一次将第一个，第二个value传入，将值在与第三个value传入
        // 因此此处，也会自动定义两个泛型类型，代表call()方法的两个传入参数的类型
        // 第三个泛型类型，代表了每次reduce操作返回值的类型，默认也是与原始RDD的value类型相同的
        //reduceByKey算子返回的RDD，还是JavaPairRDD<key,value>
        JavaPairRDD<String, Integer> scoreReduce = scoreRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            // 对每个key，都会将其value，依次传入call方法
            // 从而聚合出每一个key对应的一个value
            // 然后，将每一个key对应的一个value，组合称一个Tuple2，做为新的RDD的元素

            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });
        scoreReduce.foreach(new VoidFunction<Tuple2<String, Integer>>() {
            @Override
            public void call(Tuple2<String, Integer> tuple2) throws Exception {
                System.out.println(tuple2._1 + " : " + tuple2._2);
            }
        });
        sc.close();

    }

join与cogroup算子

public class Transfromationa {
    public static void main(String[] args) {
        //mymap();
        //myFileter();
        //myFlatMap();
        //myGroupByKey();
        //myReduceByKey();
        myJoinAndCogroup();
    }
    
    /**
     * join与cogroup:打印学生的成绩
     *
     */
    private static void myJoinAndCogroup(){
        SparkConf conf = new SparkConf()
                .setMaster("local")
                .setAppName("myJoinAndCogroup");

        JavaSparkContext sc = new JavaSparkContext(conf);

        List<Tuple2<Integer,String>> stuList = Arrays.asList(
                new Tuple2<Integer, String>(1,"zhaungsan"),
                new Tuple2<Integer, String>(2,"lisi"),
                new Tuple2<Integer, String>(3,"wangwu")
        );

        List<Tuple2<Integer,Integer>> scoreList = Arrays.asList(
                new Tuple2<Integer, Integer>(1,100),
                new Tuple2<Integer, Integer>(2,53),
                new Tuple2<Integer, Integer>(3,76)
        );

        List<Tuple2<Integer, Integer>> scoreTwoList = Arrays.asList(
                new Tuple2<Integer, Integer>(1, 100),
                new Tuple2<Integer, Integer>(2, 90),
                new Tuple2<Integer, Integer>(3, 60),
                new Tuple2<Integer, Integer>(1, 70),
                new Tuple2<Integer, Integer>(2, 80),
                new Tuple2<Integer, Integer>(3, 50)
        );

        // 并行化两个RDD
        JavaPairRDD<Integer, String> studets = sc.parallelizePairs(stuList);
        JavaPairRDD<Integer, Integer> scoreOne = sc.parallelizePairs(scoreList);
        JavaPairRDD<Integer, Integer> scoreTow = sc.parallelizePairs(scoreTwoList);

        // 使用join关联两个RDD
        // join后，还是会根据key进行join，并返回JavaPairRDD
        // 但是JavaPairRDD的第一个泛型类型，之前两个JavaPairRDD的key的类型，因为是通过key进行join的
        // 第二个泛型类型，是Tuple2<v1,v2>的类型，Tuple2的两个泛型分别是原始RDD的value类型
        // join，就返回的RDD的每一个元素，就是通过key join上的一个pair
        // 例如：(1,1) (1,2) (1,3)的一个RDD
        //还有一个(1,4) (2,1) (2,2)的一个RDD
        //join以后，实际上会得到(1,(1,4)) (1,(2,4)) (1,(3,4))
        JavaPairRDD<Integer, Tuple2<String, Integer>> studentJoinScoreOne = studets.join(scoreOne);

studentJoinScoreOne.foreach(new VoidFunction<Tuple2<Integer, Tuple2<String, Integer>>>() {
    @Override
    public void call(Tuple2<Integer, Tuple2<String, Integer>> tuple2) throws Exception {
        System.out.println(tuple2._1 + ":" + tuple2._2._1 + " : " + tuple2._2._2);
    }
});
        System.out.println("==============");
        // cogroup与join不同
        // 相当于，一个key join上的所有value，都放到一个Iterable里
        JavaPairRDD<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> studentsCogroupScoreOne = studets.cogroup(scoreTow);
        studentsCogroupScoreOne.foreach(new VoidFunction<Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>>>() {
            @Override
            public void call(Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> tuple2) throws Exception {
                System.out.println(tuple2._1 + ":" + tuple2._2._1 + " : " + tuple2._2._2);
            }
        });
        sc.close();
    }

常用action操作

reduce算子

public class Actiona {
    public static void main(String[] args) {
        myReduce();

    }
    private static void myReduce(){
        SparkConf conf = new SparkConf()
                .setMaster("local")
                .setAppName("myReduce");

        JavaSparkContext sc = new JavaSparkContext(conf);

        List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 7, 9, 9);
        JavaRDD<Integer> numRDD = sc.parallelize(numList);

        Integer sum = numRDD.reduce(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });
        System.out.println(sum);
        sc.close();
    }
}

collect算子

public class Actiona {
    public static void main(String[] args) {
        //myReduce();
        mycollect();
    }

    private static void mycollect(){
        SparkConf conf = new SparkConf()
                .setMaster("local")
                .setAppName("mycollect");

        JavaSparkContext sc = new JavaSparkContext(conf);

        List<Integer> numlist = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        JavaRDD<Integer> numRDD = sc.parallelize(numlist);

        JavaRDD<Integer> map = numRDD.map(new Function<Integer, Integer>() {
            @Override
            public Integer call(Integer integer) throws Exception {
                return integer * 3;
            }
        });
        List<Integer> collect = map.collect();
        for (Integer a:collect) {
            System.out.println(a);
        }
        sc.close();
    }
}

count算子

public class Actiona {
    public static void main(String[] args) {
        //myReduce();
        //mycollect();
        mycount();
    }
  /**
     * 获取RDD元素总个数
     */
    private static void mycount(){
        SparkConf conf = new SparkConf()
                .setMaster("local")
                .setAppName("mycount");

        JavaSparkContext sc = new JavaSparkContext(conf);


        List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        JavaRDD<Integer> numRDD = sc.parallelize(numList);

        long count = numRDD.count();
        System.out.println(count);
    }

take算子

public class Actiona {
    public static void main(String[] args) {
        //myReduce();
        //mycollect();
        //mycount();
        mytake();

    }
    private static void mytake(){
        SparkConf conf = new SparkConf()
                .setMaster("local")
                .setAppName("mytake");

        JavaSparkContext sc = new JavaSparkContext(conf);
        // 取集合中的前n的元素
        List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        JavaRDD<Integer> numRDD = sc.parallelize(numList);
        //take操作是从远程集群上获取RDD中的数据，但是只获取前n个
        List<Integer> take = numRDD.take(5);
        for (Integer a :take) {
            System.out.println(a);
        }
        sc.close();
    }

saveAsTextFile算子

public class Actiona {
    public static void main(String[] args) {
        //myReduce();
        //mycollect();
        //mycount();
        //mytake();
        mysaveAsTextFile();
    }


    private static void mysaveAsTextFile(){
        SparkConf conf = new SparkConf()
                .setMaster("local")
                .setAppName("mysaveAsTextFile");

        JavaSparkContext sc = new JavaSparkContext(conf);

        List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 67, 788, 34);
        JavaRDD<Integer> listRDD = sc.parallelize(numList);

        JavaRDD<Integer> numbers = listRDD.map(new Function<Integer, Integer>() {
            @Override
            public Integer call(Integer integer) throws Exception {
                return integer *2;
            }
        });
        numbers.saveAsTextFile("D:\\eclipse\\wc\\scalaworid\\num.txt");
        sc.close();
    }

countByKey算子

public class Actiona {
    public static void main(String[] args) {
        //myReduce();
        //mycollect();
        //mycount();
        //mytake();
        //mysaveAsTextFile();
        mycountByKey();
    }

 private static void mycountByKey(){
        SparkConf conf = new SparkConf()
                .setMaster("local")
                .setAppName("mycountByKey");

        JavaSparkContext sc = new JavaSparkContext(conf);

        List<Tuple2<String,String>> asList = Arrays.asList(
                new Tuple2<String, String>("class1","leo"),
                new Tuple2<String, String>("class2","tom"),
                new Tuple2<String, String>("class1","wahaha"),
                new Tuple2<String, String>("class1","jack"),
                new Tuple2<String, String>("class2","tyler")
        );
        // 并行化集合,创建JavaPairRDD
        JavaPairRDD<String, String> pairRDD = sc.parallelizePairs(asList);
        // 对rdd应用countByKey操作，统计每个班级学生人数，也就是统计每个key对应的元素个数
        // 这句是countByKey的作用
        Map<String, Object> countByKey = pairRDD.countByKey();

        for (Map.Entry<String,Object> a:countByKey.entrySet()) {
            System.out.println(a.getKey() + " :" + a.getValue());
        }
        sc.close();

    }