Spark RDD动作算子

|--------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 动作算子 | 介绍 |
| reduce(func) | 使用函数 func 对数据集中的元素进行聚合。该函数应当具备可交换性(如：a+b=b+a a-b!=b-a)和可结合性(a+b+c=a+(b+c))，以便能够正确地在并行环境下进行计算。 |
| collect() | 将数据集的所有元素作为一个数组返回给 Driver 程序。这通常在执行了过滤（filter）或其他操作，返回了一个足够小的数据子集之后使用。测试环境，数据量不大可以使用，如果数据量过大或生产环境，不建议使用。返回一个List<T> |
| count() | 返回dataset元素的数量。返回Long类型 |
| first() | 返回dataset第一个元素。类似于take(1) |
| take(n) | 返回一个包含数据集前 n 个元素的数组。 |
| takeSample(withReplacement, num, [seed]) | 返回一个包含数据集中 num 个随机元素的数组，支持设置是否放回抽样，并可选择性地预先指定随机数生成器的种子。 |
| takeOrdered(n, [ordering]) | 使用自然顺序或自定义比较器，返回 RDD 的前 n 个元素。 |
| saveAsTextFile(path) | 将数据集的元素写入给定目录下的文本文件（或一组文本文件），支持本地文件系统、HDFS 或任何其他 Hadoop 支持的文件系统。Spark 会调用每个元素的 toString 方法，将其转换为文件中的一行文本。如果是类的话，实现toString方法,且path是一个目录，如果目录存在会报错，不是文件名；且文件按分区生成多个具体文件 |
| saveAsSequenceFile(path) (Java and Scala) | 将数据集的元素以 Hadoop SequenceFile 的格式写入指定路径，支持本地文件系统、HDFS 或任何其他 Hadoop 支持的文件系统。此算子仅适用于由键值对组成的 RDD，且这些键值对必须实现 Hadoop 的 Writable 接口。在 Scala 中，该算子也适用于可以隐式转换为 Writable 的类型（Spark 已经内置了对 Int、Double、String 等基本类型的转换支持）。版本暂时没有，存在saveAsHadoopFile |
| saveAsObjectFile(path) | 使用 Java 序列化机制，以简单的格式写入数据集的元素，随后可通过 SparkContext.objectFile() 进行加载。可以通过mapPartitionsRDD反序列化，或者mapPartitionsToPair。 |
| countByKey() | 仅适用于类型为 (K, V) 的 RDD。返回一个哈希映射（HashMap），其中包含每个键（Key）的计数，格式为 (K, Int) 键值对。如：wordcount，可以不采用reduceByKey,直接在map(lambda x:(x,1)).countByKey()。返回key的类型+Long的Map Map<String,Integer> |
| foreach(func) | 在数据集的每个元素上运行函数 func。这通常用于产生副作用，例如更新累加器或与外部存储系统交互。注意：在 foreach() 之外修改变量（累加器除外）可能会导致未定义的行为。 |

java 复制代码

// reduce
        JavaRDD<Integer> rdd = sc.parallelize(Arrays.asList(1,2,3,4,5,6));
        Integer result = rdd.reduce((a,b)->a+b);
        System.out.println(result);
输出：21
// collect 
        List<Integer> result = rdd.collect();
// count
        Long result = rdd.count();
// first  由于RDD类型为Integer,所以返回是Integer,如果是JavaRDD<String> 返回String
        Integer result =rdd.first();
// take(n)
        List<Integer> result = rdd.take(3);
// takeSample()
        List<Integer> result = rdd.takeSample(true,3,0);
// takeOrdered(num,ordering):降序
        List<Integer> result = rdd.takeOrdered(3, (o1, o2) -> o2.compareTo(o1));
// saveAsTextFile
        rdd.saveAsTextFile("test")
// saveAsHadoopFile
        JavaPairRDD<String,Integer> stuScore = sc.parallelizePairs(Arrays.asList(
                new Tuple2<>("Tom",611),
                new Tuple2<>("Jack",585),
                new Tuple2<>("Tom",585),
                new Tuple2<>("James",700)
                ));
        stuScore.saveAsHadoopFile("hdfs://master:9000/output/demo", Text.class, IntWritable.class, TextOutputFormat.class);
// saveAsObject
        JavaRDD<Employee> emps = sc.parallelize(Arrays.asList(
                new Employee(1,"tom",12),
                new Employee(2,"jack",22)

                ));
        emps.saveAsObjectFile("test01");
        JavaRDD<Employee> result = sc.objectFile("test01");
        JavaRDD<Tuple2<Integer, Tuple2<String, Integer>>> data = result.mapPartitions(new FlatMapFunction<Iterator<Employee>, Tuple2<Integer,Tuple2<String,Integer>>>() {
            @Override
            public Iterator<Tuple2<Integer, Tuple2<String, Integer>>> call(Iterator<Employee> employeeIterator) throws Exception {
                List<Tuple2<Integer,Tuple2<String,Integer>>> data = new ArrayList<>();
                while(employeeIterator.hasNext()){
                    Employee e = employeeIterator.next();
                    data.add(new Tuple2<Integer,Tuple2<String,Integer>>(e.getId(),new Tuple2<String,Integer>(e.getName(),e.getAge())));
                };
                return data.iterator();
            }
        });
        data.foreach(x-> System.out.println(x));
// countByKey
        Map<String,Long> result = stuScore.countByKey();

python 复制代码

# reduce：此外reduce支持最大最小值max/min函数
    rdd = sc.parallelize([1,2,3,4,5,6])
    print(rdd.reduce(lambda a,b:a+b))
    rdd = sc.parallelize([("tom",12),("jack",13)])
    print(rdd.reduce(lambda a, b: a[1] + b[1]))
# collect
    print(rdd.collect())
# count 
    print(rdd.count())
# first
    print(rdd.first())
# take
    print(rdd.take(3))
# takeSample
    print(rdd.takeSample(True,3))
# takeOrder (num,key=None) 降序 -x
    print(rdd.takeOrdered(3,lambda x:-x))
# saveAsTextFile
    rdd.saveAsTextFile("test")