Spark_3

学习Spark第三天
一.常用transformation

package main;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class Transfromtion {
    public static void main(String[] args) {
//        myMap();
//结果:
//        2
//        4
//        6
//        8
//        10
//        12

//        myFilter();
//结果:
//        2
//        4
//        6
//        8
//        10

//        myFlatMap();
//结果:
//        hello
//        me
//        hello
//        you
//        hello
//        world

//        myGroupByKey();
//结果:
//        班级:class1
//        85
//        49
//        92
//        =========================
//        班级:class2
//        56
//        89
//        68
//        =========================

//        myReduceByKey();
//结果:
//        class1:71
//        class2:57

//        mySortByKey();
//结果:
//        45:xiaobao
//        60:daqiang
//        71:wangwu
//        92:xiaozhang
//        100:xiaoli

//        myJoinAndCogroup();
//结果:
//        1:zhansan:99
//        3:wangwu:56
//        2:lisi:89
//        ================================
//        1:[zhansan]:[45, 78]
//        3:[wangwu]:[38, 58]
//        2:[lisi]:[82, 76]
//    }

//    map算子：对每一个元素*2
    private static void myMap(){
        SparkConf conf = new SparkConf().setMaster("local").setAppName("myMap");

        JavaSparkContext sc = new JavaSparkContext(conf);

        //构建集合
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        //并行化集合，初始RDD
        JavaRDD<Integer> numbersRDD = sc.parallelize(numbers);
        //使用map算子，将集合中的每个元素*2
        // map算子，是对任何算数据类型的RDD都可以调用的
        // 在java中，map算子接收的参数是Function对象
        // 创建的Function对象，一定会让你设置第二个参数，这个泛型参数，就是返回新元素的类型
        // 同时call()方法的返回类型，也必须与第二个个泛型类型同步
        // 在call()可以对原始数据进行各种操作，并返回一组新的元素组成一个新的RDD
        JavaRDD<Integer> map = numbersRDD.map(new Function<Integer, Integer>() {
            @Override
            public Integer call(Integer integer) throws Exception {
                return integer * 2;
            }
        });
        // 打印新的RDD中的内容
        map.foreach(new VoidFunction<Integer>() {
            @Override
            public void call(Integer integer) throws Exception {
                System.out.println(integer);
            }
        });
        sc.close();
    }


//    filter算子函数：过滤集合总的偶数
    private static void myFilter(){
        SparkConf conf = new SparkConf().setAppName("myFilter").setMaster("local");

        JavaSparkContext sc = new JavaSparkContext(conf);

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        JavaRDD<Integer> numberRDD = sc.parallelize(numbers);
        //对初始RDD执行filter算子，将其中的偶数过滤出来
        //filter传入的也是faction，其他的输赢注意点，实际和map是一样的
        //每一个RDD初始化中的元素，都会传入call()方法，此时你可以执行各种自定义的计算逻辑
        //莱帕胺段这个元素石佛营是你想要的
        //如果你想要在新的RDD中保留这个元素，那么就返回true；否则，不想保留这个元素，返回false
        JavaRDD<Integer> filter = numberRDD.filter(new Function<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) throws Exception {
                return integer % 2 == 0;
            }
        });
        filter.foreach(new VoidFunction<Integer>() {
            @Override
            public void call(Integer integer) throws Exception {
                System.out.println(integer);
            }
        });
        sc.close();
    }

    /*
    flatMap案例:将文本拆分成多个单词
     */
    private static void myFlatMap(){
        SparkConf conf = new SparkConf().setMaster("local").setAppName("myFlatMap()");

        JavaSparkContext sc = new JavaSparkContext(conf);

        //模拟集合
        List<String> lineList = Arrays.asList("hello me", "hello you", "hello world");

        JavaRDD<String> lines = sc.parallelize(lineList);
        //对RDD执行fletMap算子,将每一行文本,拆分成多个单词
        //flatMap算子,在Java中,接受的参数是flatMapFunction
        //我们需要自己定义FlatMapFunction的第二个泛型类型,即,代表了返回新的元素的类型
        //call()方法 ,返回类型,不是object,而是Iterable