spark常用函数和Scala语言的使用

已于 2024-05-16 20:07:19 修改
阅读量734 收藏 18
点赞数 19
文章标签： spark scala 大数据
于 2024-05-16 20:06:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83205962/article/details/138973014
版权

目录

spark编程基础

1.parallelize()

2.makeRDD()

3.textfile()

4.Map()方法

5.sortBy()方法

6.collect()方法

7.flatMap()

8.take（）方法

9.union（）方法

10.distinst()方法

11.cartesian() 方法

12.reduceByKey()

13.groupBykey()

14.combineByKey() 

15.join()方法

Scala语言

1.Map()方法

2.foreach()方法

3.filter()方法

spark编程基础

1.parallelize()

import org.apache.spark.{SparkConf, SparkContext}
 
object one {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("example").setMaster("local[*]")
    val sc = new SparkContext(conf)
    // 创建一个包含整数的列表
    val data = List(1, 2, 3, 4, 5)
 
    // 使用 parallelize() 方法将列表转换为 RDD
    val rdd = sc.parallelize(data)
 
    // 对 RDD 执行一些操作
    val sum = rdd.reduce(_ + _)
 
    println("Sum of elements in RDD: " + sum)
 
  }
}

运行结果

2.makeRDD()

makeRDD() 是一个用于创建 RDD（弹性分布式数据集）的方法。它可以将一个已存在的集合或数组转换为一个 RDD，使得数据能够在 Spark 集群上进行并行计算。

import org.apache.spark.{SparkConf, SparkContext}
 
object one {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建一个包含整数的列表
    val data = List(1, 2, 3, 4, 5)
 
    // 使用 makeRDD() 方法将列表转换为 RDD
    val rdd = sc.makeRDD(data)
 
    // 对 RDD 执行一些操作
    val sum = rdd.reduce(_ + _)
 
    println("Sum of elements in RDD: " + sum)
 
    sc.stop()
  }
}

运行结果

3.textfile()

textFile() 是一个用于读取文本文件并将其转换为 RDD 的方法。该方法可以接受一个或多个文件路径，并将它们转换为 RDD

import org.apache.spark.{SparkConf, SparkContext}
 
object SparkApp {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 使用 textFile() 方法读取文本文件并创建 RDD
    val rdd = sc.textFile("C:\\Users\\Administrator\\Desktop\\a.txt")
 
 
    // 对 RDD 执行一些操作
    val count = rdd.count()
 
    println("Number of lines in RDD: " + count)
 
    sc.stop()
  }
}

运行结果

4.Map()方法

Spark 中，map() 是一个用于对 RDD 中的每个元素执行转换操作的方法。该方法接受一个适用于 RDD 中每个元素的函数，并返回一个新的 RDD

import org.apache.spark.{SparkConf, SparkContext}
 
object SparkApp {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建一个包含整数的列表
    val data = List(1, 2, 3, 4, 5)
 
    // 使用 makeRDD() 方法将列表转换为 RDD
    val rdd = sc.makeRDD(data)
 
    // 对 RDD 中的每个元素执行平方操作
    val squaredRDD = rdd.map(x => x * x)
 
    // 输出转换后的 RDD 中的元素
    squaredRDD.foreach(println)
 
    sc.stop()
  }
}

运行结果

5.sortBy()方法

在 Spark 中，sortBy() 是一个用于对 RDD 中的元素进行排序的方法。该方法接受一个排序函数和一个布尔值参数，用于指定排序方式（升序或降序），并返回一个新的已排序的 RDD。

import org.apache.spark.{SparkConf, SparkContext}
 
object SparkApp {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建一个包含整数的列表
    val data = List(5, 3, 1, 4, 2)
 
    // 使用 makeRDD() 方法将列表转换为 RDD
    val rdd = sc.makeRDD(data)
 
    // 对 RDD 中的元素进行排序
    val sortedRDD = rdd.sortBy(x => x, ascending = true)
 
    // 输出排序后的 RDD 中的元素
    sortedRDD.foreach(println)
 
    sc.stop()
  }
}

运行结果

6.collect()方法

在 Spark 中，collect() 是一个用于将 RDD 中的所有元素收集到驱动程序中的方法。该方法会以数组的形式返回 RDD 中的所有元素，并且需要注意的是，如果 RDD 太大无法一次性放入内存中，则可能会导致内存溢出。

import org.apache.spark.{SparkConf, SparkContext}
 
object SparkApp {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建一个包含整数的列表
    val data = List(1, 2, 3, 4, 5)
 
    // 使用 makeRDD() 方法将列表转换为 RDD
    val rdd = sc.makeRDD(data)
 
    // 使用 collect() 方法将 RDD 中的所有元素收集到驱动程序中
    val collected = rdd.collect()
 
    // 输出收集到的 RDD 元素
    collected.foreach(println)
 
    sc.stop()
  }
}

运行结果

7.flatMap()

flatMap() 方法是 Spark 中常用的一个转换操作，它可以将一个 RDD 中的每个元素映射成一个或多个新的元素，并将这些元素合并为一个新的 RDD。

import org.apache.spark.{SparkConf, SparkContext}
 
object SparkApp {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SparkApp").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val words = sc.parallelize(Seq("Hello", "world", "this", "is", "Spark"))
    words.foreach(println)
    val chars = words.flatMap(word => word.toCharArray)
    chars.foreach(println)
  }
}

运行结果

8.take（）方法

take() 方法用于从集合中获取指定数量的元素，返回一个新的集合。

package com
 
object one {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4, 5)
 
    // 取前3个元素
    val result1 = list.take(3)
    println(result1)
 
    // 对于空集合，take() 方法返回一个空集合
    val emptyList = List.empty[Int]
    val result2 = emptyList.take(3)
    println(result2)
 
    // 如果指定的数量大于集合中的元素数量，将返回整个集合
    val result3 = list.take(10)
    println(result3)
  }
}

运行结果

9.union（）方法

union() 方法用于将两个集合合并成一个新的集合，去除重复的元素。它是集合类的方法之一，适用于 Set 和 Seq 类型的集合。

package com
 
object one {
  def main(args: Array[String]): Unit = {
    val set1 = Set(1, 2, 3)
    val set2 = Set(3, 4, 5)
 
    val result = set1.union(set2)
    println(result)
  }
}

运行结果

10.distinst()方法

distinct() 方法用于从集合中移除重复的元素，并返回一个包含唯一元素的新集合。这个方法适用于 Seq、Set 和 Map 类型的集合。

package com
 
object one {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 2, 3, 3, 4, 5, 5)
 
    val uniqueList = list.distinct
    println(uniqueList)
  }
}

运行结果

11.cartesian() 方法

用于计算两个 RDD 的笛卡尔积（Cartesian product）。笛卡尔积是两个集合之间的所有可能的组合，其中一个元素来自第一个集合，另一个元素来自第二个集合。

package com
 
import org.apache.spark.{SparkConf, SparkContext}
 
object one {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("RDDCartesianExample").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建两个RDD
    val rdd1 = sc.parallelize(Seq("A", "B", "C"))
    val rdd2 = sc.parallelize(Seq(1, 2, 3))
 
    // 计算两个RDD的笛卡尔积
    val cartesianRDD = rdd1.cartesian(rdd2)
 
    // 打印结果
    cartesianRDD.collect().foreach(println)
 
    sc.stop()
 
  }
}

运行结果

12.reduceByKey()

用于将具有相同键的元素进行归约操作。它接收一个函数作为参数，该函数定义了对具有相同键的值进行合并的方式，并返回一个新的 RDD。

package com
 
import org.apache.spark.{SparkConf, SparkContext}
 
object one {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("ReduceByKeyExample").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建一个包含键值对的RDD
    val data = Seq(("a", 1), ("b", 2), ("a", 3), ("b", 4), ("c", 5))
    val rdd = sc.parallelize(data)
 
    // 对具有相同键的值进行求和
    val result = rdd.reduceByKey(_ + _)
 
    // 打印结果
    result.collect().foreach(println)
 
    sc.stop()
 
  }
}

运行结果

13.groupBykey()

用于将具有相同键的元素进行分组。它接收一个键值对 RDD 作为输入，并返回一个新的 RDD，其中的元素是按键分组的。

package com
 
import org.apache.spark.{SparkConf, SparkContext}
 
object one {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("GroupByKeyExample").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建一个包含键值对的RDD
    val data = Seq(("a", 1), ("b", 2), ("a", 3), ("b", 4), ("c", 5))
    val rdd = sc.parallelize(data)
 
    // 按键分组
    val groupedRDD = rdd.groupByKey()
 
    // 打印结果
    groupedRDD.collect().foreach(println)
 
    sc.stop()
 
  }
}

运行结果

14.combineByKey() 

用于执行基于键的聚合操作的高级转换函数之一。它提供了一种灵活的方式来对每个键的值进行聚合，而不需要事先进行预先聚合或排序。

package com
 
import org.apache.spark.{SparkConf, SparkContext}
 
object one {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("CombineByKeyExample").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建一个包含键值对的RDD
    val rdd = sc.parallelize(Seq(("apple", 3), ("banana", 5), ("apple", 7), ("banana", 2), ("orange", 1)))
 
    // 使用combineByKey方法进行基于键的聚合操作
    val aggregatedRDD = rdd.combineByKey(
      createCombiner = (v: Int) => (v, 1), // 初始化值为(v, 1)，其中v是值，1表示计数
      mergeValue = (acc: (Int, Int), v: Int) => (acc._1 + v, acc._2 + 1), // 将新值合并到已存在的聚合值中，并更新计数
      mergeCombiners = (acc1: (Int, Int), acc2: (Int, Int)) => (acc1._1 + acc2._1, acc1._2 + acc2._2) // 合并不同分区的聚合值，并更新计数
    )
 
    // 打印结果
    aggregatedRDD.collect().foreach(println)
 
    sc.stop()
  }
}

运行结果

15.join()方法

用于将两个 RDD 按照键进行连接操作。它接收另一个键值对 RDD 作为参数，并返回一个新的 RDD，其中的元素是两个原始 RDD 中具有相同键的元素的笛卡尔积。

package com
 
import org.apache.spark.{SparkConf, SparkContext}
 
object one {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("JoinExample").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建两个包含键值对的RDD
    val rdd1 = sc.parallelize(Seq(("a", 1), ("b", 2), ("c", 3)))
    val rdd2 = sc.parallelize(Seq(("a", "apple"), ("b", "banana"), ("c", "cherry")))
 
    // 使用join方法进行连接操作
    val joinedRDD = rdd1.join(rdd2)
 
    // 打印结果
    joinedRDD.collect().foreach(println)
 
    sc.stop()
 
  }
}

运行结果

Scala语言

1.Map()方法

map()是一种高阶函数，通常用于对集合（比如List、Array等）中的每个元素进行映射转换。它接受一个函数作为参数，该函数会被应用到集合中的每个元素上，并返回一个新的集合，其中包含了原集合中每个元素经过函数转换后的结果。

object one {
  def main(args: Array[String]): Unit = {
    // 定义一个列表
    val a = List(1, 2, 3, 4, 5)
 
    // 使用map()函数将列表中的每个元素乘以2
    val b = a.map(x => x * 2)
 
    // 打印转换后的列表
    println(b)
  }
}

运行结果

2.foreach()方法

foreach() 是 Scala 中常用的集合操作方法之一，用于对集合中的每个元素执行指定的操作，但不返回任何结果。与 map() 不同的是，foreach() 主要用于执行副作用操作，而不是对集合中的元素进行转换。

object one {
  def main(args: Array[String]): Unit = {
    // 定义一个列表
    val numbers = List(1, 2, 3, 4, 5)
 
    // 使用 foreach() 方法打印列表中的每个元素
    numbers.foreach(x => println(x))
  }
}

运行结果

3.filter()方法


filter() 方法是 Scala 中常用的集合操作方法之一，用于筛选出集合中满足指定条件的元素，并返回一个新的集合包含满足条件的元素。这个方法接受一个函数作为参数，该函数会被应用到集合中的每个元素上，如果函数返回 true，则该元素会被包含在结果集合中，否则不包含。

object one {
  def main(args: Array[String]): Unit = {
    // 定义一个列表
    val numbers = List(1, 2, 3, 4, 5)
 
    // 使用 filter() 方法筛选出列表中大于 2 的元素
    val filteredNumbers = numbers.filter(x => x > 2)
 
    // 打印筛选后的列表
    println(filteredNumbers)
 
  }
}

运行结果

岸柳垂湖
关注
  • 19
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spark scala 常用函数
weixin_42155006的博客
03-19 678
spark常用函数整理 CONCAT_WS(separator,str1,str2,…) 将多个字符串连接成一个字符串并用分隔符隔开 reduceByKey(binary_function) Key相同的元素的Value进行binary_function的合并操作，如若括号内为(x,y) => x + y则表示对key相同元素value求和 .drop(列名) 用来丢弃指定列，na.drop用来丢弃行 ...
java spark map函数_Scala系列8：函数式编程之map，flatten,flatmap的使用详解
weixin_31613447的博客
03-04 928
0.Scala函数式编程我们将来使用Spark/Flink的大量业务代码都会使用到函数式编程。下面这些事开发中常用的函数式编程。注意这些函数都是操作 Scala 集合的，一般会进行两类操作：转换操作(transformation )和行动操作(actions)(有些人喜欢叫他为聚合操作)。第一种操作类型将集合转换为另一个集合，第二种操作类型返回某些类型的值。遍历( foreach )映射( map...
spark 常用函数介绍（python）
03-13 254
以下是个人理解，一切以官网文档为准。 http://spark.apache.org/docs/latest/api/python/pyspark.html 在开始之前，我先介绍一下，RDD是什么？ RDD是Spark中的抽象数据结构类型，任何数据在Spark中都被表示为RDD。从编程的角度来看，RDD可以简单看成是一个数组。和普通数组的区别是，RDD中的数据是分...
Scala语言与spark常用函数使用说明
最新发布
h_adint的博客
05-16 604
map()
spark常用函数
w757227129的博客
10-09 1884
spark内置函数
Scala和Spark大数据分析函数式编程、数据流和机器学习
04-23
Scala是一种静态类型的函数式编程语言，而Spark是一个分布式计算框架，尤其适合于大数据处理和分析。本教程将深入探讨这两者如何结合，实现高效的大数据分析、数据流处理以及机器学习任务。 首先，让我们来理解...
Spark常用的算子以及Scala函数总结.pdf
05-17
了解 Scala 是学习 Spark 的一大优势，因为 Spark 中的许多高级功能和 API 都是用 Scala 实现的，因此使用 Scala 访问这些功能和 API 会更加简单。 在 Spark 中，数据以弹性分布式数据集（RDD）的形式存在，RDD 是 ...
utility_Scala:Scala编程语言基本和函数式编程（fp）和Spark Scala基本演示| #SE
03-12
在常见的用例中，通过几个基本脚本介绍了Scala programming language和Spark Scala 。 请检查以获取更多信息。 Scala项目 我的Coursera Scala系列课程的注释/代码 将Hadoop生态系统作业提交到AWS EMR的演示 各种...
spark 常用函数总结
航天飞哥的博客
06-02 5069
1, textFile()  读取外部数据源 2, map() 对每一条数据进行相应的处理 如切分 3, reduceByKey(_+_) 传入一个函数，将key相同的一类进行聚合计算 如相加 4, mapvalues(_+10) 传入一个函数，类似于map方法，不过这里只是对元组中的value进行计算 5,filter() 传入一个函数， 用户过滤处理数据
sparkRDD函数大全
02-28
spark rdd函数大全。spark rdd操作为core操作，虽然后续版本主要以dataset来操作，但是rdd操作也是不可忽略的一部分。
Spark 入门之 Scala 语言解释及示例讲解
05-15
spark官方文档中文版本，希望对于刚入门的同学有帮助。
spark常见的函数
u014156013的博客
07-22 402
http://spark.apache.org/docs/latest/api/scala/index.html#package
Spark(一) ：Scala
qq_35909080的博客
08-10 2392
1  Scala是一门怎样的语言，具有哪些优点  一致性 : 静态类型系统+面向对象+函数式编程 面向对象 : 所有的变量和方法都封装在对象中 函数式编程 :函数可以独立存在，可以定义一个函数作为 另外一个函数的返回值，也可以接受函数作为函数的参数 异步编程 : 函数式编程提倡变量不可变，使得异步编程变得十分容易 基于JVM : Scala会被编译成为Bytecode，所以Scala能无...
spark常用小函数
u012073033的专栏
12-06 229
1、keyBy 为rdd按指定key生成key-value形式 scala> val a = sc.parallelize(List("dog", "salmon", "salmon", "rat", "elephant"), 3) a: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[123] at paralleliz...
spark基本函数
Python300的博客
04-09 478
aggregate()函数可以对一个RDD中的所有元素进行聚合计算，并返回一个结果。与reduce()不同的是，aggregate()可以同时对多个聚合函数进行计算。filter()函数可以根据条件过滤出符合条件的元素，并返回一个新的RDD。map()函数可以将RDD中的每个元素都执行一个函数，并返回一个新的RDD。groupBy()函数可以根据指定的键将数据分组，并返回一个新的RDD。reduce()函数可以将一个RDD中的所有元素进行聚合计算，并返回一个结果。# 过滤出年龄大于25岁的数据。
Spark RDD常用的函数
nwpuxhld
04-25 1338
Spark RDD常用函数
Spark大数据技术（Scala）小白教程（一)——大数据技术概述以及环境配置_spark scala教程
2401_84166811的博客
04-15 1246
Apache Spark 是一个基于内存计算的大数据处理框架，提供了高性能和灵活性，支持多种数据处理模式。Spark 提供了丰富的 API，包括 Spark Core、Spark SQL、Spark Streaming、MLlib（机器学习库）和 GraphX（图计算库），使得用户可以方便地进行数据处理、数据分析和机器学习等任务。
Spark基础-Scala集合的操作
Xlucas的博客
08-16 577
核心 1、scala集合的操作package com.xlucas import scala.collection.mutable.ArrayBuffer /* * Created by xlucas on 2017/8/15 0015. * scala 中数据的创建和操作 * 1、最原始的创建数据的方式 val array=new Array[Int](5) * 2、数据的长度和J
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值