实验四 Spark程序设计进阶

已于 2022-04-05 15:30:35 修改
阅读量2.1k 收藏 4
点赞数 4
分类专栏： Spark 文章标签： spark big data scala
于 2022-04-04 23:53:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jdsaiasodh/article/details/123956920
版权
本文介绍了使用Spark进行电影评分数据分析，包括最受欢迎电影、各年龄段男性/女性偏好、高评分电影筛选等。通过统计和排序展示了用户行为和电影热度的洞察。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数据来源：https://grouplens.org/datasets/movielens/

使用的文件内容如下：

用户表：
在这里插入图片描述
电影表：
在这里插入图片描述

评分表：
在这里插入图片描述

三个表数据详情如下：

在这里插入图片描述

1、求被评分次数最多的 10 部电影，并给出评分次数（电影名，评分次数）

package com.spark.homework.movie


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

object code_01{
    def main(args: Array[String]): Unit = {
        // TODO 建立和Spark框架的连接

        val sparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
        val sc = new SparkContext(sparkConf)

        // TODO 执行业务操作1

        //1、读取文件,提取需要的数据

        // 用户id 性别
        val users = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\users.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        // 电影id 1
        val ratings = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\ratings.dat")
                .map(x => x.split("::"))
                .map(x => (x(1),1))

        //电影id  电影名
        val movies = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\movies.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))


        //(电影id，（电影名，1）) => （电影名，N）
        val top10_movie = movies.join(ratings)
                .map(x => (x._2._1, x._2._2))
                .reduceByKey(_+_)
                .takeOrdered(10)(Ordering[Int].reverse.on(x => x._2))

        for (elem <- top10_movie) {println(elem)}

        // TODO 关闭连接
        sc.stop();
    }

}

2、分别求男性，女性当中评分最高的 10 部电影（性别，电影名，影评分）

package com.spark.homework.movie

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

object code_02 {
    def main(args: Array[String]): Unit = {
        // TODO 建立和Spark框架的连接

        val sparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
        val sc = new SparkContext(sparkConf)

        // TODO 执行业务操作1

        //1、读取文件,提取需要的数据

        // 用户id 性别
        val users = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\users.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        // 用户id  (电影id,评分)
        val ratings = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\ratings.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),(x(1),x(2).toDouble)))

        //电影id  电影名
        val movies = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\movies.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //分别男女
        val maleUsers = users.filter(x => x._2 == "F")
        val femaleUsers = users.filter(x => x._2 == "M")

        //(用户id，（性别，（电影id，评分））) => (电影id，(评分，1)) => 求和 =>（电影id，平均评分）
        val maleMovie = maleUsers.join(ratings)
                        .map(x => (x._2._2._1,(x._2._2._2,1)))
                        .reduceByKey((a,b)=>(a._1+b._1,a._2+b._2))
                        .map(x => (x._1,x._2._1/x._2._2))

        val femaleMovie = femaleUsers.join(ratings)
                        .map(x => (x._2._2._1,(x._2._2._2,1)))
                        .reduceByKey((a,b)=>(a._1+b._1,a._2+b._2))
                        .map(x => (x._1,x._2._1/x._2._2))

        //（电影id，平均评分） => （电影id，（平均评分，电影名）） => （电影名，平均评分）
        val maleMovieName = maleMovie.join(movies).map(x => (x._2._2, x._2._1))
        val femaleMovieName = femaleMovie.join(movies).map(x => (x._2._2, x._2._1))

        //取点击量最高的前10个
        val top10_male = maleMovieName.takeOrdered(10)(Ordering[Double].reverse.on(x => x._2))
        val top10_female = femaleMovieName.takeOrdered(10)(Ordering[Double].reverse.on(x => x._2))

        println("男性：")
        for (elem <- top10_male) {println(elem)}

        println("女性: ")
        for (elem <- top10_female) {println(elem)}

        // TODO 关闭连接
        sc.stop();
    }

}

3、分别求男性，女性看过评分次数最多的 10 部电影（性别，电影名）

package com.spark.homework.movie


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

object code_03{
    def main(args: Array[String]): Unit = {
        // TODO 建立和Spark框架的连接

        val sparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
        val sc = new SparkContext(sparkConf)

        // TODO 执行业务操作1

        //1、读取文件,提取需要的数据

        // 用户id 性别
        val users = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\users.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        // 用户id  电影id
        val ratings = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\ratings.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //电影id  电影名
        val movies = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\movies.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //分别男女
        val maleUsers = users.filter(x => x._2 == "F")
        val femaleUsers = users.filter(x => x._2 == "M")

        //(用户id，（性别，电影id）) => (电影id，1) => （电影id，N）
        val maleMovie = maleUsers.join(ratings).map(x => (x._2._2,1)).reduceByKey(_+_)
        val femaleMovie = femaleUsers.join(ratings).map(x => (x._2._2,1)).reduceByKey(_+_)

        //(电影id，（N，电影名）) => （电影名，N）
        val maleMovieName = maleMovie.join(movies).map(x => (x._2._2, x._2._1))
        val femaleMovieName = femaleMovie.join(movies).map(x => (x._2._2, x._2._1))

        //取点击量最高的前10个
        val top10_male = maleMovieName.takeOrdered(10)(Ordering[Int].reverse.on(x => x._2))
        val top10_female = femaleMovieName.takeOrdered(10)(Ordering[Int].reverse.on(x => x._2))

        println("男性：")
        for (elem <- top10_male) {println(elem._1)}

        println("女性: ")
        for (elem <- top10_female) {println(elem._1)}

        // TODO 关闭连接
        sc.stop();
    }

}

4、年龄段在“18-24”的男人，最喜欢看（评分次数最多的）10部电影

package com.spark.homework.movie

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

object code_04 {
    def main(args: Array[String]): Unit = {
        // TODO 建立和Spark框架的连接

        val sparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
        val sc = new SparkContext(sparkConf)

        // TODO 执行业务操作1

        // 用户id 性别
        val users = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\users.dat")
                .map(x => x.split("::"))
                .filter(x => x.toList(2) == "18") //年龄18~24
                .map(x => (x(0),x(1)))

        // 用户id  电影id
        val ratings = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\ratings.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //电影id  电影名
        val movies = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\movies.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //取男性
        val maleUsers = users.filter(x => x._2 == "F")

        //(用户id，（性别，电影id）) => (电影id，1) => （电影id，N）
        val maleMovie = maleUsers.join(ratings).map(x => (x._2._2,1)).reduceByKey(_+_)

        //(电影id，（N，电影名）) => （电影名，N）
        val maleMovieName = maleMovie.join(movies).map(x => (x._2._2, x._2._1))

        //取点击量最高的前10个
        val top10_male = maleMovieName.takeOrdered(10)(Ordering[Int].reverse.on(x => x._2))
        
        for (elem <- top10_male) {println(elem._1)}
        
        // TODO 关闭连接
        sc.stop();
    }

}

5、求 movieid = 2116 这部电影各年龄段（因为年龄就只有 7 个，就按这个 7 个分就好了）的平均影评（年龄段，影评分）

package com.spark.homework.movie

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

object code_05 {
    def main(args: Array[String]): Unit = {
        // TODO 建立和Spark框架的连接

        val sparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
        val sc = new SparkContext(sparkConf)

        // TODO 执行业务操作1

        // 用户id 年龄
        val users = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\users.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(2)))

        // 用户id  评分
        val ratings = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\ratings.dat")
                .map(x => x.split("::"))
                .filter(x => x(1) == "2116")
                .map(x => (x(0),x(2)))

        //(用户id，（年龄，评分）) => (年龄，（评分，1）) => (年龄，（sum评分，sum）) => (年龄，均值)
        val score = users.join(ratings).map(x => (x._2._1.toInt, (x._2._2.toInt, 1)))
                .reduceByKey((a,b) =>(a._1+b._1,a._2+b._2))
                .map(x => (x._1, 1.0 * x._2._1 / x._2._2))

        for (elem <- score.collect()) {
            println(elem)
        }

        // TODO 关闭连接
        sc.stop();
    }

}

6、求最喜欢看电影（影评次数最多）的那位女性评最高分的 10 部电影的平均影评分（观影者，电影名，影评分）

package com.spark.homework.movie

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

object code_06 {
    def main(args: Array[String]): Unit = {
        // TODO 建立和Spark框架的连接

        val sparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
        val sc = new SparkContext(sparkConf)

        // TODO 执行业务操作1

        // 用户id 性别
        val users = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\users.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        // 用户id 电影id 评分
        val ratings = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\ratings.dat")
                .map(x => x.split("::"))

        //电影id  电影名
        val movies = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\movies.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //(用户id,1) => (用户id，（1，评分）) => （用户id，1） => 聚合（用户id，N） => 排序取最大的N
        val top = ratings.map(x => (x(0), 1))
                .join(users.filter(x => x._2 == "F"))
                .map(x => (x._1, 1))
                .reduceByKey(_ + _)
                .takeOrdered(1)(Ordering[Int].reverse.on(x => x._2))

        //最喜欢看电影的女性的id
        val id = top(0)._1

        //过滤id => （电影id，评分） => 取评分前10
        val top10_movesId = ratings.filter(x => x(0) == id)
                .map(x => (x(1), x(2)))
                .takeOrdered(10)(Ordering[Int].reverse.on(x => x._2.toInt))

        for (elem <- top10_movesId) {
            // 当前电影id
            val moveId = elem._1

            // 当前电影名
            val moveName = movies.filter(x => x._1 == moveId).collect()(0)._2

            // 过滤电影 => 统计得分（moveName,(评分，1)） => （moveName （sum评分，sum）） => (moveName，平均评分)
            val score = ratings.filter(x => x(1) == moveId)
                    .map(x => (moveName, (x(2).toInt, 1)))
                    .reduceByKey((a, b) => (a._1 + b._1, a._2 + b._2))
                    .map(x => (x._1, 1.0 * x._2._1 / x._2._2))

            println(score.collect().toList)
        }

        // TODO 关闭连接
        sc.stop();
    }

}

7、求好片（评分>=4.0）最多的那个年份的最好看的 10 部电影（好看定义为平均评分最高）

package com.spark.homework.movie

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

object code_07 {
    def main(args: Array[String]): Unit = {
        // TODO 建立和Spark框架的连接

        val sparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
        val sc = new SparkContext(sparkConf)

        // TODO 执行业务操作1

        // 用户id 性别
        val users = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\users.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //电影id 评分
        val ratings = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\ratings.dat")
                .map(x => x.split("::"))
                .map(x => (x(1),x(2).toDouble))

        //电影id  电影名
        val movies = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\movies.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //(电影id，（电影名，评分）) => 过滤大于大于4评分电影 => （电影id，1） => 计算数量 => 取评分数量最多的电影的id
        val top1_moveId = movies.join(ratings.filter(x => x._2 >= 4))
                .map(x => (x._1, 1))
                .reduceByKey(_ + _)
                .takeOrdered(10)(Ordering[Int].reverse.on(x => x._2))(0)._1

        //id为top1_moveId 的电影名
        val top1_moveName = movies.filter(x => x._1 == top1_moveId).collect()(0)._2

        //取电影播放年份
        val year = top1_moveName.substring(top1_moveName.length - 5, top1_moveName.length - 1)

        //过滤年份 => 合并(电影id，（评分，电影名）) => （电影名，（评分，1））=>求和(电影名，（sum评分，sum）) => 求平均 => 取平均最高的10个
        val score = ratings.join(movies.filter(x => x._2.contains(year)))
                .map(x => (x._2._2, (x._2._1, 1)))
                .reduceByKey((a, b) => (a._1 + b._1, a._2 + b._2))
                .map(x => (x._1, x._2._1 / x._2._2))
                .takeOrdered(10)(Ordering[Double].reverse.on(x => x._2))

        for (elem <- score) {println(elem)}

        // TODO 关闭连接
        sc.stop();
    }

}

8、求 1997 年上映的电影中，评分最高的 10 部 Comedy 类电影

package com.spark.homework.movie

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

object code_08 {
    def main(args: Array[String]): Unit = {
        // TODO 建立和Spark框架的连接

        val sparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
        val sc = new SparkContext(sparkConf)

        // TODO 执行业务操作1

        // 用户id 性别
        val users = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\users.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //电影id 评分
        val ratings = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\ratings.dat")
                .map(x => x.split("::"))
                .map(x => (x(1),x(2).toDouble))

        //电影id  电影名
        //过滤类型 and 年份
        val movies = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\movies.dat")
                .map(x => x.split("::"))
                .filter(x => x(2).contains("Comedy") && x(1).contains("1997"))
                .map(x => (x(0),x(1)))


        //合并(电影id，（评分，电影名）) => （电影名，（评分，1））=>求和(电影名，（sum评分，sum）) => 求平均 => 取平均最高的10个
        val score = ratings.join(movies)
                .map(x => (x._2._2, (x._2._1, 1)))
                .reduceByKey((a, b) => (a._1 + b._1, a._2 + b._2))
                .map(x => (x._1, x._2._1 / x._2._2))
                .takeOrdered(10)(Ordering[Double].reverse.on(x => x._2))

        for (elem <- score) {println(elem)}

        // TODO 关闭连接
        sc.stop();
    }

}

9、该影评库中各种类型电影中评价最高的 5 部电影（类型，电影名，平均影评分）

package com.spark.homework.movie

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

object code_09 {
    def main(args: Array[String]): Unit = {
        // TODO 建立和Spark框架的连接

        val sparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
        val sc = new SparkContext(sparkConf)

        // TODO 执行业务操作1

        // 用户id 性别
        val users = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\users.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //电影id 评分
        val ratings = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\ratings.dat")
                .map(x => x.split("::"))
                .map(x => (x(1),x(2).toDouble))

        //电影id  电影名
        val movies = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\movies.dat")
                .map(x => x.split("::"))

        //取得所有电影的类型
        val moveType = movies.map(x => x(2)).flatMap(x => x.split('|')).distinct().collect()

        for (elem <- moveType) {
            //对于每种类型，获取评价最高的
            
            //（电影id，（电影名，评分）） => （电影名，（评分，1）） => 求和，求平均 => 取最高的5个
            val top5_movie = movies.filter(x => x(2).contains(elem))
                    .map(x => (x(0), x(1))).join(ratings)
                    .map(x => (x._2._1, (x._2._2, 1)))
                    .reduceByKey((a, b) => (a._1 + b._1, a._2 + b._2))
                    .map(x => (x._1, x._2._1 / x._2._2))
                    .takeOrdered(5)((Ordering[Double].reverse.on(x => x._2)))
            println(elem + ":")
            for (movie <- top5_movie) {println(movie)}
        }
        // TODO 关闭连接
        sc.stop();
    }

}

10、各年评分最高的电影类型（年份，类型，影评分）

package com.spark.homework.movie

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

object code_10 {
    def main(args: Array[String]): Unit = {
        // TODO 建立和Spark框架的连接

        val sparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")
        val sc = new SparkContext(sparkConf)

        // TODO 执行业务操作1

        // 用户id 性别
        val users = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\users.dat")
                .map(x => x.split("::"))
                .map(x => (x(0),x(1)))

        //电影id 评分
        val ratings = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\ratings.dat")
                .map(x => x.split("::"))
                .map(x => (x(1),x(2).toDouble))

        //电影id  电影名
        val movies = sc.textFile("E:\\BigData\\homework\\Spark作业\\实验八\\movies.dat")
                .map(x => x.split("::"))

        //取得所有电影上映时间
        val years = movies.map(x => x(1)).map(x => x.substring(x.length - 5,x.length - 1)).distinct().collect()

        for (elem <- years) {
            //对于每年，获取评价最高的

            //（电影id，（电影名，评分）） => （电影名，（评分，1）） => 求和，求平均 => 取最高的5个
            val top_movie = movies.filter(x => x(1).contains(elem))
                    .map(x => (x(0), x(2))) //（电影id，类型）
                    .join(ratings) //（电影id，（类型，评分））
                    .map(x => (x._2._1, (x._2._2, 1))) //(类型，（评分，1）)
                    .reduceByKey((a, b) => (a._1 + b._1, a._2 + b._2)) //求和
                    .map(x => (x._1, x._2._1 / x._2._2)) //求平均
                    .takeOrdered(1)((Ordering[Double].reverse.on(x => x._2))) //取最大
            println(elem + ":" + top_movie(0))
        }
        // TODO 关闭连接
        sc.stop();
    }

}
Spark入门指南：大数据处理的第一个Hello World程序
AI天才研究院
05-10 987
随着数据量呈指数级增长，传统单机数据处理技术已无法满足需求。Apache Spark作为当前最主流的大数据处理框架，凭借其“快如闪电”的计算速度（基于内存计算）和“简单易用”的API设计，成为企业级大数据平台的核心工具。本文的目标是通过一个经典的“Hello World”程序（即WordCount词频统计），引导读者完成从环境搭建到程序运行的全流程，并深入理解Spark的核心机制。Spark的核心概念与架构分布式计算的基础逻辑PySpark环境搭建与配置。
Spark学习笔记：程序设计
BigPig的博客
01-21 1093
基本流程 创建SparkContext对象 封装了spark执行环境的上下文信息，必须有且只有一个； 创建RDD 可从Scala集合或Hadoop数据集上创建，利用Context对象的API创建RDD，可以将HBase表、MySQL表、本地文件等数据映射成RDD； 在RDD之上进行Transformation和Action Spark提供了多种Transformation和Action函数 返回...
Spark——实验四：从HBASE建立RDD
maochaofei的博客
06-05 1351
文章目录一. 实验目的二. 实验内容三. 实验步骤及结果分析 1. 基于ubuntukylin14.04(16)通过命令行建立hbase程序 1.1 创建hbase表 1.2 配置Spark 1.3 编写程序读取HBase数据 1.4 编写程序向HBase写入数据 2. 基于ubuntukylin14.04(16)通过eclipse平台运行hbase程序 2.1 创建Hbase程序 2.2 在Eclipse运行HBase程序 一. 实验目的   学习从hbase库建立RDD数据结构的主要技术。 二. 实验内
spark进阶
会算法的架构师
04-12 221
1hadoop 2hive 3zoopkper 4 kafka
Spark进阶
weixin_45116848的博客
12-28 213
Spack进阶 1.RDD的依赖关系 窄依赖(不产生shuffle) 父RDD和子RDD的patiition之间的关系是一对一,或者是多对一的关系 宽依赖(会有shuffle产生(类似中间结果,会影响计算效率)) 父RDD和子RDD的patition之间的关系是多对一. 宽依赖与窄依赖示意图 2.stage 过程 spark会根据RDD之间的依赖关系,形成一个有向无环图...
Spark进阶（一）
a_victory的博客
03-15 705
Hadoop与Spark的区别 搜狗文件分析例子 以交互的方式：val rdd = sc.textFile("/input/SogouQ.reduced")① ⽤户在00:00:00到12:00:00之间的查询数？以本地的模式：package cn.chinahadoop.scalaimport org.apache.spark.{SparkContext, SparkConf} obje
Spark编程进阶
BGoodHabit的博客
12-13 1706
目录1 简介 1 简介 介绍两种类型的共享变量: 累加器(accumulator)与广播变量(broadcast variable)。累加器用来对信息进行聚合，而 广播变量用来高效分发较大的对象。
300页PPT讲述Spark DevOps进阶技巧
08-18
具体的实验室练习包括DevOps 101和PySpark DevOps 102的实践环节，以及对Spark Streaming的介绍，这表明了Spark作为实时处理工具的能力。 为了帮助听众更好地理解和应用所学知识，演讲者还安排了问答环节，并在课程...
LSH电影推荐系统-基于Hadoop+Spark+Django开发（含源码+项目说明+实验报告）.zip
01-09
LSH电影推荐系统-基于Hadoop+Spark+Django开发（含源码+项目说明+实验报告）.zip [资源说明] 1、该项目是团队成员近期最新开发，代码完整，资料齐全，含设计文档等 2、上传的项目源码经过严格测试，功能完善且能正常...
商品推荐系统-大数据实战项目（基于Spark,Scala,MongoDB，含源码+项目说明+实验报告）.zip
最新发布
01-13
商品推荐系统-大数据实战项目（基于Spark,Scala,MongoDB，含源码+项目说明+实验报告）.zip 【资源说明】 1、该项目是团队成员近期最新开发，代码完整，资料齐全，含设计文档等 2、上传的项目源码经过严格测试，功能...
JavaWeb前后端搜索服务系统-基于SpringBoot+Elasticsearch+SparkMLib开发（含源码+项目说明+实验报告）.zip
01-09
JavaWeb前后端搜索服务系统-基于SpringBoot+Elasticsearch+SparkMLib开发（含源码+项目说明+实验报告）.zip [资源说明] 1、该项目是团队成员近期最新开发，代码完整，资料齐全，含设计文档等 2、上传的项目源码经过...
Spark进阶（六）
a_victory的博客
03-28 621
SparkSQL 运行架构 && hive 的安装实践 TreeNode 体系Logical Plans 、Expressions 、Physical Operators 都可以使用Tree 表示 – TreeNode 具备一些scala collection 的操作能力和树遍历能力，树的修改是以替换已有节点的方式进行的。 – TreeNode ，内部带一个children: Seq[Base
Spark进阶（三）
a_victory的博客
03-23 680
客户端模式和集群模式的区别这里我们要区分一下什么是客户端模式（client mode），什么是集群模式（cluster mode）。   我们知道，当在YARN上运行Spark作业时，每个Spark executor作为一个YARN容器(container)运行。Spark可以使得多个Tasks在同一个容器(container)里面运行。 yarn-cluster和yarn-client模式的区别其
Spark进阶（二）内部机制和执行原理
runqu的博客
03-31 1263
Spark是一种开源的分布式计算框架，旨在解决大规模数据处理的问题。它的计算模型是一种基于内存的、并行的数据处理模型，适用于处理大规模数据集的计算任务。Spark的计算模型可以归结为以下几个关键概念：弹性分布式数据集（RDD）：RDD是Spark的核心数据结构，它是一种容错的、可并行计算的数据抽象。RDD可以在内存中缓存数据，以便更快地进行数据处理。RDD的数据可以通过各种方式进行转换和操作，包括过滤、映射、缓存等。DAG调度器：Spark使用有向无环图（DAG）来表示计算任务的依赖关系。
Spark学习之编程进阶总结(二)
weixin_30302609的博客
04-16 248
五、基于分区进行操作 　　基于分区对数据进行操作可以让我们避免为每个数据元素进行重复的配置工作。诸如打开数据库连接或创建随机数生成器等操作，都是我们应当尽量避免为每个元素都配置一次的工作。Spark 提供基于分区的 map 和 foreach ，让你的部分代码只对 RDD 的每个分区运行一次，这样可以帮助降低这些操作的代价。 　　当基于分区操作 RDD 时，Spark 会为函数提供该分区中的元...
spark进阶（五）
a_victory的博客
03-24 582
Spark StreamingSparkStreaming框架计算流程：Spark Streaming是将流式计算分解成一系列短小的批处理作业。这里的批处理引擎是Spark，也就是把Spark Streaming的输入数据按照batch size（如1秒）分成一段一段的数据（Discretized Stream），每一段数据都转换成Spark中的RDD（Resilient Distributed D
五、Spark编程进阶
RobinLiew的博客
05-29 206
一、累加器 1.累加器的用法 通过在驱动器中调用SparkContext.accumulator(initialValue)方法，创建出有初始值的累加器。返回值为org.apache.spark.Accumulator[T]对象，其中T是初始值initialValue的类型。 Spark闭包里的执行器代码可以使用累加器的+=方法增加累加器的值。 驱动器程序可以调用累加器的value属性来访问累加器的值。 注意：工作节点上的任务不能访问累加器的值。累加器是一个只写变量。 2.累加器与容错性 Spark会
Spark程序设计
disuihuo0872的博客
09-18 201
一、Spark编程模型 Spark常规步骤： 创建SparkContext对象：连接集群，提供创建RDD和广播变量等接口 输入数据：从Hadoop等外部数据源或Scala数据集创建RDD 创建RDD-Scala集合/本地文件 并行度3，创建3个partition HDFS 文件被切分成block分布在多个节点上，通过...
Spark2.x学习笔记：7、Spark应用程序设计
与其临渊羡鱼 不如退而结网
07-18 383
7、 Spark应用程序设计 7.1 基本流程 1.创建SparkContext对象 每个Spark应用程序有且仅有一个SparkContext对象，封装了Spark执行环境信息 2.创建RDD 可以冲Scala集合或者Hadoop数据集上创建 3.在RDD之上进行转换和Action MapReduce只提供了map和reduce两种操作，而Spark提供了...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值