saprk版本的wordCount

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 ;
导入 scala.Tuple2 ;
import java.util.Arrays ;
import java.util.Iterator ;
/ **


* java版本的WordCount
 * Spark版本的
 APi * /
 public class JavaWordCounts {
     public static void main（String [] args）{
        SparkConf CONF = 新。SparkConf（）setAppName（JavaWordCount 类 .getSimpleName（））setMaster（ “ 本地”）;
        JavaSparkContext jsc = new JavaSparkContext（conf）;
        JavaRDD <String> lines = jsc.textFile（args [ 0 ]）;
        JavaRDD <字符串>词语= lines.flatMap（新 FlatMapFunction <字符串，字符串>（）{
             @覆盖
 公共迭代<字符串> 呼叫（字符串线）抛出异常{
                 返回阵列。asList（line.split（ “”            ））。iterator（）;
            }
        }）;
        JavaPairRDD <字符串，整数> wordAndOne = words.mapToPair（新 PairFunction <字符串，字符串，整数>（）{
             @覆盖
 公共 Tuple2 <字符串，整数> 呼叫（字符串字）抛出异常{
                 返回新 Tuple2 <>（字，1）;
 }                        
        }）;
        JavaPairRDD <String ， Integer> reduced = wordAndOne.reduceByKey（new Function2 <Integer ， Integer ， Integer>（）{
             @Override
 public Integer call（Integer v1 ， Integer v2）throws Exception {
                 return v1 + v2 ;
 }                        
        }）;
//交换顺序
 JavaPairRDD <Integer ， String> swap = reduced.mapToPair （新的 PairFunction <Tuple2 <String ， Integer> ， Integer ， String>（）{
             @
 Override public Tuple2 <Integer ， String> call（Tuple2 <String ， Integer> tp）抛出异常{
                 / *返回新的Tuple2 <>（tp._2，tp._1）; * /
 return tp.swap（）;
 }                                                        
        }）;
//排序
 JavaPairRDD <Integer ， String> sorted = swap.sortByKey（false）;
//调整顺序
 JavaPairRDD <String ， Integer> result = sorted.mapToPair（new PairFunction <Tuple2 <Integer ， String> ， String ， Integer>（）{
             @
 Override public Tuple2 <String ， Integer> call（Tuple2 <Integer ， String> tp2）抛出 Exception {
                 return tp2.swap（）;
 }                                                        
        }）;
//将数据保存到hdfs
 result.saveAsTextFile（args [ 1 ]）;
jsc.stop（）;}

import org.apache.spark.rdd.RDD
 import org.apache.spark。{SparkConf ， SparkContext}

/ **
   *由巨大创建
   *日期：2018/6/14
   *描述：
   * spark scala语法的wordcount
   * /
 object ScalaWordCount {


  def main（args：Array [ String ]）：Unit = {

    if（args.length！= 2）{
       println（“Usage：cn.huge.spark33.day01.ScalaWordCount <input> <output>”）
      SYS。退出（1）
    }

    //参数接收
 val Array（input ， output）= args    



    val conf：SparkConf = new SparkConf（）
     //创建SparkContext
 val sc：SparkContext = new SparkContext（conf）    

    //理论可以一行搞定，实际不推荐
     //缩略图（“”） “）
     //读取数据
 val file：RDD [ String ] = sc.textFile（input）
    

    //切分并压平
 val words：RDD [ String ] = file.flatMap（_。split（“”））    

    //组装
 VAL wordAndOne：RDD [（字符串，整数）] = words.map（（_ ，1））
     //分组聚合
 VAL结果：RDD [（字符串，整数）] = wordAndOne.reduceByKey（_ + _）        

    //排序降序
     //第一种 - 第二种：第二个参数
 val finalRes：RDD [（String ，Int）] = result.sortBy（_._ 2 ，false）    

    //直接存储到hdfs中
     finalRes.saveAsTextFile（输出）

    //释放资源
     sc.stop（）

  }
}

import org.apache.spark.rdd.RDD
 import org.apache.spark。{SparkConf ， SparkContext}


/ **
 集群模式
 * /
 object ScalaWordCount {



  def main（args：Array [ String ]）：Unit = {

    if（args.length！= 2）{
       println（“Usage：cn.huge.spark33.day01.ScalaWordCount <input> <output>”）
      SYS。退出（1）
    }

    //参数接收
 val Array（input ， output）= args    



    val conf：SparkConf = new SparkConf（）
     //创建SparkContext
 val sc：SparkContext = new SparkContext（conf）    

    //理论可以一行搞定，实际不推荐
     //缩略图（“”） “）
     //读取数据
 val file：RDD [ String ] = sc.textFile（input）
    

    //切分并压平
 val words：RDD [ String ] = file.flatMap（_。split（“”））    

    //组装
 VAL wordAndOne：RDD [（字符串，整数）] = words.map（（_ ，1））
     //分组聚合
 VAL结果：RDD [（字符串，整数）] = wordAndOne.reduceByKey（_ + _）        

    //排序降序
     //第一种 - 第二种：第二个参数
 val finalRes：RDD [（String ，Int）] = result.sortBy（_._ 2 ，false）    

    //直接存储到hdfs中
     finalRes.saveAsTextFile（输出）

    //释放资源
     sc.stop（）

  }
}

import org.apache.spark.rdd.RDD
 import org.apache.spark。{SparkConf ， SparkContext}

/ **        本地模式
   *  * /
 object ScalaWordCountLocal {


  def main（args：Array [ String ]）：Unit = {

    if（args.length！= 2）{
       println（“Usage：cn.huge.spark33.day01.ScalaWordCount <input> <output>”）
      SYS。退出（1）
    }

    //参数接收
 val Array（input ， output）= args    

    val conf：SparkConf = 新的 SparkConf（）

    conf.setMaster（“local [3]”）// 2个内核
     conf.setAppName（this .getClass.getSimpleName）

    //创建SparkContext
 val sc：SparkContext = new SparkContext（conf）    

    //读取数据
 val file：RDD [ String ] = sc.textFile（input）    

    //切分并压平
 val words：RDD [ String ] = file.flatMap（_。split（“”））    

    //组装
 VAL wordAndOne：RDD [（字符串，整数）] = words.map（（_ ，1））
     //分组聚合
 VAL结果：RDD [（字符串，整数）] = wordAndOne.reduceByKey（_ + _）        

    //排序降序
     //第一种 - 第二种：第二个参数
 val finalRes：RDD [（String ，Int）] = result.sortBy（_._ 2 ，false）    

    //获取分区数据的API
 println（finalRes.partitions.size）    

    //直接存储到hdfs中
     finalRes.saveAsTextFile（输出）

    //释放资源
     sc.stop（）

  }
}