Spark学习——RDD基本操作

Spark操作分为transformation和action，现将常用的记录在此：

        //transformation
        //将元素一个一个转换
        JavaRDD<String> map = raw.map(new Function<String, String>() {
            @Override
            public String call(String string) throws java.lang.Exception {
                return string+"!";
            }
        });
        //返回结果依true、false结果来定
        JavaRDD<String> filter = raw.filter(new Function<String, Boolean>() {
            @Override
            public Boolean call(String s) throws java.lang.Exception {
                return s.length()>11;
            }
        });
        //将每一个元素先进行内部处理，再讲所有部分经过处理的元素再合并
        JavaRDD<String> flatmap = raw.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public Iterator<String> call(String s) throws java.lang.Exception {
                return Arrays.asList(s.split(" ")).iterator();
            }
        });
        //该函数和map函数类似，只不过映射函数的参数由RDD中的每一个元素变成了RDD中每一个分区的迭代器。
        //如果在映射的过程中需要频繁创建额外的对象，使用mapPartitions要比map高效的多。例如在写入数据库
        //时，map会为每一个partition创建一个connection，开销大；而用mapPartitions则会为每个partition
        //创建一个connection
        JavaRDD<String> mapPartitions = raw.mapPartitions(new FlatMapFunction<Iterator<String>, String>() {
            @Override
            public Iterator<String> call(Iterator<String> stringIterator) throws java.lang.Exception {
                int i = 0;
                List<String> cur = new ArrayList<String>();
                while(stringIterator.hasNext()){
                    cur.add(stringIterator.next()+i);
                    i++;
                }
                return cur.iterator();
            }
        });
        //mapPartitionsWithIndex与mapPartition基本相同，只是在处理函数的参数是一个二元元组，元组的第一
        // 个元素是当前处理的分区的index，元组的第二个元素是当前处理的分区元素组成的Iterator
        JavaRDD<String> mapPartitionsWithIndex = raw.mapPartitionsWithIndex(new Function2<Integer, Iterator<String>, Iterator<String>>() {
            @Override
            public Iterator<String> call(Integer v1, Iterator<String> v2) throws java.lang.Exception {
                List<String> cur = new ArrayList<String>();
                while(v2.hasNext()){
                    cur.add(v2.next()+v1);
                }
                return cur.iterator();
            }
        },true);
        //联结两个RDD
        JavaRDD<String> union = map.union(mapPartitions);
        //求两个RDD的交集
        JavaRDD<String> intersection = raw.intersection(map);
        //去重
        JavaRDD<String> distinct = raw.distinct();
        //转为pair
        JavaPairRDD<Integer,String> mapToPair = raw.mapToPair(new PairFunction<String, Integer, String>() {
            @Override
            public Tuple2<Integer, String> call(String s) throws java.lang.Exception {
                if(s.length() < 11){
                    return new Tuple2<Integer, String>(1,s);
                }else{
                    return new Tuple2<Integer, String>(2,s);
                }
            }
        });
        //按照key来归并，返回的RDD中value为Iterable类型的
        JavaPairRDD<Integer,Iterable<String>> groupByKey = mapToPair.groupByKey();
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //按照key来进行聚合
        JavaPairRDD<Integer,String> reduceByKey = mapToPair.reduceByKey(new Function2<String, String, String>() {
            @Override
            public String call(String s, String s2) throws java.lang.Exception {
                return s + " " + s2;
            }
        });
        //按照key来聚合，首先第一个方法在当前分段内部完成按key聚合，然后再将所有分段按key进行合并
        JavaPairRDD<Integer,String> aggregateByKey = mapToPair.aggregateByKey("test", new Function2<String, String, String>() {
            @Override
            public String call(String s, String s2) throws java.lang.Exception {
                System.out.println("1:"+s+" "+s2);
                return s+s2;
            }
        }, new Function2<String, String, String>() {
            @Override
            public String call(String s, String s2) throws java.lang.Exception {
                System.out.println("2:"+s+" "+s2);
                return s+s2;
            }
        });
        //按key排序
        JavaPairRDD<Integer,String> sortByKey = mapToPair.sortByKey();
        //联结两个RDD，放入一个二元tuple
        JavaPairRDD<Integer,Tuple2<String,String>> join = mapToPair.join(reduceByKey);

        //action:
        //以数组的形式返回一个数据集
        List<String> res = distinct.collect();
        //统计数量
        long num = mapPartitions.count();
        //返回第一个元素
        String first = map.first();
        //take(n)返回前n个元素
        List<String> n = map.take(3);
        //随机抽样，返回一个包含 num 个随机抽样（random sample）元素的数组，参数 withReplacement
        //指定是否有放回抽样，参数 seed 指定生成随机数的种子
        List<String> sample = map.takeSample(true, 3, 7);
        //saveAsTextFile(path):将数据集中的元素以文本文件（或文本文件集合）的形式写入本地文件系统、
        // HDFS 或其它 Hadoop 支持的文件系统中的给定目录中。Spark 将对每个元素调用 toString 方法，
        // 将数据元素转换为文本文件中的一行记录。

        //saveAsSequenceFile(path):将数据集中的元素以 Hadoop SequenceFile 的形式写入到本地文件系统、
        // HDFS 或其它 Hadoop 支持的文件系统指定的路径中。该操作可以在实现了 Hadoop 的 Writable 接口
        // 的键值对（key-value pairs）的 RDD 上使用。在 Scala 中，它还可以隐式转换为 Writable 的类型

        //saveAsObjectFile(path) :使用 Java 序列化（serialization）以简单的格式（simple format）
        //编写数据集的元素，然后使用 SparkContext.objectFile() 进行加载。

        //仅适用于（K,V）类型的 RDD 。返回具有每个 key 的计数的 （K , Int）对 的 hashmap。
        Map<Integer, Long> resultMap = mapToPair.countByKey();
        //遍历
        map.foreach(new VoidFunction<String>() {
            @Override
            public void call(String s) throws Exception {
                System.out.println(s);
            }
        });