spark概述及Java wordcount、Scala wordcount

最新推荐文章于 2024-04-30 11:17:29 发布
最新推荐文章于 2024-04-30 11:17:29 发布
阅读量229 收藏
点赞数
分类专栏： spark 文章标签： spark概述 spark scala wordcount spark java wordcount
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sltylzx/article/details/91355140
版权

1.spark是什么

[1].官网 http://spark.apache.org/

[2].是什么

Apache Spark™ is a fast and general engine for large-scale data processing.

Apache Spark is an open source cluster computing system that aims to make data analytics fast

both fast to run and fast to wrtie

[3].Speed（速度）

基于内存速度是hadoop的100+倍

基于磁盘速度是hadoop的10+倍

[4].Ease of Use（易用性）

Write applications quickly in Java, Scala, Python, R, and SQL.

[5].Generality（通用性）

Combine SQL, streaming, and complex analytics.

[6].Runs Everywhere

Spark runs on Hadoop, Apache Mesos, Kubernetes, standalone, or in the cloud. It can access diverse data sources.

[7].One stack rule them all

2.技术栈

3.Spark4种模式可以运行

[1].Local

多用于本地测试，如在eclipse，idea中写程序测试等。

[2].Standalone

Standalone是Spark自带的一个资源调度框架，它支持完全分布式。

[3].Yarn

Hadoop生态圈里面的一个资源调度框架，Spark也是可以基于Yarn来计算的。

要基于Yarn来进行资源调度，必须实现AppalicationMaster接口，Spark实现了这个接口，所以可以基于Yarn。

[4].Mesos

一个通用的资源调度框架。

4.Spark VS MapReduce

[1].MapReduce

[2].Spark，另外：Spark快的原因除了基于内存以外，还有一个重要原因就是DAG（负责任务的逻辑调度，负责将作业拆分成不同阶段的具有依赖关系的多批任务。）

5.wordcount

[0].准备

①.数据

bamor java
scala kotlin groovy
android w4xj h5 java
hadoop groovy kotlin griffon
java bamor

②.jar

spark-assembly-1.6.0-hadoop2.6.0.jar

[1].Scala版本

①.代码

package com.w4xj.scala.spark.wordcount





import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.rdd.RDD





/**

* @author w4xj

* @date 2019年6月7日 10:32:38

* 基于scala的spark wordcount

*/

object ScalaSparkWordcount {

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

//        val conf = new SparkConf()

//        conf.setMaster("local").setAppName("ScalaSparkWordcount")

//        val sc = new SparkContext(conf)

//        val lines: RDD[String] = sc.textFile("./words")

//        val words = lines.flatMap(line => {

//          line.split(" ")

//        })

//        val pairWords: RDD[(String, Int)] = words.map(word => {

//          new Tuple2(word, 1)

//        })

//    

//        val result: RDD[(String, Int)] = pairWords.reduceByKey((v1: Int, v2: Int) => {

//          v1 + v2

//        })

//    

//        //这里用sortByKey来，指定按次数排序

//        //先将次数和单词在而元祖的位置进行交换

//        val resultTmp1:RDD[(Int, String)] = result.map(tuple => {tuple.swap})

//        //排序（升序）

//        val resultTmp2:RDD[(Int, String)] =resultTmp1.sortByKey(true)

//        //再将二元祖调换为原来的顺序

//        val resultFinal:RDD[(String, Int)] = resultTmp2.map(tuple => {tuple.swap})

//        

//        resultFinal.foreach(tuple => {

//          println(tuple)

//        })

//    

//        sc.stop()



    

    //简写

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

    val sc = new SparkContext(conf)

    //这里用的sortBy()排序，指定按次数排序（升序）

    sc.textFile("./words").flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _).sortBy(tuple => {tuple._2}, true).foreach(println)

    sc.stop()

  }

}

②.运行结果

(scala,1)
(hadoop,1)
(h5,1)
(android,1)
(griffon,1)
(w4xj,1)
(kotlin,2)
(groovy,2)
(bamor,2)
(java,3)

[2].java版本

①.代码

package com.w4xj.java.spark.wordcount;

import java.util.Arrays;

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;

/**

* @author w4xj

* @date 2019年6月7日 10:32:38

* 基于java的spark wordcount

*/

public class JavaSparkWordCount {

     public static void main(String[] args) {

          /**

           * conf

           *   1.可以设置spark的运行模式

           *   2.可以设置spark在webui中显示的application的名称。

           *   3.可以设置当前spark application 运行的资源:内存+core（4核8线程看做8个core）

           *

           * Spark运行模式：

           *   1.local --在eclipse ，IDEA中开发spark程序要用local模式，本地模式，多用于测试

           *  2.standalone -- Spark 自带的资源调度框架，支持分布式搭建,Spark任务可以依赖standalone调度资源

           *  3.yarn -- hadoop 生态圈中资源调度框架。Spark  也可以基于yarn 调度资源

           *  4.mesos -- 资源调度框架

           */

          SparkConf conf = new SparkConf();

          conf.setMaster("local");

          conf.setAppName("JavaSparkWordCount");

          

          /**

           * SparkContext 是通往集群的唯一通道

           */

          JavaSparkContext sc  = new  JavaSparkContext(conf);

          /**

           * sc.textFile 读取文件

           */

          JavaRDD<String> lines = sc.textFile("./words");

          

          /**

           * flatMap 进一条数据出多条数据，一对多关系

           */

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

//

//            /**

//             *

//             */

//            private static final long serialVersionUID  = 1L;

//

//            @Override

//            public Iterable<String> call(String line)  throws Exception {

//                 return Arrays.asList(line.split(" "));

//            }

//        });

          

          //lambda表达式

          JavaRDD<String> words = lines.flatMap((String  line) -> {

              return Arrays.asList(line.split(" "));

          });

          

          /**

           * 在java中 如果想让某个RDD转换成K,V格式 使用xxxToPair

           * K,V格式的RDD:JavaPairRDD<String, Integer>

           */

//        JavaPairRDD<String, Integer> pairWords =  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);

//            }

//        });

          JavaPairRDD<String, Integer> pairWords =  words.mapToPair((String word)->{

                   return new Tuple2<String,  Integer>(word,1);

          });

          

          

          /**

           * reduceByKey

           * 1.先将相同的key分组

           * 2.对每一组的key对应的value去按照你的逻辑去处理

           */

//        JavaPairRDD<String, Integer> result =  pairWords.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;

//            }

//        });

          

          //lambda表达式

          JavaPairRDD<String, Integer> result =  pairWords.reduceByKey((Integer v1, Integer v2) -> {

                   return v1+v2;

          });

          

          

          

          

          //Java的spark api没有sortBy方法，只有sortByKey，所以我们需要1.将key和的value的二元祖先进行交换，2.再sort，3.再转换回来

          //1.将一个Tuple2<String,Integer> 转为 Integer,  String 的K,V

//        JavaPairRDD<Integer, String> resultTmp1 =  result.mapToPair(new PairFunction<Tuple2<String,Integer>,  Integer, String>() {

//

//            private static final long serialVersionUID  = 1L;

//

//            @Override

//            public Tuple2<Integer, String>  call(Tuple2<String, Integer> tuple) throws Exception {

//                 //return new Tuple2<Integer,  String>(tuple._2, tuple._1);

//                 return tuple.swap();

//            }

//        });

          //lambda

          JavaPairRDD<Integer, String> resultTmp1 =  result.mapToPair((Tuple2<String, Integer> tuple)->{

                   //return new Tuple2<Integer,  String>(tuple._2, tuple._1);

                   return tuple.swap();

          });

          

          //2.排序（降序）

          JavaPairRDD<Integer, String> resultTmp2 =  resultTmp1.sortByKey(false);

          //3.再转回String,Integer的二元祖

//        JavaPairRDD<String, Integer> resultFinal =  resultTmp2.mapToPair(new  PairFunction<Tuple2<Integer,String>, String, Integer>() {

//

//            private static final long serialVersionUID  = 1L;

//

//            @Override

//            public Tuple2<String, Integer>  call(Tuple2<Integer, String> tuple) throws Exception {

//                 return new Tuple2<String,  Integer>(tuple._2, tuple._1);

//                 //return tuple.swap();

//            }

//        });

          

          //lambda

          JavaPairRDD<String, Integer> resultFinal =  resultTmp2.mapToPair((Tuple2<Integer, String> tuple) -> {

                   return new Tuple2<String,  Integer>(tuple._2, tuple._1);

                   //return tuple.swap();

          });

          

          

          

//        resultFinal.foreach(new  VoidFunction<Tuple2<String,Integer>>() {

//            

//            /**

//             *

//             */

//            private static final long serialVersionUID  = 639147013282066178L;

//

//            @Override

//            public void call(Tuple2<String, Integer>  tuple) throws Exception {

//                 System.out.println(tuple);

//            }

//        });

          

          //lambda表达式

          resultFinal.foreach((Tuple2<String, Integer>  tuple) -> {

                   System.out.println(tuple);

          });

          

          

          sc.stop();

          

          

     }

}

②.运行结果

(java,3)
(kotlin,2)
(groovy,2)
(bamor,2)
(scala,1)
(hadoop,1)
(h5,1)
(android,1)
(griffon,1)
(w4xj,1)

 

w4xj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark 的JavaWordCount分步详解
晓晓的天空
03-16 1156
Spark 的JavaWordCount分步详解
Spark入门-Java实现WordCount并打包测试
Horsleyli的博客
07-13 790
一、Java代码实现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; imp
Spark学习之WordCount（Java版）
最新发布
pckzzy119的博客
04-30 422
由于篇幅有限，小编已将上面介绍的**《Kafka源码解析与实战》、Kafka面试专题解析、复习学习必备44个Kafka知识点（基础+进阶+高级）都整理成册，全部都是PDF文档**由于篇幅有限，小编已将上面介绍的**《Kafka源码解析与实战》、Kafka面试专题解析、复习学习必备44个Kafka知识点（基础+进阶+高级）都整理成册，全部都是PDF文档**// 每个单词作为key,value为1。// 分组：相同 key 分为一组。// 相同key，value值累加。
Spark入门第一步：WordCount之java版、Scala版
趣学程序
10-27 404
Spark入门第一步：WordCount之java版、Scala版 Spark入门系列，第一步，编写WordCount程序。 我们分别使用java和scala进行编写，从而比较二者的代码量 数据文件 通过读取下面的文件内容，统计每个单词出现的次数 java scala python android spark storm spout bolt kafka MQ elasticsearch lo...
Spark用Java实现的WordCount
大数据
12-04 1071
java版本的sparkWordCount /** * Java版本的spark WordCount */ public class JavaWordCount { public static void main(String[] args) { //1.先创建conf对象进行配置，主要是设置名称，为了设置运行模式 SparkConf conf = ne...
Spark：用Scala和Java实现WordCount
03-03
用Scala和Java实现WordCount，其中Java实现的JavaWordCount是spark自带的例子（$SPARK_HOME/examples/src/main/java/org/apache/spark/examples/JavaWordCount.java）OS:RedHatEnterpriseLinuxServerrelease6.4...
WordCount_Spark!_spark_wordcount_java_
10-01
在Java中实现Spark WordCount，需要注意以下几点： - 使用`JavaSparkContext`类代替Scala中的`SparkContext`，它提供了与Java API兼容的方法。 - 依赖管理：确保引入Spark的Java库，如`org.apache.spark:spark-...
spark框架中wordcount的scala实现
05-18
scala语言和python一样都是交互式的语言，操作简单。这是wordcount的scala实现，简单明了，比java实现简单很多，希望对大家有所帮助
Spark 最简单WordCount
05-15
在Spark中，我们可以通过Scala、Java、Python或R语言进行编程。本教程将重点介绍如何使用Scala编写一个简单的WordCount程序，以及如何在本地和集群模式下运行它。 **一、Spark环境搭建** 1. 安装Java：Spark依赖于...
Spark入门程序WordCount实现（Java）
机器学习，大数据
11-29 2480
文章目录1. 环境与数据准备1.1 运行环境1.2 数据准备2. 代码实现2.1 maven工程创建2.2 代码逻辑2.3 编译、打包、运行Reference 为了快速入门java与Spark工程的构建与开发，本次使用java实现Spark经典程序WordCount，过程记录如下，如有错误，请指正。 1. 环境与数据准备 1.1 运行环境 Hadoop：2.7.7 Spark：2.4.7 java：1.8.0_211 Maven：3.6.3 1.2 数据准备 使用如下命令启动Hadoo
Java实现Spark词配对Wordcount计数代码实现
05-24
使用Spark实现对一个文档中的每一行的单词进行词配对计数，要求去标点符号，将大写符号统一转化成为小写单词。
4 | Java Spark实现 WordCount
微信号：RunsenLiu
09-01 1378
简单的 Java Spark 实现 WordCount 的教程，它将教您如何使用 Apache Spark 来统计文本文件中每个单词的出现次数。首先，确保您已经安装了 Apache Spark 并设置了运行环境。您需要准备一个包含文本内容的文本文件，以便对其进行 WordCount 分析。
Spark开发工程师（含项目）
02-21
本课程为大数据金融信贷项目实战课，着重讲解企业中常用的大数据技术理论与实战，如Hadoop、Hive、HBase、Sqoop、Flume、Kafka、Spark Streaming、Spark SQL、Spark Structured Streaming等。课程包含离线项目和实时项目，从项目业务需求、技术选型、架构设计、集群安装部署、集成开发以及项目可视化进行全方位实战讲解。
spark系列 - wordCount( java版)
cj2580的博客
06-06 3339
环境说明 spark版本：1.6.1(已经安装完毕) os: centos6.5 java: 1.8 hadoop:2.3网上许多spark教程都是基于scala或者python的，通过这篇文章我们来使用spark的JavaAPI， 来写一个wordCount程序， 首先我们写个Java程序： pom.xml如下：<?xml version="1.0" encoding="UTF-8"?
spark java 案例_spark java wordCount实例
weixin_42437253的博客
02-19 176
packagecom.test;importjava.util.Arrays;importjava.util.List;importorg.apache.spark.SparkConf;importorg.apache.spark.api.java.JavaPairRDD;importorg.apache.spark.api.java.JavaRDD;importorg.apache.spark....
Scala版WordCount
ZZJXP的博客
05-07 550
object Demo12List { def main(args:Array[String]): Unit ={ /** * List列表 * 特点：元素可以重复、有序的、不可变的 */ //定义一个List val list1: List[Int] = List[Int](1, 2, 1, 2, 3, 5, 7, 3, 4, 6, 4, 9, 8) println(list1) //通过下标(index,索引)取元素 .
Scala实现wordCount
SX的博客
07-10 9517
废话不多说直接上代码 val list = List("rose is beautiful","jennie is beautiful","lisa is beautiful","jisoo is beautiful") /** * 第一步，将list中的元素按照分隔符这里是空格拆分，然后展开 * 先map(_.split(" "))将每一个元素按照空格拆分 ...
Scala写的wordcount
qingyang0320的专栏
02-28 775
参照文档加以修改和深化，mark一下 package mywork import java.io.File import org.apache.spark.SparkContext import org.apache.spark.SparkContext._ import org.apache.spark.SparkConf object WordCount { def main(arg
spark的wordcount代码scala
03-16
以下是Spark的WordCount代码（Scala版本）： ```scala import org.apache.spark.{SparkConf, SparkContext} object WordCount { def main(args: Array[String]): Unit = { // 创建SparkConf对象 val conf = new...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值