Spark编程模型Transformation操作一

基本Transformation使用
1、map
2、filter
3、flatMap
4、mapPartitions
5、mapPartitionsWithIndex
6、sample

案例和注释

package com.paic.Spark;

import org.apache.spark.SparkConf;
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.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * Created by xlucas on 2018/3/29.
 */
public class SparkDemo1 {
    public static void main(String[] args){
        SparkConf conf= new SparkConf();
        conf.setMaster("local[2]");
        conf.setAppName("SparkDemo1");
        JavaSparkContext sc=new JavaSparkContext(conf);
        //显示日志的级别
        // ALL,DEBUG,ERROR,FATAL,INFO,OFF,TRACE,WARN
        sc.setLogLevel("ERROR");
        JavaRDD<String> rdd1=sc.textFile("D:\\date\\*.txt",2);
        System.out.println(sc.sparkUser()+" "+sc.isLocal()+"    "+sc.startTime()+"  "+sc.defaultMinPartitions());
        // map 里面 需要实现Function函数，里面实现了 call的方法,返回是一个单一的值
        //map 里面返回的值类型和回调函数里面的最后一个参数类型一样，可以是单一的值也可以是list
        System.out.println(rdd1.map(new Function<String, List<String>>() {
            @Override
            public List<String> call(String str) throws Exception {
                return Arrays.asList(str.split(" "));
            }
        }).collect());
        rdd1.map(new Function<String,String>(){
            @Override
            public String call(String s) throws Exception {
                return s.contains("kafka")?"true1":"flase1";
            }
        }).foreach(new VoidFunction<String>() {
            @Override
            public void call(String s) throws Exception {
                System.out.print(s+" ");
            }
        });
        System.out.println();
        System.out.println(rdd1.map(new Function<String,String>(){
            @Override
            public String call(String s) throws Exception {
                return s.contains("kafka")?"true":"flase";
            }
        }).collect());
        // filter 里面的函数function实现call方法返回的是一个boolean 类型
        System.out.println(rdd1.filter(new Function<String, Boolean>() {
            @Override
            public Boolean call(String str) throws Exception {
                return str.contains("kafka");
            }
        }).collect());
        // flatMap 返回的是一个seq
        //faltMap的函数应用于每一个元素，对于每一个元素返回的是多个元素组成的迭代器
        System.out.println(rdd1.flatMap(new FlatMapFunction<String, String>() {

            @Override
            public Iterable<String> call(String str) throws Exception {
                return Arrays.asList(str.split(" "));
            }
        }).collect());
        //与map方法类似，map是对rdd中的每一个元素进行操作，而mapPartitions(foreachPartition)则是对rdd中的每个分区的迭代器进行操作。
        // 如果在map过程中需要频繁创建额外的对象(例如将rdd中的数据通过jdbc写入数据库,
        // map需要为每个元素创建一个链接而mapPartition为每个partition创建一个链接),则mapPartitions效率比map高的多。
        //SparkSql或DataFrame默认会对程序进行mapPartition的优化。
        rdd1.mapPartitions(new FlatMapFunction<Iterator<String> , String>() {
            @Override
            public Iterable<String> call(Iterator<String> str) throws Exception {
                ArrayList<String> result=new ArrayList<>();
                while(str.hasNext()){
                    result.add(str.next());
                }
                return  result;
        }}).foreach(new VoidFunction<String>() {
            @Override
            public void call(String s) throws Exception {
                System.out.println(s);
            }
        });
        //和mapPartitions类似，但func带有一个整数参数表上分区的索引值，
        // 在类型为T的RDD上运行时，func的函数参数类型必须是(int,Iterator[T])=>Iterator[U]
        //Integer, Iterator<String>, Iterator<Tuple2<Integer,String>>
        // 索引地址   输入值          返回值
        rdd1.mapPartitionsWithIndex(new Function2<Integer, Iterator<String>, Iterator<Tuple2<Integer,String>>>() {
            @Override
            public Iterator<Tuple2<Integer, String>> call(Integer integer, Iterator<String> str) throws Exception {
                ArrayList<Tuple2<Integer, String>> tuple2s = new ArrayList<>();
                while (str.hasNext()) {
                    String next = str.next();
                    tuple2s.add(new Tuple2<>(integer,next));
                }
                return tuple2s.iterator();
            }
        },false).foreach(new VoidFunction<Tuple2<Integer, String>>() {
            @Override
            public void call(Tuple2<Integer, String> s) throws Exception {
                System.out.println(s);
            }
        });
        //withReplacement 这个是true 结果可以是重复rdd1中的数据 false 结果只从rdd1中的样本，不能重复
        //fraction 0到1的值
        //返回一个随机的样本
        System.out.println(rdd1.sample(true,0.5).collect());

    }
}