Spark集合操作API之交并集、笛卡尔积、Join

1、交并集、笛卡尔积

val rdd1: RDD[Int] = sc.parallelize( List( 1,2,3,4,5)  )
val rdd2: RDD[Int] = sc.parallelize( List( 3,4,5,6,7)  )

-- 并集：union操作；union操作只是将2个RDD合并成一个，并没有发生数据计算
-- 并集是窄依赖(one to one deps)
rdd1.union(rdd2).foreach(println)    //1 2 3 4 5 3 4 5 6 7

-- 交集：intersection
--交集是shuffle依赖
rdd1.intersection(rdd2).foreach(print) //3 4 5

-- 差集:subtract操作，subtract是shuffle依赖
-- 注意，差集是有方向的，rdd1.subtract(rdd2)和rdd2.subtract(rdd1)结果是不一样的
rdd1.subtract(rdd2).foreach(print) //1 2
rdd2.subtract(rdd1).foreach(print) //6 7

-- 笛卡尔积cartesian
-- 如果数据不需要区分每一条记录归属于那个分区，这样的数据不需partitioner，不需要shuffle，所以，cartesian是窄依赖
-- (1,3)(1,4)(1,5)(1,6)(1,7)(2,3)(2,4)(2,5)(2,6)(2,7)(3,3)(3,4)(3,5)(3,6)(3,7)(4,3)(4,4)(4,5)(4,6)(4,7)(5,3)(5,4)(5,5)(5,6)(5,7)
rdd1.cartesian(rdd2).foreach(print)

2、 关联

   val kv1: RDD[(String, Int)] = sc.parallelize(List(
      ("zhangsan", 11),
      ("zhangsan", 12),
      ("lisi", 13),
      ("wangwu", 14)
    ))
     val kv2: RDD[(String, Int)] = sc.parallelize(List(
      ("zhangsan", 21),
      ("zhangsan", 22),
      ("lisi", 23),
      ("zhaoliu", 28)
    ))

	-- join，join是shuffle依赖
	-- join的逻辑与mysql中的join是一样的，注意：如果两个相同的key在一个RDD中，它们不会发生join，也不会变成一个(key,value)类型，比如key'zhangsan'。
	-- (zhangsan,(11,21))(zhangsan,(11,22))(zhangsan,(12,21))(zhangsan,(12,22))(lisi,(13,23))
    val join: RDD[(String, (Int, Int))] = kv1.join(kv2)
    join.foreach(println)

	--leftOuterJoin，leftOuterJoin是shuffle依赖
	--leftOuterJoin的逻辑与mysql中的leftOuterJoin逻辑是一样的，只会选左边的数据集进行join操作，如果右边没有相同的key，就返回none
	-- (zhangsan,(11,Some(21)))(zhangsan,(11,Some(22)))(zhangsan,(12,Some(21)))(zhangsan,(12,Some(22)))(wangwu,(14,None))(lisi,(13,Some(23)))
	val left: RDD[(String, (Int, Option[Int]))] = kv1.leftOuterJoin(kv2)
    left.foreach(print)