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);            }        });