1.spark的算子分为转换算子和Action算子，Action算子将形成一个job，转换算子RDD转换成另一个RDD,或者将文件系统的数据转换成一个RDD

2.Spark的算子介绍地址：http://spark.apache.org/docs/2.3.0/rdd-programming-guide.html

3.Spark操作基本步骤【java版本，其他语言可以根据官网的案例进行学习】

（1）创建配置文件，将集群的运行模式设置好，给作业起一个名字，可以使用set方法其他配置设入。

SparkConf sparkConf = new SparkConf().setAppName("Demo").setMaster("local");

这里使用的是local的运行模式，起的名字是Demo

（2）创建SparkContext

JavaSparkContext javaContext = new JavaSparkContext(sparkConf);

（3）使用算子，操作数据

　　　　　JavaRDD<String> javaRdd = sparkContext.textFile("logfile.txt",);

        javaRdd = javaRdd.cache();//这一句必须这样写，我们在数据计算很费时的时候，将数据缓存

        long line = javaRdd.count();

        System.out.println(line);

（4）关闭资源

sparkContext.close();

上面以一个求出数据行数的例子，看一下代码操作的流程。

4.Action算子和介绍和举例

（1）map算子;将数据读取使用map进行操作，使用foreach算子计算出 结果。 每一次读取partition中的一条数据进行分析

　　案例：将数据乘以10，在输出，测试算子。

package kw.test.demo;

import java.util.Arrays;

import java.util.List;

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;

/*

 * 本案例：将数据 值乘以一个数，然后将数据的值返回。

 */

public class MapApp {

    public static void main(String[] args) {

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

        JavaSparkContext jsc= new JavaSparkContext(conf);

        List<Integer> list = Arrays.asList(,,,,) ;

        JavaRDD<Integer> javaRdd = jsc.parallelize(list);

        JavaRDD<Integer> result = javaRdd.map(new Function<Integer,Integer>() {

            @Override

            public Integer call(Integer list) throws Exception {

                // TODO Auto-generated method stub

                return list*;

            }

        });

        result.foreach(new  VoidFunction<Integer>() {

            @Override

            public void call(Integer result) throws Exception {

                // TODO Auto-generated method stub

                System.out.println(result);

            }

        });

        jsc.close();

    }

}

(2)MapPartition:将一整块的数据放入然后处理，他和map的区别就是，map将一部分数据放入然后计算，MapPartition将一整块的数据一起放入计算。

如果数据量小的时候，可以是Mappartition中，如果数据量比较大的时候使用Map会比较好，因为可以防止内存溢出。

package kw.test.demo;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.apache.hadoop.hive.metastore.api.Function;

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.FlatMapFunction;

import org.apache.spark.api.java.function.Function2;

import org.apache.spark.api.java.function.VoidFunction;

public class MapPartitionApp {

    public static void main(String[] args) {

        /*

         * 创建配置文件

         * 创建出RDD

         */

        SparkConf sparkconf = new SparkConf().setMaster("local").setAppName("mapPartition");

        JavaSparkContext javaSparkContext = new JavaSparkContext(sparkconf);

        /*

         * mapPartition的使用是将一个块一起放入到算子中操作。

         *

         * 假如说RDD上的数据不是太多的时候，可以使用mapPartition 来操作，如果一个RDD的数据比较多还是使用map好

         * 返回了大量数据，容易曹成内存溢出。

         */

    /*    准备数据集*/

        List <String> list= Arrays.asList("kangwang","kang","wang");

        JavaRDD<String> javaRDD = javaSparkContext.parallelize(list);

        final Map<String,Integer> sore = new HashMap<String ,Integer>();

        sore.put("kangwang", );

        sore.put("kang", );

        sore.put("wang", );

        JavaRDD<Integer> sRDD= javaRDD.mapPartitions(new FlatMapFunction<Iterator<String>, Integer>() {

            @Override

            public Iterator<Integer> call(Iterator<String> it) throws Exception {

                // TODO Auto-generated method stub

                List list = new ArrayList();

                while(it.hasNext())

                {

                    String name = it.next();

                    Integer so = sore.get(name);

                    list.add(so);

                }

                Iterator i =list.iterator();

                return  i;

            }

        });

        sRDD.foreach(new VoidFunction<Integer>() {

            @Override

            public void call(Integer it) throws Exception {

                // TODO Auto-generated method stub

                System.out.println("it的值是"+it);

            }

        });

    }

}

（3）MapPartitionWithIndex:

本案例：
  查看将数据的分配到具体的快上的信息。
  我们可以指定partition的个数，默认是2
  parallelize并行集合的时候，指定了并行度，也就是partition的个数是2
  具体他们的数据怎样分，我们并不知道，由spark自己分配
 如果想要知道，就可以使用此算子，将数据的值打印出来。

package kw.test.demo;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

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.Function2;

import org.apache.spark.api.java.function.VoidFunction;

public class MapPartionWithIndex {

    public static void main(String[] args) {

        SparkConf sparkConf = new SparkConf().setAppName("MapPartitionWithIndex").setMaster("local");

        JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);

        //准备数据

        List<String> list =new ArrayList<String>();

        list.add("Demo1");

        list.add("Demo2");

        list.add("Demo3");

        list.add("Demo4");

        list.add("Demo5");

        list.add("Demo6");

        list.add("Demo7");

        list.add("Demo8");

        list.add("Demo9");

        list.add("Demo10");

        list.add("Demo11");

        list.add("Demo12");

        //创建RDD,指定map的个数4

        JavaRDD<String> javaRDD = javaSparkContext.parallelize(list, );

        JavaRDD<String> javaRDD1 =javaRDD.mapPartitionsWithIndex(new Function2<Integer, Iterator<String>, Iterator<String>>() {

            @Override

            public Iterator<String> call(Integer index, Iterator<String> it2) throws Exception {

                // TODO Auto-generated method stub

                //index是partition的个数

                List<String> list = new ArrayList<String>();

                while(it2.hasNext())

                {

                    String name = it2.next();

                    String info = "partition是:"+index+"数据的name是："+name;

                    list.add(info);

                }

                return list.iterator();

            }

        }, true);

        javaRDD1.foreach(new VoidFunction<String>() {

            @Override

            public void call(String infos) throws Exception {

                // TODO Auto-generated method stub

                System.out.println(infos);

            }

        });

    }

}

(4)coalesce算子，是架构RDD的partition的数量缩减

将一定数量的partition压缩到更少的partition分区中去

使用的场景，很多时候在filter算子应用之后会优化一下到使用coalesce算子。

filter算子应用到RDD上面，说白了会应用到RDD对应到里面的每个partition上

数据倾斜，换句话说就是有可能的partition里面就剩下了一条数据 建议使用coalesce算子，

从前各个partition中 数据都更加的紧凑就可以减少它的 个数

package kw.test.demo;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

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.Function2;

import org.apache.spark.api.java.function.VoidFunction;

public class CoalesceOpter {

    public static void main(String[] args) {

        SparkConf sparkConf = new SparkConf().setAppName("coalesceDemo").setMaster("local");

        JavaSparkContext javaContext = new JavaSparkContext(sparkConf);

        List<String> list = Arrays.asList("kw1","djf","kw1","fgf",

                "djf","kw1","djf","sdsds","kw1","ssdu","djf");

        JavaRDD<String>javaRDD = javaContext.parallelize(list,);

        JavaRDD<String> info = javaRDD.mapPartitionsWithIndex(new Function2<Integer, Iterator<String>, Iterator<String>>() {

            @Override

            public Iterator<String> call(Integer arg0, Iterator<String> arg1) throws Exception {

                // TODO Auto-generated method stub

                List<String> list =new ArrayList<String>();

                while(arg1.hasNext())

                {

                    String name = arg1.next();

                    String info = arg0 +"^^^^^……………………………………………………………………"+ name;

                    list.add(info);

                }

                return list.iterator();

            }

        }, true);

        info.foreach(new VoidFunction<String>() {

            @Override

            public void call(String arg0) throws Exception {

                // TODO Auto-generated method stub

                System.out.println(arg0);

            }

        });

        info.coalesce();

        JavaRDD<String> javaRDD1 = info.mapPartitionsWithIndex(new Function2<Integer, Iterator<String>, Iterator<String>>() {

            @Override

            public Iterator<String> call(Integer arg0, Iterator<String> arg1) throws Exception {

                // TODO Auto-generated method stub

                List<String> list = new ArrayList<String>();

                while(arg1.hasNext())

                {

                    String name = arg1.next();

                    String info2 ="        " +name +"………………………………" +arg0;

                    list.add(info2);

                }

                return list.iterator();

            }

        }, true);

        javaRDD1.foreach(new VoidFunction<String>() {

            @Override

            public void call(String arg0) throws Exception {

                // TODO Auto-generated method stub

                System.out.println(arg0);

            }

        });

    }

}

*

（5）filter此案例将数据的值过滤出来。使用的是filter算子

package kw.test.demo;

import java.util.ArrayList;

import java.util.List;

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;

/*

 * 此案例将数据的值过滤出来。使用的是filter算子

 */

public class APPFilter {

    public static void main(String[] args) {

        SparkConf sparkConf = new SparkConf().setMaster("local").setAppName("Filter");

        JavaSparkContext jsc = new JavaSparkContext(sparkConf);

        List<Integer> list = new ArrayList<Integer>();

        list.add();

        list.add();

        list.add();

        list.add();

        list.add();

        list.add();

        list.add();

        list.add();

        list.add();

        JavaRDD<Integer> javaRDD = jsc.parallelize(list,);

        //返回值  将返回true的数据返回

        JavaRDD<Integer> num= javaRDD.filter(new Function<Integer, Boolean>() {

            @Override

            public Boolean call(Integer it) throws Exception {

                // TODO Auto-generated method stub

                return it%==;

            }

        });

        num.foreach(new VoidFunction<Integer>() {

            @Override

            public void call(Integer arg0) throws Exception {

                // TODO Auto-generated method stub

                System.out.println(arg0);

            }

        });

    }

}

spark程序可以在本地运行，也可以在集群中运行，可以大成jar，放到真实的集群环境中运行程序。

 

spark算子介绍的更多相关文章

  1. Spark：常用transformation及action，spark算子详解

    常用transformation及action介绍,spark算子详解 一.常用transformation介绍 1.1 transformation操作实例 二.常用action介绍 2.1 act ...

  2. spark API 介绍链接

    spark API介绍: http://homepage.cs.latrobe.edu.au/zhe/ZhenHeSparkRDDAPIExamples.html#aggregateByKey

  3. (转)Spark 算子系列文章

    http://lxw1234.com/archives/2015/07/363.htm Spark算子:RDD基本转换操作(1)–map.flagMap.distinct Spark算子:RDD创建操 ...

  4. Spark算子总结及案例

    spark算子大致上可分三大类算子: 1.Value数据类型的Transformation算子,这种变换不触发提交作业,针对处理的数据项是Value型的数据. 2.Key-Value数据类型的Tran ...

  5. UserView--第二种方式（避免第一种方式Set饱和），基于Spark算子的java代码实现

      UserView--第二种方式(避免第一种方式Set饱和),基于Spark算子的java代码实现   测试数据 java代码 package com.hzf.spark.study; import ...

  6. UserView--第一种方式set去重，基于Spark算子的java代码实现

    UserView--第一种方式set去重,基于Spark算子的java代码实现 测试数据 java代码 package com.hzf.spark.study; import java.util.Ha ...

  7. spark算子之DataFrame和DataSet

    前言 传统的RDD相对于mapreduce和storm提供了丰富强大的算子.在spark慢慢步入DataFrame到DataSet的今天,在算子的类型基本不变的情况下,这两个数据集提供了更为强大的的功 ...

  8. Spark算子总结（带案例）

    Spark算子总结(带案例) spark算子大致上可分三大类算子: 1.Value数据类型的Transformation算子,这种变换不触发提交作业,针对处理的数据项是Value型的数据. 2.Key ...

  9. Spark算子---实战应用

    Spark算子实战应用 数据集 :http://grouplens.org/datasets/movielens/ MovieLens 1M Datase 相关数据文件 : users.dat --- ...

随机推荐

  1. ActiveReports 9实战教程（2）： 准备数据源（设计时、执行时）

    在上讲中<ActiveReports 9实战教程(1): 手把手搭建好开发环境Visual Studio 2013 社区版>,我们已经结合Visual Studio 2013搭建好了Act ...

  2. jquery12 queue() : 队列方法

    <!DOCTYPE HTML> <html> <head> <meta http-equiv="Content-Type" content ...

  3. Vue v-bind的使用

    1.src <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <tit ...

  4. 66.app.use(express.static)

    转自:https://blog.csdn.net/u010977147/article/details/60956502

  5. 如何让hudson的两个job共用一个svn工作目录

    作者:朱金灿 来源:http://blog.csdn.net/clever101 现在我的需求是这样的:一个软件需要编译完全版本和基础版本,完全版本的基础功能较多,基础版本只包含了基础功能.有时只需要 ...

  6. mvc4 视图中的form如何获取

    public ActionResult Index(FormCollection form)         {             var Name = form["字段名" ...

  7. CSU 1046 追杀

    Description 在一个8行9列的国际象棋棋盘上,有一名骑士在追杀对方的国王.该骑士每秒跨越一个2*3的区域,如下图所示. 而对方的国王慌忙落逃,他先沿着右下斜线方向一直跑,遇到边界以后会沿着光 ...

  8. kafka删除主题

    hdp集群默认不能删除kafka主题,如果要删除,需要在ambari上进行配置,将enable delete设置为true.

  9. aop 中joinpoint的使用方法

    一.簡述下joinpoint在不同情況下的不同: 1.在around中可以用,此時可以執行被包裹的代碼,可以根據情況來判斷是否執行被包裹的代碼,以實現控制的作用. public void around ...

  10. 洛谷——T1725 探险

    http://codevs.cn/problem/1725/ 时间限制: 1 s  空间限制: 256000 KB 题目等级 : 钻石 Diamond 题解  查看运行结果   题目描述 Descri ...