spark wordcount 提交运行

spark-submit --master spark://127.0.0.1:7077 --class com.WordCountLocal /usr/local/soft/com.spark-1.0-SNAPSHOT.jar

package com;

/**
 * Created by kcz on 2017/2/18.
 */

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

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.Function2;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.api.java.function.VoidFunction;

import scala.Tuple2;


public class WordCountLocal implements Serializable{

    private static final long serialVersionUID = -5528440737714481080L;

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("1");
        list.add("3");
        list.add("2");
        SparkConf conf = new SparkConf()
                .setAppName("WordCountLocal")
                .setMaster("local");


        JavaSparkContext sc = new JavaSparkContext(conf);

        JavaRDD<String> lines = sc.parallelize(list);


        JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>(){

            @Override
            public Iterator<String> call(String s) throws Exception {

                return Arrays.asList(s.split(" ")).iterator();
            }

            private static final long serialVersionUID = -5344820265599150266L;
        });

// 接着，需要将每一个单词，映射为(单词, 1)的这种格式
        // 因为只有这样，后面才能根据单词作为key，来进行每个单词的出现次数的累加
// mapToPair，其实就是将每个元素，映射为一个(v1,v2)这样的Tuple2类型的元素
        // 如果大家还记得scala里面讲的tuple，那么没错，这里的tuple2就是scala类型，包含了两个值
// mapToPair这个算子，要求的是与PairFunction配合使用，第一个泛型参数代表了输入类型
        // 第二个和第三个泛型参数，代表的输出的Tuple2的第一个值和第二个值的类型
// JavaPairRDD的两个泛型参数，分别代表了tuple元素的第一个值和第二个值的类型
        JavaPairRDD<String, Integer> pairs = words.mapToPair(

                new PairFunction<String, String, Integer>() {

                    private static final long serialVersionUID = 1L;

                    @Override
                    public Tuple2<String, Integer> call(String word) throws Exception {
                        return new Tuple2<String, Integer>(word, 1);
                    }

                });

// 接着，需要以单词作为key，统计每个单词出现的次数
// 这里要使用reduceByKey这个算子，对每个key对应的value，都进行reduce操作
// 比如JavaPairRDD中有几个元素，分别为(hello, 1) (hello, 1) (hello, 1) (world, 1)
// reduce操作，相当于是把第一个值和第二个值进行计算，然后再将结果与第三个值进行计算
// 比如这里的hello，那么就相当于是，首先是1 + 1 = 2，然后再将2 + 1 = 3
// 最后返回的JavaPairRDD中的元素，也是tuple，但是第一个值就是每个key，第二个值就是key的value
// reduce之后的结果，相当于就是每个单词出现的次数
        JavaPairRDD<String, Integer> wordCounts = pairs.reduceByKey(

                new Function2<Integer, Integer, Integer>() {

                    private static final long serialVersionUID = 1L;

                    @Override
                    public Integer call(Integer v1, Integer v2) throws Exception {
                        return v1 + v2;
                    }

                });

// 到这里为止，我们通过几个Spark算子操作，已经统计出了单词的次数
// 但是，之前我们使用的flatMap、mapToPair、reduceByKey这种操作，都叫做transformation操作
// 一个Spark应用中，光是有transformation操作，是不行的，是不会执行的，必须要有一种叫做action
// 接着，最后，可以使用一种叫做action操作的，比如说，foreach，来触发程序的执行
        wordCounts.foreach(new VoidFunction<Tuple2<String,Integer>>() {

            private static final long serialVersionUID = 1L;

            @Override
            public void call(Tuple2<String, Integer> wordCount) throws Exception {
                System.out.println(wordCount._1 + " appeared " + wordCount._2 + " times.");
            }

        });

        sc.close();
    }



}