【Spark】Spark基础练习题（一）

题目：

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,20,30,40,50,60)，使用glom将每个分区的数据放到一个数组

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

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

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

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

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

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

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

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

13、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和4 to 10，求并集

14、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和4 to 10，计算差集，两个都算

15、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和4 to 10，计算交集

16、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和4 to 10，计算 2 个 RDD 的笛卡尔积

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

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

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

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

21、统计出每一个省份广告被点击次数的 TOP3，数据在access.log文件中
数据结构：时间戳，省份，城市，用户，广告 字段使用空格分割。
样本如下：
1516609143867 6 7 64 16
1516609143869 9 4 75 18
1516609143869 1 7 87 12

22、读取本地文件words.txt,统计出每个单词的个数，保存数据到 hdfs 上

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

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

25、读取24题的SequenceFile 文件并输出

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

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

28、使用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,男

29、mysql创建一个数据库bigdata0407，在此数据库中创建一张表
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;
数据如下：
依次是：姓名 生日 性别 省份
安荷 1998/2/7 女 江苏省
白秋 2000/3/7 女 天津市
雪莲 1998/6/7 女 湖北省
宾白 1999/7/3 男 河北省
宾实 2000/8/7 男 河北省
斌斌 1998/3/7 男 江苏省
请使用spark将以上数据写入mysql中，并读取出来。

30、在hbase中创建一个表student，有一个 message列族
create ‘student’, ‘message’
scan ‘student’, {COLUMNS => ‘message’}
给出以下数据，请使用spark将数据写入到hbase中的student表中,并进行查询出来
数据如下：
依次是：姓名 班级 性别 省份，对应表中的字段依次是：name,class,sex,province
飞松 3 女 山东省
刚洁 1 男 深圳市
格格 4 女 四川省
谷菱 5 女 河北省
国立 2 男 四川省
海涛 3 男 广东省
含芙 3 女 四川省
华敏 4 女 上海市
乐和 2 男 上海市
乐家 3 男 黑龙江
乐康 4 男 湖北省
乐人 5 男 四川省
乐水 3 男 北京市
乐天 4 男 河北省
乐童 5 男 江苏省
乐贤 1 男 陕西省
乐音 2 男 广东省
李仁 3 男 湖北省
立涛 3 女 陕西省
凌青 4 女 湖北省
陆涛 4 男 山东省
媚媚 5 女 河南省
梦亿 4 男 江苏省
铭忠 5 男 四川省
慕梅 3 女 北京市
鹏吉 1 男 上海市
娉婷 4 女 河南省
淇峰 2 男 广东省
庆元 3 男 上海市
庆滋 4 男 北京市
丘东 5 男 江苏省
荣郑 1 男 黑龙江
蕊蕊 5 女 四川省
尚凯 2 男 北京市
诗涵 1 女 河南省
淑凤 2 女 天津市
淑娇 3 女 上海市
淑燕 4 女 河北省
淑怡 4 女 广东省
思璇 2 女 湖北省
苏华 3 女 山东省
苏梅 4 女 四川省
听荷 5 女 深圳市
文怡 1 女 天津市
文怡 2 女 河北省
香凝 3 女 山东省
翔云 4 女 河南省
小芸 5 女 深圳市

答案：

package scala

import org.apache.hadoop.hbase.{Cell, CellUtil, HBaseConfiguration}
import org.apache.hadoop.hbase.client.{Put, Result}
import org.apache.hadoop.hbase.io.ImmutableBytesWritable
import org.apache.hadoop.hbase.mapred.TableOutputFormat
import org.apache.hadoop.hbase.mapreduce.TableInputFormat
import org.apache.hadoop.hbase.util.Bytes
import org.apache.hadoop.mapred.JobConf
import org.apache.spark.rdd.{JdbcRDD, RDD}
import org.apache.spark.{SparkConf, SparkContext}

object demo02 {


  val sc: SparkContext = new SparkContext(new SparkConf().setMaster("local").setAppName("demo02"))
  // 1、创建一个1-10数组的RDD，将所有元素*2形成新的RDD
  val data1 = sc.makeRDD(1 to 10)
  val data1Result = data1.map(_ * 2)

  // 2、创建一个10-20数组的RDD，使用mapPartitions将所有元素*2形成新的RDD
  val data2 = sc.makeRDD(10 to 20)
  val data2Result = data2.mapPartitions(_.map(_ * 2))

  // 3、创建一个元素为 1-5 的RDD，运用 flatMap创建一个新的 RDD，新的 RDD 为原 RDD 每个元素的 平方和三次方 来组成 1,1,4,8,9,27..
  val data3 = sc.makeRDD(1 to 5)
  val data3Result = data3.flatMap(x => Array(math.pow(x, 2), math.pow(x, 3)))

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

  // 5、创建一个 RDD数据为Array(1, 3, 4, 20, 4, 5, 8)，按照元素的奇偶性进行分组
  val data5 = sc.makeRDD(Array(1, 3, 4, 20, 4, 5, 8))
  val data5Result = data5.groupBy(x => if (x % 2 == 0) "偶数" else "奇数")

  // 6、创建一个 RDD（由字符串组成）Array("xiaoli", "laoli", "laowang", "xiaocang", "xiaojing", "xiaokong")，过滤出一个新 RDD（包含“xiao”子串）
  val data6 = sc.makeRDD(Array("xiaoli", "laoli", "laowang", "xiaocang", "xiaojing", "xiaokong"))
  val data6Result = data6.filter(_.contains("xiao"))

  // 7、创建一个 RDD数据为1 to 10，请使用sample不放回抽样
  val data7 = sc.makeRDD(1 to 10)
  val data7Result = data7.sample(false, 0.5, 1)

  // 8、创建一个 RDD数据为1 to 10，请使用sample放回抽样
  val data8 = sc.makeRDD(1 to 10)
  val data8Result = data8.sample(true, 0.5, 1)

  // 9、创建一个 RDD数据为Array(10,10,2,5,3,5,3,6,9,1),对 RDD 中元素执行去重操作
  val data9 = sc.makeRDD(Array(10, 10, 2, 5, 3, 5, 3, 6, 9, 1))
  val data9Result = data9.distinct()

  // 10、创建一个分区数为5的 RDD，数据为0 to 100，之后使用coalesce再重新减少分区的数量至 2
  val data10 = sc.makeRDD(0 to 100, 5)
  val data10Result = data10.coalesce(2)

  // 11、创建一个分区数为5的 RDD，数据为0 to 100，之后使用repartition再重新减少分区的数量至 3
  val data11 = sc.makeRDD(0 to 100, 5)
  val data11Result = data11.repartition(3)

  // 12、创建一个 RDD数据为1,3,4,10,4,6,9,20,30,16,请给RDD进行分别进行升序和降序排列
  val data12 = sc.makeRDD(Array(1, 3, 4, 10, 4, 6, 9, 20, 30, 16))
  val data12Result1 = data12.sortBy(x => x)
  val data12Result2 = data12.sortBy(x => x, false)

  // 13、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和4 to 10，求并集
  val data13_1 = sc.makeRDD(1 to 6)
  val data13_2 = sc.makeRDD(4 to 10)
  val data13Result = data13_1.union(data13_2)

  // 14、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和4 to 10，计算差集，两个都算
  val data14_1 = sc.makeRDD(1 to 6)
  val data14_2 = sc.makeRDD(4 to 10)
  val data14Result_1 = data14_1.subtract(data14_2)
  val data14Result_2 = data14_2.subtract(data14_1)

  // 15、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和4 to 10，计算交集
  val data15_1 = sc.makeRDD(1 to 6)
  val data15_2 = sc.makeRDD(4 to 10)
  val data15Result_1 = data15_1.intersection(data15_2)

  // 16、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 6和4 to 10，计算 2 个 RDD 的笛卡尔积
  val data16_1 = sc.makeRDD(1 to 6)
  val data16_2 = sc.makeRDD(4 to 10)
  val data16Result = data16_1.cartesian(data16_2)

  // 17、创建两个RDD，分别为rdd1和rdd2数据分别为1 to 5和11 to 15，对两个RDD拉链操作
  val data17_1 = sc.makeRDD(1 to 5)
  val data17_2 = sc.makeRDD(11 to 15)
  val data17Result = data17_1.zip(data17_2)

  // 18、创建一个RDD数据为List(("female",1),("male",5),("female",5),("male",2))，请计算出female和male的总数分别为多少
  val data18 = sc.makeRDD(List(("female", 1), ("male", 5), ("female", 5), ("male", 2)))
  val data18Result = data18.reduceByKey(_ + _)

  // 19、创建一个有两个分区的 RDD数据为List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8))，取出每个分区相同key对应值的最大值，然后相加
  /**
    * (a,3),(a,2),(c,4)
    * (b,3),(c,6),(c,8)
    */
  val data19 = sc.makeRDD(List(("a", 3), ("a", 2), ("c", 4), ("b", 3), ("c", 6), ("c", 8)), 2)
  data19.glom().collect().foreach(x => println(x.mkString(",")))
  val data19Result = data19.aggregateByKey(0)(math.max(_, _), _ + _)

  // 20、创建一个有两个分区的 pairRDD数据为Array(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98))，根据 key 计算每种 key 的value的平均值
  val data20 = sc.makeRDD(Array(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98)))
  val data20Result = data20.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))

  // 21、统计出每一个省份广告被点击次数的 TOP3，数据在access.log文件中
  // 数据结构：时间戳，省份，城市，用户，广告 字段使用空格分割。
  val file1 = sc.textFile("input20200407/access.log")
  file1.map { x => var datas = x.split(" "); (datas(1), (datas(4), 1)) }.groupByKey().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)

  // 22、读取本地文件words.txt,统计出每个单词的个数，保存数据到 hdfs 上
  val file2 = sc.textFile("file:///F:\\study\\题库\\大数据题库\\words.txt")
  file2.flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _).saveAsTextFile("hdfs://node01:8020/20200407_wordsOutput")

  // 23、读取 people.json 数据的文件, 每行是一个 json 对象，进行解析输出
  import scala.util.parsing.json.JSON

  val file3 = sc.textFile("input20200407/people.json")
  val result: RDD[Option[Any]] = file3.map(JSON.parseFull)

  // 24、保存一个 SequenceFile 文件，使用spark创建一个RDD数据为Array(("a", 1),("b", 2),("c", 3))，保存为SequenceFile格式的文件到hdfs上
  val data24 = sc.makeRDD(Array(("a", 1), ("b", 2), ("c", 3)))
  data24.saveAsSequenceFile("hdfs://node01:8020/20200407_SequenceFile")

  // 25、读取24题的SequenceFile 文件并输出
  val data25: RDD[(String, Int)] = sc.sequenceFile[String, Int]("hdfs://node01:8020/20200407_SequenceFile/part-00000")

  // 26、读写 objectFile 文件，把 RDD 保存为objectFile，RDD数据为Array(("a", 1),("b", 2),("c", 3))，并进行读取出来
  val data26_1 = sc.makeRDD(Array(("a", 1), ("b", 2), ("c", 3)))
  data26_1.saveAsObjectFile("output20200407/20200407_objectFile")
  val data26_2 = sc.objectFile("output20200407/20200407_objectFile")

  // 27、使用内置累加器计算Accumulator.txt文件中空行的数量
  val data27 = sc.textFile("input20200407/Accumulator.txt")
  var count = sc.longAccumulator("count")
  data27.foreach { x => if (x == "") count.add(1) }
  println(count.value)

  /**
    * 28、使用Spark广播变量
    * 用户表：
    * id name age gender(0|1)
    * 001,刘向前,18,0
    * 002,冯  剑,28,1
    * 003,李志杰,38,0
    * 004,郭  鹏,48,1
    * 要求，输出用户信息，gender必须为男或者女，不能为0,1
    * 使用广播变量把Map("0" -> "女", "1" -> "男")设置为广播变量，最终输出格式为
    * 001,刘向前,18,女
    * 003,李志杰,38,女
    * 002,冯  剑,28,男
    * 004,郭  鹏,48,男
    */
  val data28 = sc.textFile("input20200407/user.txt")
  val sex = sc.broadcast(Map("0" -> "女", "1" -> "男"))
  data28.foreach { x => var datas = x.split(","); println(datas(0) + "," + datas(1) + "," + datas(2) + "," + sex.value(datas(3))) }

  /**
    * 29、mysql创建一个数据库bigdata0407，在此数据库中创建一张表
    * 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;
    * 数据如下：
    * 依次是：姓名 生日 性别 省份
    * 安荷 1998/2/7 女 江苏省
    * 白秋 2000/3/7 女 天津市
    * 雪莲 1998/6/7 女 湖北省
    * 宾白 1999/7/3 男 河北省
    * 宾实 2000/8/7 男 河北省
    * 斌斌 1998/3/7 男 江苏省
    * 请使用spark将以上数据写入mysql中，并读取出来。
    */
  val data29 = sc.textFile("input20200407/users.txt")
  val driver = "com.mysql.jdbc.Driver"
  val url = "jdbc:mysql://localhost:3306/bigdata0407"
  val username = "root"
  val password = "root"
  /**
    * MySQL插入数据
    */
  data29.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()
  }
  /**
    * MySQL查询数据
    */
  var 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)},address=${result.getString(5)}")
    }
  )
  jdbcRDD.collect()


  /**
    * 30、在hbase中创建一个表student，有一个 message列族
    * create 'student', 'message'
    * scan 'student', {COLUMNS => 'message'}
    * 给出以下数据，请使用spark将数据写入到hbase中的student表中,并进行查询出来
    * 数据如下：
    * 依次是：姓名 班级 性别 省份，对应表中的字段依次是：name,class,sex,province
    */
  //org.apache.hadoop.hbase.mapreduce.TableInputFormat
  val conf = HBaseConfiguration.create()
  conf.set("hbase.zookeeper.quorum", "node01:2181,node02:2181,node03:2181")
  conf.set(TableInputFormat.INPUT_TABLE, "student")
  /**
    * HBase插入数据
    */
  val dataRDD: RDD[String] = sc.textFile("input20200407/student.txt")
  val putRDD: RDD[(ImmutableBytesWritable, Put)] = dataRDD.map {
    //飞松	3	女	山东省
    case line => {
      val datas = line.split("\t")
      val rowkey = Bytes.toBytes(datas(0))
      val put = new Put(rowkey)
      put.addColumn(Bytes.toBytes("message"), Bytes.toBytes("name"), Bytes.toBytes(datas(0)))
      put.addColumn(Bytes.toBytes("message"), Bytes.toBytes("class"), Bytes.toBytes(datas(1)))
      put.addColumn(Bytes.toBytes("message"), Bytes.toBytes("sex"), Bytes.toBytes(datas(2)))
      put.addColumn(Bytes.toBytes("message"), Bytes.toBytes("province"), Bytes.toBytes(datas(3)))
      (new ImmutableBytesWritable(rowkey), put)
    }
  }
  val jobConf = new JobConf(conf)
  //org.apache.hadoop.hbase.mapred.TableOutputFormat
  jobConf.setOutputFormat(classOf[TableOutputFormat])
  jobConf.set(TableOutputFormat.OUTPUT_TABLE, "student")
  putRDD.saveAsHadoopDataset(jobConf)


  /**
    * HBase查询数据
    */
  val hbaseRDD: RDD[(ImmutableBytesWritable, Result)] = sc.newAPIHadoopRDD(conf, classOf[TableInputFormat],
    classOf[ImmutableBytesWritable],
    classOf[Result])
  hbaseRDD.foreach {
    case (rowKey, result) => {
      val cells: Array[Cell] = result.rawCells()
      for (cell <- cells) {
        println(Bytes.toString(CellUtil.cloneRow(cell)) + "\t" +
          Bytes.toString(CellUtil.cloneFamily(cell)) + "\t" +
          Bytes.toString(CellUtil.cloneQualifier(cell)) + "\t" +
          Bytes.toString(CellUtil.cloneValue(cell))
        )
      }
    }
  }
}