【Spark基础练习题一】

已于 2022-06-10 09:10:34 修改
阅读量2.8k 收藏 29
点赞数 1
分类专栏： # Spark练习题 文章标签： spark
于 2020-11-29 14:43:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45797116/article/details/110312016
版权

简单配置环境

package spark练习题.练习题01

import org.apache.spark.rdd.{JdbcRDD, RDD}
import org.apache.spark.{SparkConf, SparkContext}
import org.junit.Test
import org.mortbay.util.ajax.JSON

class e01 {

  val conf = new SparkConf().setAppName("test").setMaster("local[6]")
  val sc = new SparkContext(conf)

1、创建一个1-10数组的RDD，将所有元素*2形成新的RDD

  @Test
  def e01(): Unit ={
    val rdd = sc.parallelize(1 to 10)
    val maprdd = rdd.map(_*2)
    maprdd.collect().foreach(println(_))
  }

//2、创建一个10-20数组的RDD，使用mapPartitions将所有元素*2形成新的RDD

  @Test
  def e02(): Unit ={
    val rdd = sc.parallelize(10 to 20,2)
    val mappartitionrdd = rdd.mapPartitions(_.map(_*2))
    mappartitionrdd.collect().foreach(println(_))
  }

//3、创建一个元素为 1-5 的RDD，运用 flatMap创建一个新的 RDD，新的 RDD 为原 RDD 每个元素的 平方和三次方
来组成 1,1,4,8,9,27…

@Test
  def e03(): Unit ={
    val rdd = sc.parallelize(1 to 5)
    val flatrdd = rdd.flatMap(x => Array(Math.pow(x,2).toInt,Math.pow(x,3).toInt))
    flatrdd.foreach(println(_))
  }

//4、创建一个 4 个分区的 RDD数据为Array(10,20,30,40,50,60)，使用glom将每个分区的数据放到一个数组

 @Test
  def e04(): Unit ={
    val rdd = sc.parallelize(Array(10,20,30,40,50,60),4)
    val glom = rdd.glom().collect()
    glom.foreach(println(_))
    for(i <- glom;j <- i)
      println(j)
  }

//5、创建一个 RDD数据为Array(1, 3, 4, 20, 4, 5, 8)，按照元素的奇偶性进行分组

@Test
  def e05(): Unit ={
    val rdd = sc.parallelize(Array(1, 3, 4, 20, 4, 5, 8))
    val rdd1 = rdd.groupBy(
      item =>
        if (item%2==0) "偶数" else "基数"
    )
    rdd1.collect().foreach(print(_))
  }

//6、创建一个 RDD（由字符串组成）Array(“xiaoli”, “laoli”, “laowang”, “xiaocang”,
“xiaojing”, “xiaokong”)，过滤出一个新 RDD（包含“xiao”子串）

 @Test
  def e06(): Unit ={
    val rdd = sc.parallelize(Array("xiaoli", "laoli", "laowang", "xiaocang", "xiaojing", "xiaokong"))
    val filter = rdd.filter(_.contains("xiao"))
    filter.collect().foreach(println(_))
  }

//7、创建一个 RDD数据为1 to 10，请使用sample不放回抽样

  @Test
  def e07(): Unit ={
    val rdd = sc.parallelize(1 to 10)
    val sample = rdd.sample(withReplacement = false,0.5,2)
    sample.collect().foreach(println(_))
  }

//8、创建一个 RDD数据为1 to 10，请使用sample放回抽样

  @Test
  def e08(): Unit ={
    val rdd = sc.parallelize(1 to 10)
    val sample = rdd.sample(withReplacement = true,0.5,1)
    sample.collect().foreach(println(_))
  }

//9、创建一个 RDD数据为Array(10,10,2,5,3,5,3,6,9,1),对 RDD 中元素执行去重操作

 @Test
  def e09(){
    val rdd = sc.parallelize(Array(10,10,2,5,3,5,3,6,9,1))
    val dupl = rdd.distinct()
    dupl.collect().foreach(println(_))
  }

//10、创建一个分区数为5的 RDD，数据为0 to 100，之后使用coalesce再重新减少分区的数量至 2 //
创建一个分区数为5的 RDD，数据为0 to 100，之后使用repartition再重新减少分区的数量至 3

  @Test
  def e10(){
    val rdd = sc.parallelize(0 to 100,5)
    val coalesce = rdd.coalesce(2)
    println(coalesce.partitions.size)

    val repartition = rdd.repartition(3)
    println(repartition.partitions.size)
  }

//11、创建一个 RDD数据为1,3,4,10,4,6,9,20,30,16,请给RDD进行分别进行升序和降序排列

  @Test
  def e11(): Unit ={
    val rdd = sc.parallelize(Array(1,3,4,10,4,6,9,20,30,16))
    val desc = rdd.sortBy(x => x, false)
    val asc = rdd.sortBy(x => x, true)
    desc.collect().foreach(println(_ ))
    asc.collect().foreach(println(_))
  }

//12、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和1 to 10，求并集 //
创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和4 to 10，计算差集，两个都算 //
创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和1 to 10，计算交集 //
创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和1 to 10，计算 2 个 RDD 的笛卡尔积

  @Test
  def e12(): Unit ={
    val rdd = sc.parallelize(1 to 6)
    val rdd1 = sc.parallelize(1 to 10)
    val rdd2 = rdd.union(rdd1)
    rdd2.collect().foreach(println(_))

    val rdd3 = sc.parallelize(1 to 6)
    val rdd4 = sc.parallelize(4 to 10)
    val rdd5 = rdd3.subtract(rdd4)
    val rdd5_1= rdd4.subtract(rdd3)
    rdd5.collect().foreach(println(_))
    rdd5_1.collect().foreach(println(_))

    val rdd6 = sc.parallelize(1 to 6)
    val rdd7 = sc.parallelize(1 to 10)
    val rdd8 = rdd6.intersection(rdd7)
    rdd8.collect().foreach(println(_))

    val rdd6_1 = sc.parallelize(1 to 6)
    val rdd7_1 = sc.parallelize(1 to 10)
    val rdd8_1 = rdd6_1.cartesian(rdd7_1)
    rdd8_1.collect().foreach(println(_))
  }

//13、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 5和11 to 15，对两个RDD拉链操作

 @Test
  def e13(): Unit ={
    val rdd = sc.parallelize(1 to 5)
    val rdd1 = sc.parallelize(11 to 15)
    val rdd2 = rdd.zip(rdd1)
    rdd2.collect().foreach(println(_))
  }

//14、创建一个RDD数据为List((“female”,1),(“male”,5),(“female”,5),(“male”,2))，请计算出female和male的总数分别为多少

 @Test
  def e14(): Unit ={
    val rdd = sc.parallelize(List(("female",1),("male",5),("female",5),("male",2)))
    val reduce = rdd.reduceByKey((curr,agg)=>curr+agg)
    reduce.collect().foreach(println(_))
  }

//15、创建一个有两个分区的
RDD数据为List((“a”,3),(“a”,2),(“c”,4),(“b”,3),(“c”,6),(“c”,8))，取出每个分区相同key对应值的最大值，然后相加

 @Test
  def e15(): Unit ={
    val rdd = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
    val rdd1= rdd.glom().collect().foreach(x => println(x.mkString(",")))  // 将数组转换成字符串打印出来
    val rdd2 = rdd.aggregateByKey(0)(math.max(_,_),_+_)
    rdd2.collect().foreach(println(_))
  }

//16、创建一个有两个分区的 pairRDD数据为Array((“a”, 88), (“b”, 95), (“a”, 91),(“b”, 93), (“a”, 95), (“b”, 98))，根据 key 计算每种 key 的value的平均值

  @Test
  def e16(): Unit ={
    val rdd = sc.parallelize(Array(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98)),2)
    // 1
    val rdd1 = rdd.groupByKey().map(x=>x._1->x._2.sum/x._2.size)
    rdd1.collect().foreach(println(_))
    // 2
    val rdd2 = rdd.map(x=>(x._1,(x._2,1)))
      .reduceByKey((x,y)=>(x._1+y._1,x._2+y._2))
      .map(x=>(x._1,x._2._1/x._2._2))
    rdd2.collect().foreach(println(_))
  }

//17、统计出每一个省份广告被点击次数的 TOP3 // 数据结构：时间戳，省份，城市，用户，广告 字段使用空格分割。 //
样本如下： // 1516609143867 6 7 64 26 // 1516609143861 8 4 75 28 //
1516609143864 8 7 87 22 // 1516609143865 6 7 64 36 //
1516609143866 9 4 75 38 // 1516609143868 6 7 87 32 //
1516609143857 6 7 64 16 // 1516609143859 9 4 75 48 //
1516609143859 1 7 87 42 // 1516609143847 6 7 64 26 //
1516609143859 9 4 75 48 // 1516609143849 1 7 87 42 //
1516609143837 6 7 64 86 // 1516609143839 9 4 75 78 //
1516609143829 1 7 87 32 // 1516609143827 6 7 64 76 //
1516609143829 9 4 75 98 // 1516609143819 1 7 87 112

 @Test
  def e17(): Unit ={
    val rdd = sc.textFile("src/main/scala/spark练习题/练习题01/data/ads")
    //rdd.take(2).foreach(println(_))
    rdd.map { x => var data = x.split(" ");(data(1),(data(4),1))}
      .groupByKey()
//    (8,CompactBuffer((28,1), (22,1)))
//    (6,CompactBuffer((26,1), (36,1), (32,1), (16,1), (26,1), (86,1), (76,1)))
//    (9,CompactBuffer((38,1), (48,1), (48,1), (78,1), (98,1)))
//    (1,CompactBuffer((42,1), (42,1), (32,1), (112,1)))
      .map{
        case (province,list) => {
          val tuples =
            list.groupBy(_._1).map(x=>(x._1,x._2.size)).toList.sortWith((x,y)=>x._2>y._2).take(3)
          (province,tuples)
      }
    }.collect().sortBy(_._1).foreach(println)
  }

//18、读取 people.json 数据的文件, 每行是一个 json 对象，进行解析输出

 @Test
  def e18(): Unit ={
    import scala.util.parsing.json.JSON
    val rdd = sc.textFile("hdfs://192.168.64.129:9000/user/root/spark/sparkSql/people.json")
    val result = rdd.map(JSON.parseFull)
    result.collect().foreach(println(_))
  }

//19、保存一个 SequenceFile 文件，使用spark创建一个RDD数据为Array((“a”, 1),(“b”,
2),(“c”, 3))，保存为SequenceFile格式的文件到hdfs上 // 读取19题的SequenceFile
文件并输出

@Test
  def e19(): Unit ={
    val rdd = sc.parallelize(Array(("a", 1), ("b", 2), ("c", 3)))
    // 写入
    //rdd.saveAsSequenceFile("hdfs://192.168.64.129:9000/user/root/spark/sparkSql/SequenceFile")
    // 读取
    val rdd1 = sc.sequenceFile[String,Int]("hdfs://192.168.64.129:9000/user/root/spark/sparkSql/SequenceFile/part-00001")
    rdd1.collect().foreach(println(_))
  }

// 20.读写 objectFile 文件，把 RDD 保存为objectFile，RDD数据为Array((“a”, 1),(“b”,
2),(“c”, 3))，并进行读取出来

  @Test
  def e20(): Unit ={
    val rdd = sc.makeRDD(Array(("a", 1), ("b", 2), ("c", 3)))
    //rdd.saveAsObjectFile("src/main/scala/spark练习题/练习题01/data/output20200407/20200407_objectFile")
    val rdd1 = sc.objectFile("src/main/scala/spark练习题/练习题01/data/output20200407/20200407_objectFile/part-00001")
    println(rdd1)
  }

//21.使用内置累加器计算Accumulator.txt文件中空行的数量

  @Test
  def e21(): Unit ={
    val rdd = sc.textFile("src/main/scala/spark练习题/练习题01/data/Accumulator")
    var count = sc.longAccumulator("count")
    rdd.foreach(x => if (x=="") count.add(1))
    println(count.value)
  }

//22.使用Spark广播变量
//用户表：
//id name age gender(0|1)
//001,刘向前,18,0
//002,冯 剑,28,1
//003,李志杰,38,0
//004,郭 鹏,48,2
//要求，输出用户信息，gender必须为男或者女，不能为0,1
//使用广播变量把Map(“0” -> “女”, “1” ->“男”)设置为广播变量，最终输出格式为
//001,刘向前,18,女
//003,李志杰,38,女
//002,冯 剑,28,男
//004,郭 鹏,48,男

 @Test
  def e22(): Unit ={
    val rdd = sc.textFile("src/main/scala/spark练习题/练习题01/data/students")
    val broadcast = sc.broadcast(Map("0"->"女","1"->"男"))
    rdd.foreach{
      x =>
        var datas = x.split(",");
        println( datas(0)+","+datas(1)+","+datas(2)+","+ broadcast.value(datas(3)) )
    }
  }

//23.mysql创建一个数据库spark，在此数据库中创建一张表
//CREATE TABLE user (
// id int(11) NOT NULL AUTO_INCREMENT,
// username varchar(32) NOT NULL COMMENT ‘用户名称’,
// birthday date DEFAULT NULL COMMENT ‘生日’,
// sex char(1) DEFAULT NULL COMMENT ‘性别’,
// address varchar(256) DEFAULT NULL COMMENT ‘地址’,
// PRIMARY KEY (id)
//)
ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
//数据依次是：姓名 生日 性别 省份
//请使用spark将以上数据写入mysql中，并读取出来

 @Test
  def e23(): Unit ={
    val rdd = sc.textFile("src/main/scala/spark练习题/练习题01/data/user")
    // 配置数据库相关信息
    val Driver = "com.mysql.jdbc.Driver"
    val url = "jdbc:mysql://localhost:3306/spark"
    val username = "root"
    val password = "123456"
    //插入数据
    rdd.foreachPartition{
      data =>
        // 创数据库连接
        Class.forName(Driver)
        val connection = java.sql.DriverManager.getConnection(url,username,password)
        val sql = "insert into user values (Null,?,?,?,?)"
        data.foreach{
          tuples => {
            val datas = tuples.split(" ")
            val statement = connection.prepareStatement(sql)
            statement.setString(1,datas(0))
            statement.setString(2,datas(1))
            statement.setString(3,datas(2))
            statement.setString(4,datas(3))
            statement.executeUpdate()
            statement.close()
          }
        }
        connection.close()
    }
  }
  // 读取数据库
  @Test
  def e24(): Unit ={
    // 配置数据库相关信息
    val Driver = "com.mysql.jdbc.Driver"
    val url = "jdbc:mysql://localhost:3306/spark"
    val username = "root"
    val password = "123456"
    val sql = "select * from user where id between ? and ?"
    val jdbcRDD = new JdbcRDD(
        sc,
        () => {
          Class.forName(Driver)
          java.sql.DriverManager.getConnection(url,username,password)},
        sql,0,44,3,
        result => {
          println(s"id=${result.getInt(1)},username=${result.getString(2)}" +
            s",birthday=${result.getDate(3)},sex${result.getString(4)}" +
            s",address${result.getString(5)}")
        }
    )
    jdbcRDD.collect()
  }
}
骑着蜗牛ひ追导弹'
关注
专栏目录
Spark课堂课后作业/期末题库
qq_51610110的博客
07-28 344
"Spark课堂"课后作业及期末题库，为你提供全面的学习资源和练习机会，是确保你能够轻松应对期末考试、顺利过关的得力助手。通过精心设计的练习题和复习材料，我们致力于帮助你巩固课堂知识，提高解题技巧，从而在期末考试中取得优异成绩。不仅如此，我们的题库涵盖了各类题型和难度级别，让你在练习中不断挑战自我，提升学习效率，最终以满满的信心和扎实的准备迎接考试的检验。
Spark基础练习题(RDD)
写的不好之处,请指教
04-08 1万+
题目如下???? 1、创建一个1-10数组的RDD，将所有元素*2形成新的RDD 2、创建一个10-20数组的RDD，使用mapPartitions将所有元素*2形成新的RDD 3、创建一个元素为 1-5 的RDD，运用 flatMap创建一个新的 RDD，新的 RDD 为原 RDD 每个元素的 平方和三次方 来组成 1,1,4,8,9,27… 4、创建一个 4 个分区的 RDD数据为Array(10,...
spark考试练习题含答案.rar
06-22
spark考试练习题含答案.rar
spark练习题
afei2530的博客
09-07 491
site1,user1,2016-11-20 02:12:22 site1,user2,2016-11-28 04:12:22 site1,user3,2016-11-20 11:12:22 site1,user3,2016-11-23 11:12:22 site2,user4,2016-11-20 15:12:22 site3,user5,2016-11-29 08:12...
Spark题目练习
lhmqy的博客
08-17 316
建表： private val schema = StructType(Array( StructField("student_id", IntType, true), StructField("student_name", StringType, true), StructField("birth", StringType, true), StructField("sex", StringType, true) )) val rdd = sc.makeRDD(Array
【Spark】Spark基础练习题（一）
Together
04-06 1万+
为大家带来一些Spark的算子练习题，帮助大家巩固算子的用法！ 题目如下???? 1、读取文件的数据test.txt 2、一共有多少个小于20岁的人参加考试？ 3、一共有多少个等于20岁的人参加考试？ 4、一共有多少个大于20岁的人参加考试？ 5、一共有多个男生参加考试？ 6、一共有多少个女生参加考试？ 7、12班有多少人参加考试？ 8、13班有多少人参加考试？ 9、语文科目的平均成绩是多少？ 10、数...
Spark 练习测试题(答案仅供参考)
热门推荐
weixin_43631997的博客
07-05 1万+
选择题 1. spark 的四大组件下面哪个不是 (D) A.Spark Streaming B MLlib C Graph X D Spark R 2. Hadoop框架的缺陷有 (ABC) A.表达能力有限，MR编程框架的限制 B.过多的磁盘操作，缺乏对分布式内存的支持 C.无法高效低支持迭代式计算 D.海量的数据存储 3. 与hadoop相比，Spark主要有以下哪些优点（ABCD） A. 提供多种数据集操作类型而不仅限于MapReduce B. 数据集中式计算而...
spark考试（练习题）编程！
06-13
Spark考试（练习题）编程！ 在这篇文章中，我们将详细讨论 Spark 考试（练习题）编程！的相关知识点。 消息系统 消息系统是指能够在不同的应用程序之间传递消息的系统。常见的消息系统包括 Kafka、RabbitMQ 和 ...
Spark 练习题-数据
最新发布
06-26
本练习题集专注于Spark的数据操作，旨在帮助你深入理解和掌握Spark处理数据的各种方法。Spark以其高效的分布式计算能力、内存计算优化以及丰富的数据处理API闻名，广泛应用于大数据分析、机器学习和实时流处理等场景...
《Spark编程基础及项目实践》课后习题及答案3.pdf
04-04
《Spark编程基础及项目实践》课程的课后习题涵盖了Spark的核心概念和关键特性，旨在帮助学生深入理解和应用Spark框架。以下是对习题内容的详细解释： 1. Spark的运行架构： - Driver Program：是应用程序的主要...
【Spark】Spark基础练习题（三）
Together
04-13 7080
我又带来一堆Spark题了，这次是SparkSQL的！！！ 废话不多说，上题！！！ 题目如下???? 1、分别给出四张表的数据分别是： student_info.txt 字段是：学号,姓名,性别,所属班级编号,入学日期 department_info.txt 字段是：院系编号,院系名称 class_info.txt 字段是：班级编号,班级名称,入学日期,所属院系中文名 student_scores.tx...
spark考试练习题
qq_56437391的博客
06-15 6058
自行查看
云计算与大数据第16章 分布式内存计算平台Spark习题
m0_63394128的博客
08-29 2872
尾递归就是将递归语句写在函数的最底部，这样在每次调用尾递归时，就不需要保存当前状态值，可以直接把当前的状态值传递给下次一次调用，然后清空当前的状态。5、Spark Streaming是建立在Spark上的（ 实时计算 ）框架，提供了丰富的API、基于内存的高速执行引擎，用户可以结合流式、批处理进行交互式查询应用。A．执行器 B．主节点 C．从节点 D．上下文。6、Spark组件中，SparkContext是应用的（ C ），控制应用的生命周期。...
Spark练习题--基础20题
wgyzzzz的博客
08-06 1299
数据如下： 班级ID 姓名 年龄 性别 科目 成绩 12 张三 25 男 chinese 50 12 张三 25 男 math 60 12 张三 25 男 english 70 12 李四 20 男 chinese 50 12 李四 20 男 math 50 12 李四 20 男 english 50 12 王芳 19 女 chinese 70 12 王芳 19 女 math 70 12 王芳 19 女 english 70 13 张大三 25 男 chinese 60 13 张大三 25 男 math 6
Spark练习题
qq_57340195的博客
11-11 2055
1、将提供的文件利用ftp上传到相应的文件夹下 上传前 1、在根目录下创建 hdfs上的文件夹并查看(目标文件OPT) hdfs dfs -mkdir -p /user/root #在hdfs的根目录创建opt目录 2、上传本地文件到HDFS上去 方法1： 在本地Hadoop用户上传 文件到 hdfs上 切换到相应文件夹下 cd /opt hdfs dfs -put 文件名 /目录 在spark中操作文件 1、创建RDD(text.Fil...
spark考试（练习题）
qq_52754254的博客
06-13 7999
spark考试（练习题）
spark1.4的本地模式编程练习（1）
自天祐之，吉，无不利。
04-16 550
spark编程练习申明：以下代码仅作学习参考使用，勿使用在商业用途。 Wordcount UserMining TweetMining HashtagMining InvertedIndex Test Test代码package tutorial;import java.util.Arrays; import java.util.List;import org.apache.spark.SparkC
Spark练习题(1)
登峰造极胡子球手
04-08 2703
test.txt数据如下(都是按空格分隔的): 12 宋江 25 男 chinese 50 12 宋江 25 男 math 60 12 宋江 25 男 english 70 12 吴用 20 男 chinese 50 12 吴用 20 男 math 50 12 吴用 20 男 english 50 12 杨春 19 女 chinese 70 12 杨春 19 女 math 70 12 杨春 19 ...
Spark基础练习系列
qq_45014844的博客
08-18 1109
因最近学习了scala重温spark，本篇主要是spark sql的基础编程题 原题目地址： 题目地址 数据准备 本次所需的数据 student.txt 字段说明 学号 学生姓名 学生性别 学生出生年月 学生所在班级 108 丘东 男 1977-09-01 95033 105 匡明 男 1975-10-02 95031 107 王丽 女 1976-01-23 95033 101 李军 男 1976-02-20 95033 109 王芳 女 1975-02-10 95031 103 陆君 男 1
【spark】spark基础练习题（二）
06-28
【Spark】Spark基础练习题（二）是一组用于练习Spark基础知识的题目。这些题目涵盖了Spark的常用操作，包括RDD的创建、转换和行动操作，以及Spark SQL的使用等。通过完成这些练习题，可以加深对Spark的理解和掌握，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

骑着蜗牛ひ追导弹'

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值