SparkConf的练习题

小补充：-》宽依赖的操作有哪些？
宽依赖：父RDD的一个分区会被子RDD的多个分区依赖
操作：groupByKey，reduceByKey，sortByKey，partitionBy， join
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 上
数据：

== words.txt==
hadoop hadoop spark spark spark java java
sqoop sqoop jdk jdk
hive hive hive hbase
hbase flume
flume oozie oozie
flink flink flink
hello hello hello scala scala
代码：

结果：

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

people.json
{“name”:“Michael1”}
{“name”:“Andy1”, “age”:30}
{“name”:“Justin1”, “age”:19}
{“name”:“Michael2”}
{“name”:“Andy2”, “age”:20}
{“name”:“Justin2”, “age”:22}
{“name”:“Michael3”}
{“name”:“Andy3”, “age”:25}
{“name”:“Justin3”, “age”:26}
代码：

结果：

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文件中空行的数量
数据：Accumulator.txt

hadoop hadoop
spark spark spark java java
sqoop
sqoop
jdk jdk
hive hive hive hbase
hbase flume
flume oozie oozie
flink flink flink
hello hello hello scala scala
hadoop hadoop
spark spark spark
java java
sqoop sqoop
jdk jdk
hive hive hive hbase
hbase flume
flume oozie oozie
flink flink flink
hello hello hello scala scala

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,男
代码：

object day28{
    def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setMaster("local[2]").setAppName(_01SparkPersistOps.getClass.getSimpleName())
        val sc = new SparkContext(conf)
        Logger.getLogger("org.apache.spark").setLevel(Level.OFF)
        Logger.getLogger("org.apache.hadoop").setLevel(Level.OFF)

        val userList = List(
            "001,刘向前,18,0",
            "002,冯  剑,28,1",
            "003,李志杰,38,0",
            "004,郭  鹏,48,2"
        )
        val genderMap = Map("0" -> "女", "1" -> "男")
        val genderMapBC:Broadcast[Map[String, String]] = sc.broadcast(genderMap)
        val userRDD = sc.parallelize(userList)
        val retRDD = userRDD.map(info => {
            val prefix = info.substring(0, info.lastIndexOf(","))   // "001,刘向前,18"
            val gender = info.substring(info.lastIndexOf(",") + 1)
            val genderMapValue = genderMapBC.value
            val newGender = genderMapValue.getOrElse(gender, "男")
            prefix + "," + newGender
        })
        retRDD.foreach(println)
        sc.stop()
    }
}

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中，并读取出来。
代码：

object day29 {
  def main(args: Array[String]): Unit = {
    //Spark支持通过Java JDBC访问关系型数据库。需要使用JdbcRDD
    //创建
    val conf1 = new SparkConf().setAppName("day29").setMaster("local[*]")
    val sc = new SparkContext(conf1)
    //插入数据
    val data: RDD[(String, String, String, String)] = sc.parallelize(List(("安荷", "1998/2/7", "女", "江苏省"),("白秋", "2000/3/7", "女", "天津市"),("雪莲", "1998/6/7", "女", "湖北省"),
      ("宾白", "1999/7/3", "男", "河北省"),("宾是", "2000/8/7", "男", "河北省"),("彬彬", "1998/3/7", "男", "江苏省")))
    //调用foreachPartition针对每一个分区进行操作
    data.foreachPartition(saveToMySQL)
    //读取数据
    def getConn():Connection={
      DriverManager.getConnection("jdbc:mysql://localhost:3306/test?characterEncoding=UTF-8", "root", "root")
    }

    val studentRDD: JdbcRDD[(Int, String, String,String,String)] = new JdbcRDD(sc,
      getConn,
      "select * from user where id >= ? and id <= ? ",
      4,
      6,
      2,
      rs => {
        val id: Int = rs.getInt("id")
        val username: String = rs.getString("username")
        val birthday: String = rs.getString("birthday")
        val sex: String = rs.getString("sex")
        val address: String = rs.getString("address")
        (id, username, birthday,sex,address)
      }
    )
    println(studentRDD.collect().toBuffer)
  }

  def saveToMySQL(partitionDate:Iterator[(String, String, String, String)]):Unit={
    //将数据存入到MySQL
    //获取数据连接
    val conn:Connection =  DriverManager.getConnection("jdbc:mysql://localhost:3306/test?characterEncoding=UTF-8", "root", "root")
    partitionDate.foreach(data=>{
      //将每一条数据存入到MySQL
      val sql = "INSERT INTO `user` (`id`, `username`, `birthday`,`sex`,`address`) VALUES (NULL, ?, ?,?,?);"
      val ps: PreparedStatement = conn.prepareStatement(sql)
      ps.setString(1,data._1)
      ps.setString(2,data._2)
      ps.setString(3,data._3)
      ps.setString(4,data._4)
      ps.execute()
    })
    conn.close()

  }
}

结果：

30、在hbase中创建一个表student，有一个 message列族
create ‘student’, ‘message’
scan ‘student’, {COLUMNS => ‘message’}
给出以下数据，请使用spark将数据写入到hbase中的student表中,并进行查询出来
数据如下：
依次是：姓名 班级 性别 省份，对应表中的字段依次是：name,class,sex,province
飞松 3 女 山东省

数据：students.txt
飞松 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 女 深圳市

测试代码：

object day30 {
  def main(args: Array[String]): Unit = {
    //创建SparkContext
    val config = new SparkConf().setAppName("habse").setMaster("local[*]")
    val sc = new SparkContext(config)
    //连接数据库
    val conf = HBaseConfiguration.create()
    conf.set("hbase.zookeeper.quorum", "hadoop01:2181,hadoop02:2181,hadoop03:2181")
    //获取表名
    val fruitTable = TableName.valueOf("student")
    //设置表结构
    val tableDescr = new HTableDescriptor(fruitTable)
    //建立表与列族之间的关系
    tableDescr.addFamily(new HColumnDescriptor("message".getBytes))
    //实例admin管理员
    val admin = new HBaseAdmin(conf)
    if (admin.tableExists(fruitTable)) {
      admin.disableTable(fruitTable)
      admin.deleteTable(fruitTable)
    }
    //创建一个新的表
    admin.createTable(tableDescr)

    val dataRDD: RDD[String] = sc.textFile("F:\\第四学期的大数据资料\\day02四月份资料\\第一周\\day01\\students.txt")
    val targetRDD: RDD[(ImmutableBytesWritable, Put)] = dataRDD.map {
      //切分
      case line => {
        val datas = line.split("\t")
        val rowkey = Bytes.toBytes(datas(0))
        val put = new Put(rowkey)
        //向put添加数据
        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)
    //输出数据
    jobConf.setOutputFormat(classOf[TableOutputFormat])
    jobConf.set(TableOutputFormat.OUTPUT_TABLE, "student")

    //写入数据
    targetRDD.saveAsHadoopDataset(jobConf)
    println("写入数据成功")

    //读取数据
    conf.set(TableInputFormat.INPUT_TABLE, "student")
    //设置配置
    val hbaseRDD: RDD[(ImmutableBytesWritable, Result)] = sc.newAPIHadoopRDD(conf, classOf[TableInputFormat],
      classOf[org.apache.hadoop.hbase.io.ImmutableBytesWritable],
      classOf[org.apache.hadoop.hbase.client.Result])
    //遍历数据
    hbaseRDD.foreach {
      case (_, result) =>
        val key = Bytes.toString(result.getRow)
        val name = Bytes.toString(result.getValue("message".getBytes, "name".getBytes))
        val cla = Bytes.toString(result.getValue("message".getBytes, "class".getBytes))
        val sex = Bytes.toString(result.getValue("message".getBytes, "sex".getBytes))
        val province = Bytes.toString(result.getValue("message".getBytes, "province".getBytes))
        println("Row key:" + key + " Name:" + name + " cla:" + cla+" sex:" + sex+" province:" + province)
    }
    sc.stop()
  }
}

结果：