Spark---Java和Scala版本的WordCount

Java版本地WordCount

package cn.spark.core._01_core_basic;

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;

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


/**
 * 统计一个文件中每个单词出现的次数,wordCount经典案例
 */
public class _01_WordCountLocal {
    public static void main(String[] args) {
        //编写Spark应用程序
        //本地执行,是可以在main方法中执行的

        //第一步:创建SparkConf对象,设置Spark应用的配置信息
        //使用setMaster()可以设置spark应用程序要连接的spark集群的master的url;但是如果设置为local,则代表在本地运行
        SparkConf conf = new SparkConf()
                .setAppName("WordCountLocal")
                .setMaster("local");

        //第二步:创建javaSparkContext对象
        //在Spark中,SparkContext是spark所有功能的一个入口,无论是java,scala,Python编写,都必须要有一个SparkContext,它主要作用
        //包括初始化Spark应用程序所需要的一些核心组件,包括调度器(DAGSchedule,TaskSchedule),还会去到Spark Master节点上进行注册
        //等等,一句话:SparkContext是spark应用中,可是说是最最重要的一个对象
        //但是呢,在spark中,编写不同类型的spark应用程序,使用sparkContext是不同的,比如说使用scala,使用的就是原生的SparkContext对象
        //但是如果使用java,即使使用JavaSparkContext对象
        //如果是开发Spark SQL程序,那么就是SQLContext\HiveContext
        //如果是开发Spark Streaming 程序,那么它就是独有的SparkContext
        //依次类推

        JavaSparkContext sc = new JavaSparkContext(conf);

        //第三步:要针对输入源(hdfs文件,本地文件,等等),创建一个初始的RDD
        //输入源的数据会的打散,分配到RDD的每个partition中,从而形成一个初始的分布式的数据集
        //我们这里呢,因为是本地测试,所以呢,就是针对本地文件
        //SparkContext中,用于根据文件类型的输入源创建RDD的方法,叫做textFile()方法
        //在java中,创建的普通RDD,都叫做javaRDD
        //在这里呢,RDD中,有元素这种概念,如果是hdfs或者是本地文件呢,创建的RDD,每一个元素就相当于文件里一行

        JavaRDD<String> lines = sc.textFile("D:/testcore.txt");

        //第四步:对初始RDD进行transformation操作,也就是一些计算操作
        //通常操作会通过创建function,并配合RDD的map,flatMap等算子来执行
        //function,通常如果比较简单,则创建指定的function的匿名内部类
        //但是如果function比较复杂,则会单独创建一个类,作为实现这个Function接口的类

        //先将每一行拆分成单个的单词
        //FlatMapFunction,有两个泛型的参数,分别是代表了输入和输出类型
        //我们这里呢,输入肯定是String,因为是一行一行的文本,输出,其实也是String,因为是每一行的文本
        //这里先简要介绍flatMap算子的作用,其实就是,将RDD的一个元素,给拆分成一个或者多个的元素
        JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public Iterator<String> call(String line) throws Exception {
                List<String> strings = Arrays.asList(line.split("\\s+"));
                return strings.iterator();
            }
        });

        //接着,需要将每一个单词映射为(单词,1)的这种格式
        //因为只有这样,后面才能根于单词作为key,来进行每个单词的出现次数的累加
        //mapToPair,其实就是将每个元素,映射为(v1,v2)这样的Tuple2类型的元素
        //这里的tuple2就是scala类型,包含了两个值
        //mapToPair这个算子,要求的是与PairFunction配合使用,第一个泛型参数代表了输入类型,第二个和第三个泛型参数,代表的是输出的tuple2的第一个
        //和第二个值的类型
        //JavaPairRDD的两个泛型类型,分别代表了tuple元素的第一个值和第二个值的类型

        JavaPairRDD<String, Integer> pairs = words.mapToPair(new PairFunction<String, String, Integer>() {
            @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>() {
            @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>>() {
            @Override
            public void call(Tuple2<String, Integer> wordcount) throws Exception {
                System.out.println(wordcount._1+" : "+wordcount._2+" times");
            }
        });

        sc.close();
    }
}

Java使用Lambda表达式

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 scala.Tuple2; 
 
import java.util.Arrays; 

public class JavaLambdaWordCount { 
    public static void main(String[] args){ 
        if(args.length!=2){ 
            System.out.println("Usage JavaLambdaWordCount<input><output>"); 
            System.exit(1); 
        } 
 
        SparkConf conf = new SparkConf(); 
        conf.setMaster("local"); 
        conf.setAppName(JavaLambdaWordCount.class.getSimpleName()); 
        JavaSparkContext jsc = new JavaSparkContext(conf); 
        // 读取数据         
        JavaRDD<String> jrdd = jsc.textFile(args[0]); 
        // 切割压平         
        JavaRDD<String> jrdd2 = jrdd.flatMap(t -> Arrays.asList(t.split(" ")).iterator()); 
        // 和 1组合 
        JavaPairRDD<String, Integer> jprdd = jrdd2.mapToPair(t -> new Tuple2<String, Integer>(t, 1)); 
        // 分组聚合         
        JavaPairRDD<String, Integer> res = jprdd.reduceByKey((a, b) -> a + b); 
        // 保存         
        res.saveAsTextFile(args[1]); 
       // 释放资源         
        jsc.close(); 
    } 
} 

 

Scala版本地WordCount

package cn.spark.core._01_core_basic

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object _01_WordCountLocalOfScala {

  def main(args: Array[String]): Unit = {

    val conf: SparkConf = new SparkConf()
      .setAppName("_01_WordCountLocal")
      .setMaster("local")

    //这个和java有区别  不要混淆了
    val sc = new SparkContext(conf)

    val lines: RDD[String] = sc.textFile("F:/testdate/01wc.txt")
    val words: RDD[String] = lines.flatMap(line => line.split("\\s+"))
    val pairs: RDD[(String, Int)] = words.map(word => (word,1))
    val wordcount: RDD[(String, Int)] = pairs.reduceByKey(_ + _)

    wordcount.foreach(wordcount => println(wordcount._1 + " : " + wordcount._2 + " times"))

  }
}