Spark的WordCount

版权声明：版权声明：本文为博主原创文章，转载请附上博文链接！ https://blog.csdn.net/qq_42246689/article/details/86062997

8、Spark的WordCount

8.1、Scala 版本的 WordCount 

packge com.mazh.spark

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

/*
 *作者:https://blog.csdn.net/qq_42246689
 *
 */

object WordCount { 
 
  def main(args: Array[String]): Unit = { 
 
    // 创建一个 SparkConf对象，并设置程序的名称 
    val conf = new SparkConf().setAppName("WordCount") 
    conf.setMaster("local") 
 
    // 创建一个 SparkContext对象 
    val sc = new SparkContext(conf) 
 
    // 读取 HDFS上的文件构建一个 RDD 
    val fileRDD = sc.textFile("hdfs://myha01/spark/wc/input") 
    //  val fileRDD = sc.textFile(args(0)) 
 
    // 构建一个单词 RDD 
    val wordAndOneRDD = fileRDD.flatMap(_.split(" ")).map((_, 1)) 
 
    // 进行单词的聚合
    val resultRDD = wordAndOneRDD.reduceByKey(_+_) 
 
    // 对 resultRDD进行单词出现次数的降序排序，然后写出结果到 HDFS 
    resultRDD.sortBy(_._2, 
false).saveAsTextFile("hdfs://myha01/spark/wc/output_spark33") 
    //  resultRDD.sortBy(_._2, false).saveAsTextFile(args(1)) 
 
    sc.stop() 
  } 
}

8.2、Java7版本的WordCount

package com.mazh.spark.wc; 
 
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 scala.Tuple2; 
 
import java.util.Arrays; 
import java.util.Iterator; 
public class JavaWordCount { 
    public static void main(String[] args){ 
        if(args.length!=2){ 
            System.out.println("Usage:JavaWordCount<input><output>"); 
            System.exit(1); 
        } 
        SparkConf conf = new SparkConf(); 
        conf.setMaster("local"); 
        conf.setAppName(JavaWordCount.class.getSimpleName()); 
        JavaSparkContext jsc = new JavaSparkContext(conf); 
        JavaRDD<String> line = jsc.textFile(args[0]); 
        // 切割压平   flatMap()  两个参数，一个输入类型，一个输出类型
         JavaRDD<String> jrdd1 = line.flatMap(new FlatMapFunction<String, String>() 
{ 
            @Override 
            public Iterator<String> call(String s) throws Exception { 
                // 该方法的返回值类型是 Iterator, 需要把 Array类型的结果转换为迭代器类型的
  return Arrays.asList(s.split(" ")).iterator(); 
            } 
        }); 
        // 和 1
组合成元组  mapToPair() 第一个参数，输入数据类型，第二个参数是元组的 key
类
型，第三个参数是元组的 value
类型 
        JavaPairRDD<String, Integer> javaPairRDD = jrdd1.mapToPair(new 
PairFunction<String, String, Integer>() { 
            @Override 
            public Tuple2<String, Integer> call(String s) throws Exception { 
                return new Tuple2<String, Integer>(s, 1); 
            } 
        }); 
        // 分组聚合  reduceByKey()  (a,b)=>a+b   第三个参数：返回值的类型         JavaPairRDD<String, Integer> result = javaPairRDD.reduceByKey(new 
Function2<Integer, Integer, Integer>() { 
            @Override 
            public Integer call(Integer v1, Integer v2) throws Exception { 
                return v1 + v2; 
            } 
        }); 
        // 先在本地测试一下
        /* result.foreach(new VoidFunction<Tuple2<String, Integer>>() { 
            @Override 
            public void call(Tuple2<String, Integer> tuple) throws Exception { 
                System.out.println(tuple); 
            } 
        });*/ 
       // 可以进行排序
         JavaPairRDD<Integer, String> res1 = result.mapToPair(new 
PairFunction<Tuple2<String, Integer>, Integer, String>() { 
            @Override 
            public Tuple2<Integer, String> call(Tuple2<String, Integer> t) throws 
Exception { 
                return t.swap(); 
            } 
        }); 
        // 排序，默认是升序，如果需要降序，参数 false 
        JavaPairRDD<Integer, String> res2 = res1.sortByKey(false); 
        JavaPairRDD<String, Integer> finalRes = res2.mapToPair(new 
PairFunction<Tuple2<Integer, String>, String, Integer>() { 
            @Override 
            public Tuple2<String, Integer> call(Tuple2<Integer, String> t) throws 
Exception { 
                return t.swap(); 
 } 
        }); 
        // 保存
         finalRes.saveAsTextFile(args[1]); 
        // 释放资源
         jsc.close(); 
    } 
}

8.3、Java8 Lambda 表达式版本的 WordCount 

package com.mazh.spark.wc; 
 
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(); 
    } 
}