Spark大数据处理学习笔记（3.2.1）掌握RDD算子

已于 2023-06-12 15:10:55 修改
阅读量935 收藏
点赞数
分类专栏： # Spark大数据处理学习笔记 文章标签： hdfs 大数据 spark 学习 笔记
于 2023-06-12 15:09:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kox_233/article/details/131161378
版权

该文章主要为完成实训任务，详细实现过程及结果见【http://t.csdn.cn/FArNP】

文章目录

一、准备工作

1.1 准备文件

1. 准备本地系统文件

  • 在\home目录里创建words.txt
    在这里插入图片描述

2. 把文件上传到

  • 将words.txt上传到HDFS系统的/park目录里
    在这里插入图片描述
  • 查看文件内容
    在这里插入图片描述

1.2 启动Spark Shell

1. 启动HDFS服务

  • 执行命令：start-dfs.sh
    在这里插入图片描述

2. 启动Spark服务

  • 执行命令：start-all.sh
    在这里插入图片描述

3. 启动Spark Shell

  • 执行名命令： spark-shell --master spark://master:7077
    在这里插入图片描述

二、掌握转换算子

2.1 映射算子 - map()

1. 映射算子功能

  • map()是一种转换算子，它接收一个函数作为参数，并把这个函数应用于RDD的每个元素，最后将函数的返回结果作为结果RDD中对应元素的值。

2. 映射算子案例

  • 预备工作：创建一个RDD - rdd1
  • 执行命令：val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6))
    在这里插入图片描述
任务1、将rdd1每个元素翻倍得到rdd2
  • 对rdd1应用map()算子，将rdd1中的每个元素平方并返回一个名为rdd2的新RDD
    在这里插入图片描述
  • 查看结果
    在这里插入图片描述
任务2、将rdd1每个元素平方得到rdd2
  • 方法一、采用普通函数作为参数传给map()算子
    在这里插入图片描述
  • 方法二、采用下划线表达式作为参数传给map()算子
    在这里插入图片描述
任务3、利用映射算子打印菱形

（1）Spark Shell里实现

  • 右半菱形
    在这里插入图片描述

  • 加上前导空格，左半菱形
    在这里插入图片描述

  • 前导空格折半，显示菱形
    在这里插入图片描述
    （2）在IDEA里创建项目实现

  • 创建Maven项目
    在这里插入图片描述

  • 将java目录改成scala目录
    在这里插入图片描述

  • 在pom.xml文件里添加相关依赖和设置源程序目录
    在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.kox.rdd</groupId>
    <artifactId>SparkRDDDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.12.15</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.12</artifactId>
            <version>3.1.3</version>
        </dependency>
    </dependencies>
    <build>
        <sourceDirectory>src/main/scala</sourceDirectory>
    </build>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>



</project>
  • 添加日志属性文件
    在这里插入图片描述
log4j.rootLogger=ERROR, stdout, logfile
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/rdd.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n
  • 创建hdfs-site.xml文件，允许客户端访问集群数据节点
    在这里插入图片描述
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <property>
        <description>only config in clients</description>
        <name>dfs.client.use.datanode.hostname</name>
        <value>true</value>
    </property>
</configuration>
  • 创建cn.kox.rdd.day01包
    在这里插入图片描述
  • 在cn.kox.rdd.day01包里创建Example01单例对象
    在这里插入图片描述
package cn.kox.rdd.day01

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

import scala.collection.mutable.ListBuffer
import scala.io.StdIn

/**
 * @ClassName: Example01
 * @Author: Kox
 * @Data: 2023/6/12
 * @Sketch:
 */
object Example01 {
  def main(args: Array[String]): Unit = {
    // 创建Spark配置对象
    val conf = new SparkConf()
      .setAppName("PrintDiamond") // 设置应用名称
      .setMaster("local[*]") // 设置主节点位置（本地调试）
    // 基于Spark配置对象创建Spark容器
    val sc = new SparkContext(conf)
    // 输入一个奇数
    print("输入一个奇数：")
    val n = StdIn.readInt()
    //判断n的奇偶性
    if (n % 2 == 0) {
      println("温馨提示：你输入的不是奇数")
      return 
    }
    // 创建一个可变列表
    val list = new ListBuffer[Int]()
    // 给列表赋值
    (1 to n by 2).foreach(list.append(_))
    (n - 2 to 1 by -2).foreach(list.append(_))
    // 基于列表创建rdd
    val rdd = sc.makeRDD(list)
    // 对rdd进行映射操作
    val rdd1 = rdd.map(i => " " * ((n - i) / 2) + "*" * i)
    // 输出rdd1结果
    rdd1.collect.foreach(println)
  }
}
  • 运行程序，查看结果
    在这里插入图片描述

2.2 过滤算子 - filter()

1. 过滤算子功能

  • filter(func)：通过函数func对源RDD的每个元素进行过滤，并返回一个新RDD，一般而言，新RDD元素个数会少于原RDD。

2. 过滤算子案例

任务1、过滤出列表中的偶数
  • 整数（Integer）：奇数（odd number）+ 偶数（even number）
  • 基于列表创建RDD，然后利用过滤算子得到偶数构成的新RDD
  • 方法一、将匿名函数传给过滤算子
    在这里插入图片描述
  • 方法二、用神奇占位符改写传入过滤算子的匿名函数
    在这里插入图片描述
任务2、过滤出文件中包含spark的行
  • 查看源文件/park/words.txt内容
    在这里插入图片描述
  • 执行命令： val lines= sc.textFile("/park/words.txt")，读取文件 /park/words.txt生成RDD - lines
    在这里插入图片描述
  • 执行命令：val sparkLines = lines.filter(_.contains("spark"))，过滤包含spark的行生成RDD - sparkLines
    在这里插入图片描述
  • 执行命令：sparkLines.collect，查看sparkLines内容，可以采用遍历算子，分行输出内容

在这里插入图片描述

  • 输出长度超过20的行
    在这里插入图片描述
任务3、利用过滤算子输出[2000, 2500]之间的全部闰年
  • 传统做法，利用循环结构嵌套选择结构来实现
    在这里插入图片描述
  • 要求每行输出10个数
    在这里插入图片描述
  • 采用过滤算子来实现
    在这里插入图片描述
  • 要求每行输出10个数
    在这里插入图片描述
任务4、利用过滤算子输出[10, 100]之间的全部素数
  • 过滤算子：filter(n => !(n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0))
    在这里插入图片描述

2.3 扁平映射算子 - flatMap()

1. 扁平映射算子功能

  • flatMap()算子与map()算子类似，但是每个传入给函数func的RDD元素会返回0到多个元素，最终会将返回的所有元素合并到一个RDD。

2. 扁平映射算子案例

任务1、统计文件中单词个数
  • 读取文件，生成RDD - rdd1，查看其内容和元素个数
  • 在这里插入图片描述
  • 对于rdd1按空格拆分，做映射，生成新RDD - rdd2
    在这里插入图片描述
  • 对于rdd1按空格拆分，做扁平映射，生成新RDD - rdd3，有一个降维处理的效果
    在这里插入图片描述
  • 统计结果：文件里有25个单词
方法一、利用Scala来实现
  • 利用列表的flatten函数
  • 在cn.kox.rdd.day01包里创建Example02单例对象
    在这里插入图片描述
package cn.kox.rdd.day01

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

/**
 * @ClassName: Example02
 * @Author: Kox
 * @Data: 2023/6/12
 * @Sketch:
 */
object Example02 {
  def main(args: Array[String]): Unit = {
    // 创建不规则二维列表
    val mat = List(
      List(7, 8, 1, 5),
      List(10, 4, 9),
      List(7, 2, 8, 1, 4),
      List(21, 4, 7, -4)
    )
    // 输出二维列表
    println(mat)
    // 将二维列表扁平化为一维列表
    val arr = mat.flatten
    // 输出一维列表
    println(arr)
    // 输出元素个数
    println("元素个数：" + arr.size)
  }
}
  • 运行程序，查看结果
    在这里插入图片描述
方法二、利用Spark RDD来实现
  • 利用flatMap算子
  • 在cn.kox.rdd.day01包里创建Example03单例对象
package cn.kox.rdd.day01

import org.apache.spark.{SparkConf, SparkContext}
/**
 * @ClassName: Example03
 * @Author: Kox
 * @Data: 2023/6/12
 * @Sketch:
 */
object Example03 {
  def main(args: Array[String]): Unit = {
    // 创建Spark配置对象
    val conf = new SparkConf()
      .setAppName("PrintDiamond") // 设置应用名称
      .setMaster("local[*]") // 设置主节点位置（本地调试）
    // 基于Spark配置对象创建Spark容器
    val sc = new SparkContext(conf)
    // 创建不规则二维列表
    val mat = List(
      List(7, 8, 1, 5),
      List(10, 4, 9),
      List(7, 2, 8, 1, 4),
      List(21, 4, 7, -4)
    )
    // 基于二维列表创建rdd1
    val rdd1 = sc.makeRDD(mat)
    // 输出rdd1
    rdd1.collect.foreach(x => print(x + " "))
    println()
    // 进行扁平化映射
    val rdd2 = rdd1.flatMap(x => x.toString.substring(5, x.toString.length - 1).split(", "))
    // 输出rdd2
    rdd2.collect.foreach(x => print(x + " "))
    println()
    // 输出元素个数
    println("元素个数：" + rdd2.count)
  }
}
  • 运行程序，查看结果
    在这里插入图片描述

2.4 按键归约算子 - reduceByKey()

1. 按键归约算子功能

  • reduceByKey()算子的作用对像是元素为(key,value)形式（Scala元组）的RDD，使用该算子可以将相同key的元素聚集到一起，最终把所有相同key的元素合并成一个元素。该元素的key不变，value可以聚合成一个列表或者进行求和等操作。最终返回的RDD的元素类型和原有类型保持一致。

2. 按键归约算子案例

任务1、在Spark Shell里计算学生总分

在这里插入图片描述

  • 创建成绩列表scores，基于成绩列表创建rdd1，对rdd1按键归约得到rdd2，然后查看rdd2内容在这里插入图片描述
  • agg: aggregation 聚合值
  • cur: current 当前值
val scores = List(("张钦林", 78), ("张钦林", 90), ("张钦林", 76),
                  ("陈燕文", 95), ("陈燕文", 88), ("陈燕文", 98),
                  ("卢志刚", 78), ("卢志刚", 80), ("卢志刚", 60))
val rdd1 = sc.makeRDD(scores)
val rdd2 = rdd1.reduceByKey((x, y) => x + y)
rdd2.collect.foreach(println)
  • 可以采用神奇的占位符
    在这里插入图片描述
任务2、在IDEA里计算学生总分

在这里插入图片描述
第一种方式：读取二元组成绩列表

  • 在cn.kox.rdd.day02包里创建CalculateScoreSum01单例对象
    在这里插入图片描述
package cn.kox.rdd.day02

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

/**
 * @ClassName: CalculateScoreSum01
 * @Author: Kox
 * @Data: 2023/6/12
 * @Sketch:
 */
object CalculateScoreSum01 {
  def main(args: Array[String]): Unit = {
    // 创建Spark配置对象
    val conf = new SparkConf()
      .setAppName("PrintDiamond") // 设置应用名称
      .setMaster("local[*]") // 设置主节点位置（本地调试）
    // 基于Spark配置对象创建Spark容器
    val sc = new SparkContext(conf)
    // 创建二元组成绩列表
    val scores = List(
      ("张钦林", 78), ("张钦林", 90), ("张钦林", 76),
      ("陈燕文", 95), ("陈燕文", 88), ("陈燕文", 98),
      ("卢志刚", 78), ("卢志刚", 80), ("卢志刚", 60))
    // 基于二元组成绩列表创建RDD
    val rdd1 = sc.makeRDD(scores)
    // 对成绩RDD进行按键归约处理
    val rdd2 = rdd1.reduceByKey(_ + _)
    // 输出归约处理结果
    rdd2.collect.foreach(println)
  }
}
  • 运行程序，查看结果
    在这里插入图片描述
    第二种方式：读取四元组成绩列表
  • 在cn.kox.rdd.day02包里创建CalculateScoreSum02单例对象
    在这里插入图片描述
package cn.kox.rdd.day02

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

import scala.collection.mutable.ListBuffer
/**
 * @ClassName: CalculateScoreSum02
 * @Author: Kox
 * @Data: 2023/6/12
 * @Sketch:
 */
object CalculateScoreSum02 {

  def main(args: Array[String]): Unit = {
    // 创建Spark配置对象
    val conf = new SparkConf()
      .setAppName("PrintDiamond") // 设置应用名称
      .setMaster("local[*]") // 设置主节点位置（本地调试）
    // 基于Spark配置对象创建Spark容器
    val sc = new SparkContext(conf)
    // 创建四元组成绩列表
    val scores = List(
      ("张钦林", 78, 90, 76),
      ("陈燕文", 95, 88, 98),
      ("卢志刚", 78, 80, 60)
    )
    // 将四元组成绩列表转化成二元组成绩列表
    val newScores = new ListBuffer[(String, Int)]()
    // 通过遍历算子遍历四元组成绩列表
    scores.foreach(score => {
      newScores.append(Tuple2(score._1, score._2))
      newScores.append(Tuple2(score._1, score._3))
      newScores.append(Tuple2(score._1, score._4))
    }
    )
    // 基于二元组成绩列表创建RDD
    val rdd1 = sc.makeRDD(newScores)
    // 对成绩RDD进行按键归约处理
    val rdd2 = rdd1.reduceByKey(_ + _)
    // 输出归约处理结果
    rdd2.collect.foreach(println)
  }
}
  • 运行程序，查看结果
    在这里插入图片描述

2.5 合并算子 - union()

1. 合并算子功能

  • union()算子将两个RDD合并为一个新的RDD，主要用于对不同的数据来源进行合并，两个RDD中的数据类型要保持一致。

2. 合并算子案例

  • 创建两个RDD，合并成一个新RDD
    在这里插入图片描述
  • 课堂练习：将两个二元组成绩表合并在这里插入图片描述
  • 在集合运算里，并集符号：∪ \cup∪，并集运算：A ∪ B A \cup BA∪B
  • 在集合运算里，交集符号：∩ \cap∩，交集运算：A ∩ B A \cap BA∩B
  • 在集合运算里，补集运算：A ˉ \bar A

2.6 排序算子 - sortBy()

1. 排序算子功能

  • sortBy()算子将RDD中的元素按照某个规则进行排序。该算子的第一个参数为排序函数，第二个参数是一个布尔值，指定升序（默认）或降序。若需要降序排列，则需将第二个参数置为false。

2. 排序算子案例

  • 一个数组中存放了三个元组，将该数组转为RDD集合，然后对该RDD按照每个元素中的第二个值进行降序排列。
    在这里插入图片描述
  • sortBy(x=>x._2,false)中的x代表rdd1中的每个元素。由于rdd1的每个元素是一个元组，因此使用x._2取得每个元素的第二个值。当然，sortBy(x=>x.2,false)也可以直接简化为sortBy(._2,false)。
    在这里插入图片描述

2.7 按键排序算子 - sortByKey()

1. 按键排序算子功能

  • sortByKey()算子将(key, value)形式的RDD按照key进行排序。默认升序，若需降序排列，则可以传入参数false。

2. 按键排序算子案例

  • 将三个二元组构成的RDD按键先降序排列，然后升序排列
    在这里插入图片描述
  • 其实，用排序算子也是可以搞定的
    在这里插入图片描述

2.8 连接算子

1. 内连接算子 - join()

  • join()算子将两个(key, value)形式的RDD根据key进行连接操作，相当于数据库的内连接（Inner Join），只返回两个RDD都匹配的内容。
  • 将rdd1与rdd2进行内连接
    在这里插入图片描述

2. 左外连接算子 - leftOuterJoin()

  • leftOuterJoin()算子与数据库的左外连接类似，以左边的RDD为基准（例如rdd1.leftOuterJoin(rdd2)，以rdd1为基准），左边RDD的记录一定会存在。例如，rdd1的元素以(k,v)表示，rdd2的元素以(k, w)表示，进行左外连接时将以rdd1为基准，rdd2中的k与rdd1的k相同的元素将连接到一起，生成的结果形式为(k, (v, Some(w))。rdd1中其余的元素仍然是结果的一部分，元素形式为(k,(v, None)。Some和None都属于Option类型，Option类型用于表示一个值是可选的（有值或无值)。若确定有值，则使用Some（值）表示该值；若确定无值，则使用None表示该值。
  • rdd1与rdd2进行左外连接
    在这里插入图片描述

3. 右外连接算子 - rightOuterJoin()

  • rightOuterJoin()算子的使用方法与leftOuterJoin()算子相反，其与数据库的右外连接类似，以右边的RDD为基准（例如rdd1.rightOuterJoin(rdd2)，以rdd2为基准），右边RDD的记录一定会存在。
  • rdd1与rdd2进行右外连接
    在这里插入图片描述

4. 全外连接算子 - fullOuterJoin()

  • fullOuterJoin()算子与数据库的全外连接类似，相当于对两个RDD取并集，两个RDD的记录都会存在。值不存在的取None。
  • rdd1与rdd2进行全外连接
    在这里插入图片描述

2.9 交集算子 - intersection()

  • intersection()算子对两个RDD进行交集操作，返回一个新的RDD。要求两个算子类型要一致。
  • rdd1与rdd2进行交集操作，满足交换律
    在这里插入图片描述
  • A ∩ B ≠ ϕ
    在这里插入图片描述

2.10 去重算子 - distinct()

  • distinct()算子对RDD中的数据进行去重操作，返回一个新的RDD。有点类似与集合的不允许重复元素。

1. 去重算子案例

  • 去掉rdd中重复的元素
    在这里插入图片描述

2. IP地址去重案例

  • 在项目根目录创建ips.txt文件
    在这里插入图片描述
192.168.234.21
192.168.234.22
192.168.234.21
192.168.234.21
192.168.234.23
192.168.234.21
192.168.234.21
192.168.234.21
192.168.234.25
192.168.234.21
192.168.234.21
192.168.234.26
192.168.234.21
192.168.234.27
192.168.234.21
192.168.234.27
192.168.234.21
192.168.234.29
192.168.234.21
192.168.234.26
192.168.234.21
192.168.234.25
192.168.234.25
192.168.234.21
192.168.234.22
192.168.234.21
  • 在cn.kox.rdd.day03包里创建DistinctIPs单例对象
    在这里插入图片描述
package cn.kox.rdd.day03

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

/**
 * @ClassName: DistinctIPs
 * @Author: Kox
 * @Data: 2023/6/12
 * @Sketch:
 */
object DistinctIPs {
  def main(args: Array[String]): Unit = {
    // 创建Spark配置对象
    val conf = new SparkConf()
      .setAppName("DistinctIPs ") // 设置应用名称
      .setMaster("local[*]") // 设置主节点位置（本地调试）
    // 基于Spark配置对象创建Spark容器
    val sc = new SparkContext(conf)
    // 读取本地IP地址文件，得到RDD
    val ips = sc.textFile("D:\\Major\\BigData\\Spark\\SparkLesson2023U\\SparkRDDDemo\\ips.txt")
    // rdd去重再输出
    ips.distinct.collect.foreach(println)
  }
}
  • 运行程序，查看结果
    在这里插入图片描述
  • 修改代码，保存去重结果到本地目录在这里插入图片描述

（十一）组合分组算子 - cogroup()

  • cogroup()算子对两个(key, value)形式的RDD根据key进行组合，相当于根据key进行并集操作。例如，rdd1的元素以(k, v)表示，rdd2的元素以(k, w)表示，执行rdd1.cogroup(rdd2)生成的结果形式为(k, (Iterable, Iterable))。
  • rdd1与rdd2进行组合分组操作
    在这里插入图片描述
Kox2021
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark大数据处理学习笔记（3.1）掌握RDD的创建
Python_XTyyds的博客
06-14 1527
注意：访问本地文件，必须加file://前缀，否则系统会认为是访问hdfs://master:9000/home/test.txt，从而会报错。执行命令：val rdd = sc.textFile(“hdfs://master:9000/park/test.txt”)执行命令：val rdd = sc.textFile(“hdfs://master:9000/park/test.txt”)执行命令：val rdd = sc.textFile(“file:///home/test.txt”)
Spark大数据处理学习笔记（3.8.2） Spark RDD典型案例-利用RDD统计每日新增用户
Kox_233的博客
06-15 1085
Spark大数据处理学习笔记（3.8.2） Spark RDD典型案例-利用RDD统计每日新增用户
两万字笔记快速掌握Spark大数据处理平台
O_1CxH的博客
11-08 325
Spark大数据处理 快速掌握 一个没有废话的简介 如何运行独立应用 RDD:Spark的抽象结构 RDD函数速查表
Pyspark学习笔记小总
Miracle8070
11-20 3116
pyspark官方文档: https://spark.apache.org/docs/latest/api/python/index.html pyspark案例教程: https://sparkbyexamples.com/pyspark-tutorial/这篇文章记录下最近学习的有关Pyspark以及用spark sql去处理大规模数据的一些常用语法，之前总觉得pandas是做数据分析和数据挖掘的利器， 但是工作之后，面对海量数据(上亿规模)，这才发现，普通的pandas几乎毫无用武之力，所以有必要再重
Spark大数据处理学习笔记（3.8.3） Spark RDD典型案例-利用RDD实现分组排行榜
最新发布
Kox_233的博客
06-15 935
Spark大数据处理学习笔记（3.8.3） Spark RDD典型案例-利用RDD实现分组排行榜
Spark学习笔记
NotLency的博客
01-26 1615
Spark学习笔记一、Spark是什么？1 Spark的核心组件2 Spark 运行环境2.1 Local 模式2.2 Standalone 模式2.3 配置高可用（HA ）2.4 Yarn 模式2.5 K8S & Mesos 模式2.6 Windows 模式3 Spark 运行架构3.1 运行架构3.2 核心组件3.2.1 Driver3.2.2 Executor3.2.3 Master & Worker3.2.4 ApplicationMaster 一、Spark是什么？ Spark
《Spark官方文档》监控和工具-学习笔记
TRX的博客
03-10 2003
官网链接：Monitoring and Instrumentation - Spark 3.2.1 Documentation 有几种方法可以监控Spark应用程序：Web UI、metrics 以及外部工具。 Web UI 每个SparkContext都会启动一个web UI，其默认端口为4040，并且这个web UI能展示很多有用的Spark应用相关信息。包括： 一个stage和task的调度列表 一个关于RDD大小以及内存占用的概览 运行环境相关信息 运行中的执行器相关信息 你只需打
每周一书《Spark与Hadoop大数据分析》分享！
大数据Spark教程
12-25 288
Spark与Hadoop大数据分析比较系统地讲解了利用Hadoop和Spark及其生态系统里的一系列工具进行大数据分析的方法，既涵盖ApacheSpark和Hadoop的基础知识，又深入探讨所有Spark组件——SparkCore、SparkSQL、DataFrame、DataSet、普通流、结构化流、MLlib、Graphx，以及Hadoop的核心组件（HDFS、MapReduce和Yarn）等...
sparkcore分区_Spark Core 学习笔记
weixin_34464974的博客
12-30 82
何炜杰评审人：韩晶晶 徐江河1、Spark 简介​ Spark 是一种用于大规模数据处理的统一计算引擎。它是加州大学伯克利分校AMP 实验室所开发，后又成为Apache 顶级项目。围绕着Spark 还推出了Spark SQL、Spark Streaming、MLlib 和GraphX 等组件。​ Spark使用Scala语言实现，它是一种面向对象的函数式编程语言，能够像操作本地集合对象一...
Spark大数据处理
06-26
3.2.1 RDD简介 3.2.2 RDD与分布式共享内存的异同 3.2.3 Spark的数据存储 3.3 Spark算子分类及功能 33.3.1 Value型Transformation算子 3.3.2 Key-Value型Transformation算子 3.3.3 Actions算子 3.4 本章小结
spark-3.2.1 安装包 下载 hadoop3.2
04-03
spark-3.2.1-bin-hadoop3.2-scala2.13.tgz
spark-3.2.1 安装包 集成 hadoop2.7
04-03
spark-3.2.1 安装包 集成 hadoop2.7 只将原安装包再压缩为Zip
spark3.0.1与配套的hadoop3.2.1.zip
01-04
spark3.0.1+hadoop3.2.1
spark-3.2.1 安装包 集成 hadoop3.2
04-03
spark-3.2.1 安装包 集成 hadoop3.2 只将原安装包再压缩为Zip
spark-3.2.1-bin-hadoop2.7.tgz
02-20
linux的spark新版本，匹配hadoop2.7版本，spark-3.2.1-bin-hadoop2.7.tgz
hudi0.11.0、flink1.14.4、spark3.2.1编译
05-27
基于hudi0.11.0、flink1.14.4、spark3.2.1编译。有需要的自行下载
hadoop2.7+spark3.2.1+pyspark3.2.1+python3.9
06-08
hadoop2.7+spark3.2.1+pyspark3.2.1+python3.9
spark 3.2.1 源码下载
04-02
spark-3.2.1-source code
spark sql 3.2.1 写入kudu 表
03-31
以下是将数据写入 Kudu 表的 Spark SQL 3.2.1 代码示例： ```scala import org.apache.spark.sql.SparkSession import org.apache.kudu.spark.kudu._ // 创建 SparkSession val spark = SparkSession.builder() ....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值