Spark常用RDD算子(scala和java版本)

1、创建RDD

1.1 parallelize

调用SparkContext()的parallelize()，将一个存在的集合，变成一个RDD，这种方式适用于学习spark和做一些spark测试。

scala版本

def parallelize[T](seq: Seq[T],numSlices: Int)(implicit evidence$1: scala.reflect.ClassTag[T]): org.apache.spark.rdd.RDD[T]

第一个参数是一个Seq集合，第二个参数是分区数，返回的是RDD

scala> sc.parallelize(List(1,2,3),2)
res0: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at parallelize at <console>:25

java版本

def parallelize[T](list : java.util.List[T], numSlices : scala.Int) : org.apache.spark.api.java.JavaRDD[T] = { /* compiled code */ }

第一个参数是List集合（注意只能接收List集合），第二个参数是分区，不填就是默认，返回的是JavaRDD。

	SparkConf conf = new SparkConf().setMaster("local[1]").setAppName("parallelize");
    JavaSparkContext sc = new JavaSparkContext(conf);

    List<String> strings = Arrays.asList("hello word", "hello java", "hello spark");
    JavaRDD<String> rdd1 = sc.parallelize(strings);
    List<String> collect = rdd1.collect();
    for (String value:collect){
     //for循环遍历打印
    	System.out.println(value);
    }

1.2 makeRDD

只有scala版本才有makeRDD，跟parallelize类似。

def makeRDD[T](seq: Seq[(T, Seq[String])])(implicit evidence$3: scala.reflect.ClassTag[T]): org.apache.spark.rdd.RDD[T]
def makeRDD[T](seq: Seq[T],numSlices: Int)(implicit evidence$2: scala.reflect.ClassTag[T]): org.apache.spark.rdd.RDD[T]

scala> sc.makeRDD(List("hello scala","hello spark"),2)
res0: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[0] at makeRDD at <console>:25

1.3 textFile

调用SparkContext.textFile()方法，从外部存储中读取数据来创建 RDD

scala版本

def textFile(path: String,minPartitions: Int): org.apache.spark.rdd.RDD[String]

//通过加载本地文件产生RDD
val lines:RDD[String] = sc.textFile("D:\\test\\a.txt ")
//通过加载HDFS文件产生RDD
val linesHDFS:RDD[String] = sc.textFile("hdfs://hadoop20:9000/wctest/a.txt")

java版本

//通过加载本地文件产生RDD
JavaRDD<String> stringJavaRDD = sc.textFile("D:\\test\\a.txt");
//通过加载HDFS文件产生RDD
JavaRDD<String> stringJavaRDD = sc.textFile("hdfs://hadoop20:9000/wctest/a.txt");

注：textFile支持分区，支持正则匹配，支持多路径，多路径可以用逗号隔开。

//正则匹配
val lines = sc.textFile("D:\\test\\a*.txt ")
//多路径用逗号隔开
val lines = sc.textFile("dir1,dir2")

2、基本操作

2.1 filter

scala版本

filter(func)：对原 RDD 中每个元素使用func 函数进行过滤，并生成新的 RDD

def filter(f: Int => Boolean): org.apache.spark.rdd.RDD[Int]

val lines:RDD[String] = sc.textFile("D:\\test\\b.txt").filter(line=>line.contains("hello"))
lines.collect().foreach(println)
/*输出：
hello spark
aaa bb hello*/

java版本

JavaRDD<String> lines = sc.textFile("D:\\test\\b.txt");
JavaRDD<String> filterRDD = lines.filter(new Function<String, Boolean>() {
   
     @Override
     public Boolean call(String s) throws Exception {
   
         return s.contains("hello");

       }
        });
      List<String> collect2 = filterRDD.collect();
        for(String str:collect2){
   
            System.out.println(str);
      }
/*输出：
hello spark
aaa bb hello*/
    

2.2 map

map(func) ：对原RDD中每个元素运用func函数，并生成新的RDD

map算子输入分区与输出分区一一对应。

scala版本

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

object MapDemo {
   
  def main(args: Array[String]): Unit = {
   
    val sparkConf = new SparkConf().setMaster("local[2]").setAppName("mapdemo")
    val sc = SparkContext.getOrCreate(sparkConf)
    val rdd1 = sc.makeRDD(1 to 9,2)
    rdd1.map(_*2).collect.foreach(println)

java版本

public class MapJava {
   
    public static void main(String[] args) {
   
    SparkConf conf = new SparkConf().setMaster("local[1]").setAppName("MapJava");
        JavaSparkContext sc = new JavaSparkContext(conf);
     	JavaRDD<Integer> rdd = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5));
        JavaRDD<Integer> mapRdd = rdd.map(new Function<Integer, Integer>() {
   
            @Override
            public Integer call(Integer integer) throws Exception {
   
                return integer * 2;
            }
        });

        List<Integer> collect = mapRdd.collect();
        for (Integer i : collect) {
   
            System.out.println(i);
        }
    }
}

2.3 flatMap

flatMap(func)：将每个元素进行扁平化处理，也就是将某个元素按照规则生成多个元素。

flatMap的函数应用于每一个元素，对于每一个元素返回的是多个元素组成的迭代器。

scala版本

scala> val lines = sc.textFile("D:\\test\\b.txt")
scala>lines.flatMap(line=>line.split("\\s")).collect.foreach(println)

java版本

public class FlatMapJava {
   
    public static void main(String[] args) {
   
        SparkConf conf = new SparkConf().setMaster("local[1]").setAppName("FlatMapJava");
        JavaSparkContext sc = new JavaSparkContext(conf);       
		JavaRDD<String> rdd = sc.parallelize(Arrays.asList("hello world", "hello java", "hello spark"));
        JavaRDD<String> flatMapRdd = rdd.flatMap(new FlatMapFunction<String, String>() {
   
            @Override
            public Iterator<String> call(String s) throws Exception {
   
                String[] split = s.split(" ");
                return Arrays.asList(split).iterator();
            }
        });

        List<String> collect = flatMapRdd.collect();
        for (String s : collect) {
   
            System.out.println(s);
        }
    }
}

2.4 distinct

去重，此操作涉及到混洗，操作开销很大。

scala版本

val rdd1=sc.parallelize(List("aa", "bb", "cc", "dd", "aa", "dd"))
rdd1.distinct.collect.foreach(println)

java版本

List<String> strings = Arrays.asList("aa", "bb", "cc", "dd", "aa", "dd");
JavaRDD<String> strRdd = sc.parallelize(strings);
JavaRDD<String> distinct = strRdd.distinct();
List<String> collect = distinct.collect();
for (String str : collect) {
   
    System.out.println(str);
}

3、操作集合

3.1 union

两个RDD进行合并

scala版本

val u1=sc.parallelize(1 to 3)
val u2=sc.parallelize(3 to 4)
(u1++u2).collect.foreach(println) //输出：1 2 3 3 4
u1.union(u2).collect.foreach(println) //输出：1 2 3 3 4

java版本

List<String> strings = Arrays.asList("aa", "bb", "cc", "dd");
JavaRDD<String> strRdd = sc.parallelize(strings);
List<String> strings2 = Arrays.asList("aa", "bb", "cc");
JavaRDD<String> strRdd2 = sc.parallelize(strings2);

JavaRDD<String> unionRdd = strRdd.union(strRdd2);
List<String> collect = unionRdd.collect();
for (String str : collect) {
   
     System.out.println(str);
}

3.2 intersection

求两个RDD的交集

scala版本

val u1=sc.parallelize(1 to 3)
val u2=sc.parallelize(3 to 4)
u1.intersection(u2).collect.foreach(println) //输出：3 

java版本

List<String> strings = Arrays.asList("aa", "bb", "cc", "dd");
JavaRDD<String> strRdd = sc.parallelize(strings);
List<String> strings2 = Arrays.asList("aa", "bb", "cc");
JavaRDD<String> strRdd2 = sc.parallelize(strings2);

JavaRDD<String> interactionRdd = strRdd.intersection(strRdd2);
List<String> collect = interactionRdd.collect();
for (String str : collect) {
   
    System.out.println(str);
}    

3.3 subtract

RDD1.subtract(RDD2)，但会在RDD1中出现，但是不在RDD2中出现的元素，不去重。

scala版本

scala> val rdd1=sc.parallelize(List(1,2,3))
scala> val rdd2=sc.parallelize(List(3,4,5))
scala> rdd1.subtract(rdd2).collect.foreach(println)

java版本

List<String> strings = Arrays.asList("aa", "bb", "cc", "dd");
JavaRDD<String> strRdd = sc.parallelize(strings);
List<String> strings2 = Arrays.asList("aa", "bb", "cc");
JavaRDD<String> strRdd2 = sc.parallelize(strings2);

JavaRDD<String> subtractRdd = strRdd.subtract(strRdd2);
List<String> collect = subtractRdd.collect();
for (String str : collect) {
   
	System.out.println(str);
}//输出：dd

3.4 cartesian

RDD1.cartesian(RDD2) 返回RDD1和RDD2的笛卡儿积，这个开销非常大，慎用。

scala版本

scala> val RDD1 = sc.parallelize(List("1","2","3"))
scala> val RDD2 = sc.parallelize(List("a","b","c"))
scala> RDD1.cartesian(RDD2).collect.foreach(println)
(1,a)
(1,b)
(1,c)
(2,a)
(2,b)
(2,c)
(3,a)
(3,b)
(3,c)

java版本

JavaRDD<String> rdd1 = sc.parallelize(Arrays.asList("1", "2", "3"));
JavaRDD<String> rdd2 = sc.parallelize(Arrays.asList("a", "b", "c"));
JavaPairRDD<String, String> cartesianRdd = rdd1.cartesian(rdd2);
List<Tuple2<String, String>> collect = cartesianRdd.collect();
for (Tuple2<String, String> tp2 : collect) {
   
	System.out.println(tp2);
}

4、创建键值对

4.1 mapToPair

将每行的第一个单词作为键，1作为value创建pairRDD

scala版本

scala是没有mapToPair函数的，scala版本只需要map就可以了

val rdd1 = sc.textFile("D:\\test\\b.txt")
val rdd2 = rdd.map(x=>(x.split(" ")(0),1))
rdd2.collect.foreach(println)

java版本

JavaRDD<String> rdd1 = sc.textFile("D:\\test\\b.txt");
JavaPairRDD<String, Integer> pairRdd = rdd1.mapToPair(new PairFunction<String, String, Integer>() {
   
	 @Override
    public Tuple2<String, Integer> call(String s) throws Exception {
   
		String[] split = s.split(" ");
		String key = split[0];
		return new Tuple2<>(key, 1);
	}
});
List<Tuple2<String, Integer>> collect = pairRdd.collect();
for (Tuple2<String, Integer> tp : collect) {
   
	System.out.println(tp);
}

4.2 flatMapToPair

mapToPair是一对一，一个元素返回一个元素，而flatMapToPair可以一个元素返回多个，相当于先flatMap，再mapToPair。

scala版本

val pairRdd = sc.textFile("D:\\test\\b.txt").flatMap(x=>x.split(" ")).map((_,1))
pairRdd.collect().foreach(println)

java版本

JavaRDD<String> rdd1 = sc.textFile("D:\\test\\b.txt");
JavaPairRDD<String, Integer> pairRdd = rdd1.flatMapToPair(new PairFlatMapFunction<String, String, Integer>() {
   
	@Override
	public Iterator<Tuple2<String, Integer>> call(String s) throws Exception {
   
		ArrayList<Tuple2<String, Integer>> list = new ArrayList();
        String[] split = s.split(" ");
        for (int i = 0; i < split.length; i++) {
   
        	String key = split[i];
            Tuple2<String, Integer> tp2 = new Tuple2<>(key, 1);
            list.add(tp2);
         }
         return list.iterator();
     }
});
List<Tuple2<String, Integer>> collect = pairRdd.collect();
for (Tuple2<String, Integer> o : collect) {
   
	System.out.println(o);
}

5、键值对聚合操作

5.1 combineByKey

聚合数据处理集中式数据比较方便，那涉及到分布式数据集呢，该如何实现。

def combineByKey[C](createCombiner:(V)=C,
                   mergeValue: (C, V) => C,
                   mergeCombiners: (C, C) => C): RD

• createCombiner：combinewByKey()会遍历分区中的所有的元素，因此每个元素的键要么还没遇到过，要么就是和之前的某个元素的键相同。如果这是一个新的元素，combineByKey()会使用一个叫作createCombiner()的函数来创建key对应的累加器的初始值。
• mergeValue：区内累加。如果这是一个在处理当前分区之前已经遇到的键，它会使用mergeValue()方法将该键的累加器对应的当前值与这个新的值进行合并。
• mergeCombiners：区间合并。每个分区都是独立处理的，如果有两个或者更多的分区都有同一个键的累加器，就需要使用mergeCombiners()方法将各个分区的结果进行合并。

scala版本

import org.apache.spark.rdd.RDD
import org.apache.spark.{
   HashPartitioner, SparkConf, SparkContext}

object CombineByKeyScala {
   
  //样例类
  case class ScoreDetail(name:String,subject:String,score:Integer)

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