Scala语言与spark常用函数使用说明

已于 2024-05-16 13:03:15 修改
阅读量660 收藏 10
点赞数 17
文章标签： scala spark 开发语言
于 2024-05-16 08:55:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h_adint/article/details/138941602
版权

目录

1.Scala函数方法

1.1Map()方法

1.2foreach()方法

1.3filter()方法

1.4flatten()方法

1.5flatmap()方法

1.6.groupBy()方法

2.spark编程基础

2.1parallelize()

2.2makeRDD()

2.3textfile()

2.4Map()方法

2.5sortBy()方法

2.6collect()方法

2.7flatMap()

2.8take（）方法

2.9union（）方法

3.0distinst()方法

3.1cartesian() 方法

3.2reduceByKey()

3.3groupBykey()

3.4combineByKey() 

3.5join()方法

1.Scala函数方法

1.1Map()方法

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)
  }
}

结果：

1.2foreach()方法

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))
  }
}

结果：

1.3filter()方法

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)

  }
}

结果：

1.4flatten()方法

flatten() 方法在 Scala 中用于将嵌套的集合结构“扁平化”，即将多层嵌套的集合转换为单层的集合。例如，如果你有一个包含多个列表的列表，你可以使用 flatten() 方法将其转换为一个单独的列表，其中包含了所有元素：

代码 :

object one {
  def main(args: Array[String]): Unit = {
    val nestedList = List(List(1, 2), List(3, 4), List(5, 6))
    val flatList = nestedList.flatten

    println(flatList)
  }
}

结果：

1.5flatmap()方法

flatMap() 方法是一种结合了 map() 和 flatten() 的功能的高阶函数。它通常用于在集合上应用一个函数，并将结果扁平化成一个单层的集合。

具体来说，flatMap() 方法首先对集合中的每个元素应用一个函数，然后将结果集合中的每个子集合合并成一个大的集合。

代码：

object one {
  def main(args: Array[String]): Unit = {
    val list = List(List(1, 2), List(3, 4), List(5, 6))

    // 使用 flatMap() 方法将嵌套的列表转换为单层列表
    val flatMappedList = list.flatMap(x => x)

    println(flatMappedList)
  }
}

结果：

1.6.groupBy()方法

groupBy() 方法用于根据给定函数对集合中的元素进行分组，并返回一个 Map，其中键是分组的结果，而值是相应分组的元素列表。

代码：

object one {
  def main(args: Array[String]): Unit = {
    val list = List("apple", "banana", "grape", "apricot", "blueberry")

    // 使用 groupBy() 方法根据字符串长度进行分组
    val groupedMap = list.groupBy(_.length)

    println(groupedMap)

  }
}

结果：

2.spark编程基础

2.1parallelize()

parallelize() 方法是 Apache Spark 中的一个函数，用于将现有的集合转换为分布式数据集（RDD）。在 Spark 中，RDD（Resilient Distributed Dataset）是一种表示分布在多台计算机上的数据集合的数据结构。通过将数据集分布在多台计算机上，Spark 可以实现并行计算，加速数据处理过程。

代码：

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.2makeRDD()

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()
  }
}

结果：

2.3textfile()

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()
  }
}

结果：

2.4Map()方法

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()
  }
}

结果：

2.5sortBy()方法

在 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()
  }
}

结果：

2.6collect()方法

在 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()
  }
}

结果：

2.7flatMap()

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)
  }
}

结果：

2.8take（）方法

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)
  }
}

结果：

2.9union（）方法

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)
  }
}

结果：

3.0distinst()方法

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)
  }
}

结果：

3.1cartesian() 方法

用于计算两个 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()

  }
}

结果：

3.2reduceByKey()

用于将具有相同键的元素进行归约操作。它接收一个函数作为参数，该函数定义了对具有相同键的值进行合并的方式，并返回一个新的 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()

  }
}

结果：

3.3groupBykey()

用于将具有相同键的元素进行分组。它接收一个键值对 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()

  }
}

结果：

3.4combineByKey() 

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

代码：

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()
  }
}

结果：

3.5join()方法

用于将两个 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()

  }
}

结果：

Hadint。
关注
spark常用函数
大牛牛
09-22 4759
! ! expr -逻辑非 . % expr1 % expr2 -在expr1/expr2之后返回剩余的部分. Examples: > SELECT 2 % 1.8; 0.2 > SELECT MOD(2, 1.8); 0.2 & expr1 & expr2 -返回和expr1和expr2的结果. Examples: > SELECT 3 & 5; 1 ...
spark scala 常用函数
weixin_42155006的博客
03-19 713
spark常用函数整理 CONCAT_WS(separator,str1,str2,…) 将多个字符串连接成一个字符串并用分隔符隔开 reduceByKey(binary_function) Key相同的元素的Value进行binary_function的合并操作，如若括号内为(x,y) => x + y则表示对key相同元素value求和 .drop(列名) 用来丢弃指定列，na.drop用来丢弃行 ...
spark 常用函数介绍（python）
03-13 268
以下是个人理解，一切以官网文档为准。 http://spark.apache.org/docs/latest/api/python/pyspark.html 在开始之前，我先介绍一下，RDD是什么？ RDD是Spark中的抽象数据结构类型，任何数据在Spark中都被表示为RDD。从编程的角度来看，RDD可以简单看成是一个数组。和普通数组的区别是，RDD中的数据是分...
Spark内置函数:字符串、日期和时间函数、聚合函数、数值函数、条件判断函数、窗口函数
最新发布
m0_70882914的博客
10-15 993
Spark内置函数:字符串、日期和时间函数、聚合函数、数值函数、条件判断函数、窗口函数
spark 常用函数总结
航天飞哥的博客
06-02 5109
1, textFile()  读取外部数据源 2, map() 对每一条数据进行相应的处理 如切分 3, reduceByKey(_+_) 传入一个函数，将key相同的一类进行聚合计算 如相加 4, mapvalues(_+10) 传入一个函数，类似于map方法，不过这里只是对元组中的value进行计算 5,filter() 传入一个函数， 用户过滤处理数据
Scala和Spark大数据分析函数式编程、数据流和机器学习
04-23
Scala是一种静态类型的函数式编程语言，而Spark是一个分布式计算框架，尤其适合于大数据处理和分析。本教程将深入探讨这两者如何结合，实现高效的大数据分析、数据流处理以及机器学习任务。 首先，让我们来理解...
基于scala语言的spark操作，包含连接操作mysql，连接hdfs.zip
03-20
本教程将探讨如何使用 Scala 语言来操作 Spark，并介绍如何与 MySQL 数据库和 HDFS（Hadoop 分布式文件系统）进行交互。以下是相关知识点的详细说明： **1. Scala 语言基础** Scala 是一种多范式编程语言，融合了...
Spark常用的算子以及Scala函数总结.pdf
05-17
了解 Scala 是学习 Spark 的一大优势，因为 Spark 中的许多高级功能和 API 都是用 Scala 实现的，因此使用 Scala 访问这些功能和 API 会更加简单。 在 Spark 中，数据以弹性分布式数据集（RDD）的形式存在，RDD 是 ...
utility_Scala:Scala编程语言基本和函数式编程（fp）和Spark Scala基本演示| #SE
03-12
Utility_Scala 在常见的用例中，通过几个基本脚本介绍了Scala programming language和Spark Scala 。 请检查以获取更多信息。 Scala项目 我的Coursera Scala系列课程的... ， -Scala列表与数组非常相似，这意味着列
Spark常用函数
06-20 817
Hive常用函数总结，适用于符合SQL规范的数据库和Spark等分析引擎
sparkRDD函数大全
02-28
spark rdd函数大全。spark rdd操作为core操作，虽然后续版本主要以dataset来操作，但是rdd操作也是不可忽略的一部分。
Spark RDD常用的函数
nwpuxhld
04-25 1364
Spark RDD常用函数
spark基本函数
Python300的博客
04-09 512
aggregate()函数可以对一个RDD中的所有元素进行聚合计算，并返回一个结果。与reduce()不同的是，aggregate()可以同时对多个聚合函数进行计算。filter()函数可以根据条件过滤出符合条件的元素，并返回一个新的RDD。map()函数可以将RDD中的每个元素都执行一个函数，并返回一个新的RDD。groupBy()函数可以根据指定的键将数据分组，并返回一个新的RDD。reduce()函数可以将一个RDD中的所有元素进行聚合计算，并返回一个结果。# 过滤出年龄大于25岁的数据。
spark常见的函数
u014156013的博客
07-22 423
http://spark.apache.org/docs/latest/api/scala/index.html#package
Spark函数
feizuiku0116的博客
11-20 945
一、Spark函数分类 Transformation转换操作：返回一个新的RDD 所有Transformation函数都是Lazy，不会立即执行，需要函数触发 Action动作操作：返回值不是RDD（无返回值或返回其他的） 所有Action函数立即执行（Eager），比如count、first、collect、take等 二、Transformation函数 在Spark中Transformation操作表示将一个RDD通过一系列操作变为另一个RDD的过程，这个操作可能是简单的加减操作，也可
Spark(一) ：Scala
qq_35909080的博客
08-10 2419
1  Scala是一门怎样的语言，具有哪些优点  一致性 : 静态类型系统+面向对象+函数式编程 面向对象 : 所有的变量和方法都封装在对象中 函数式编程 :函数可以独立存在，可以定义一个函数作为 另外一个函数的返回值，也可以接受函数作为函数的参数 异步编程 : 函数式编程提倡变量不可变，使得异步编程变得十分容易 基于JVM : Scala会被编译成为Bytecode，所以Scala能无...
spark常用小函数
u012073033的专栏
12-06 252
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...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值