spark相关的算子（未完待续）

转化算子

• map(func)
• 映射方法 举例 a -> [(a,1)] 意思是即每次生成的列表是独立的，与其他无关

# java版本
RDD.map(new function<String,Tuple2<String,Integer>>(){
	@overrid
	public Tuple2<String,Integer> call(String v1) throws Exception{
		return new Tuple2<>(v1,1)
	}
})

# scala版本
RDD.map(x=>(x,1))

• flatMap(func)
• 映射方法 举例 [ a-> (a,1)] 意思即每次映射生成的列表都将与最终列表合并

RDD.flatMap(new FlatMapFunction<String, String>() {
    @Override
    public Iterable<String> call(String s) throws Exception {
        return new ArrayList<String>(Arrays.asList(s.split(" ")));
    }
  })

.flatMap(line => line.split(" "))

• reducebykey(func)

RDD.reduceByKey { case (x, y) => x + y }

• filter()
• 过滤算子 过滤满足条件的数据

val ints = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
val rdd: RDD[Int] = sc.parallelize(ints)
rdd.filter(_>5).foreach(println)

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
JavaRDD<Integer> javaRDD = jsc.parallelize(integers);
javaRDD.filter(new Function<Integer, Boolean>() {
    @Override
    public Boolean call(Integer s) throws Exception {
        return s>5;
    }
})

• union()
• 合并算子 合并两个RDD

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
List<Integer> integers1 = Arrays.asList(12, 18, 30, 23, 14);
JavaRDD<Integer> rdd1 = jsc.parallelize(integers);
JavaRDD<Integer> rdd2 = jsc.parallelize(integers1);
JavaRDD<Integer> union = rdd1.union(rdd2);

• distinct()
• 去重算子

List<Integer> ints = Arrays.asList(1, 2, 3, 4, 5, 5, 5, 7, 8, 2, 1, 3, 4);
JavaRDD<Integer> rdd1 = jsc.parallelize(ints);
rdd1.distinct().foreach(new VoidFunction<Integer>() {
    @Override
    public void call(Integer integer) throws Exception {
        System.out.println(integer);
    }
});

val ints = List(1, 2, 3, 4, 5, 5, 6, 6, 6, 6, 88, 7, 7, 5, 4, 3, 3, 2)
val rdd1: RDD[Int] = sc.parallelize(ints)
val rdd2: RDD[Int] = rdd1.distinct()
rdd2.foreach(println(_))

• sample()
• 抽样算子

List<Integer> ints = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
JavaRDD<Integer> rdd1 = jsc.parallelize(ints);
JavaRDD<Integer> sample = rdd1.sample(false, 0.2, 2);
long sampleDataSize  = sample.count();
long count = rdd1.count();
System.out.println(count + " and after the sampling: " + sampleDataSize);
sample.foreach(new VoidFunction<Integer>() {
    @Override
    public void call(Integer integer) throws Exception {
        System.out.println(integer);
    }
});

val ints = List(1, 2, 3, 4, 5, 6, 7, 7, 8, 8, 5, 3, 3, 2, 2)
val rdd: RDD[Int] = sc.parallelize(ints)
val sampleRdd = rdd.sample(false, 0.3, 2)
sampleRdd.foreach(println(_))

• intersection()
• 交集算子

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
List<Integer> integers1 = Arrays.asList(2, 3, 4, 5, 22, 33, 44, 55, 66, 77);
JavaRDD<Integer> javaRDD = jsc.parallelize(integers);
JavaRDD<Integer> javaRDD1 = jsc.parallelize(integers1);
JavaRDD<Integer> rdd = javaRDD.intersection(javaRDD1);
rdd.foreach(new VoidFunction<Integer>() {
    @Override
    public void call(Integer integer) throws Exception {
        System.out.println(integer);
    }
});

val ints = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val ints1 = List(2, 3, 4, 5, 77, 88, 99, 22, 11)
val rdd1 = sc.parallelize(ints)
val rdd2 = sc.parallelize(ints1)
val rdd3 = rdd1.intersection(rdd2)
rdd3.foreach(println)

• substract()
• 差集算子

List<Integer> int1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 10);
List<Integer> int2 = Arrays.asList(2, 3, 4, 5, 6, 7);
JavaRDD<Integer> rdd1 = jsc.parallelize(int1);
JavaRDD<Integer> rdd2 = jsc.parallelize(int2);
JavaRDD<Integer> javaRDD = rdd1.subtract(rdd2);
javaRDD.foreach(new VoidFunction<Integer>() {
    @Override
    public void call(Integer integer) throws Exception {
        System.out.println(integer);
    }
});

val ints = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val ints1 = List(2, 3, 4, 5, 6, 7, 8, 9)
val rdd1 = sc.parallelize(ints)
val rdd2 = sc.parallelize(ints1)
val rdd = rdd1.subtract(rdd2)
rdd.foreach(println)

• cartesion()
• 笛卡尔积算子

List<Integer> int1 = Arrays.asList(1, 2, 4, 5, 6, 7);
List<Integer> int2 = Arrays.asList(5, 6, 7, 8, 9, 10);
JavaRDD<Integer> rdd1 = jsc.parallelize(int1);
JavaRDD<Integer> rdd2 = jsc.parallelize(int2);
JavaPairRDD<Integer, Integer> rdd = rdd1.cartesian(rdd2);
rdd.foreach(new VoidFunction<Tuple2<Integer, Integer>>() {
    @Override
    public void call(Tuple2<Integer, Integer> integerIntegerTuple2) throws Exception {
        System.out.println(integerIntegerTuple2);
    }
});

val ints = List(1, 2, 3, 4, 5, 6)
val ints1 = List(5, 6, 7, 8, 9)
val rdd1 = sc.parallelize(ints)
val rdd2 = sc.parallelize(ints1)
val rdd = rdd1.cartesian(rdd2)
rdd.foreach(println)

• getPartition()
• 获取分区
• equal()
• 等价算子
• reduceByKey()
• PairRDD 中的合并算子
• groupByKey()
• PariRDD中的分组算子
• combineByKey()
• PariRDD中 … 有些模糊
• mapValues()
• PariRDD对相同键的值进行调整
• flatMapValues()
• PariRDD对相同键的值生成一个迭代函数
• keys()
• PariRDD返回一个仅含键的RDD
• values()
• PariRDD返回一个仅含值得RDD
• sortByKey()
• PariRDD返回一个根据键排序的RDD
• subtractByKey()
• PariRDD返回键差集的RDD
• join()
• PariRDD根据键内连接
• rightOuterJoin()
• PariRDD根据键右连接
• leftOuterJoin()
• PariRDD根据键左连接
• cogrop()
• PariRDD根据拥有的键分组
• foldByKey()
• PariRDD合并有相同的键的值
• partitionBy()
• RDD分区

执行算子

• count()
• 统计算子
• take()
• 返回n个元素
• collect()
• 收集所有的元素
• reduce()
• 并行聚集
• aggregete()
• 聚合
• countByValue()
• 根据key收集值
• top()
• 选取最大的前几个
• takeOrderd()()
• 根据条件查询返回几个元素
• takeSample()
• 抽样返回几个
• foreach()
• 枚举
• perisit()
• 硬盘化
• countByKey()
• 根据key统计
• collectAsMap()
• 收集后作为Map
• lookup()
• 返回给定值对应的所有值