前言

本人整理了网上一些考试卷和往年试卷及考点，综合出的一套卷子，希望能帮助你更好地复习。刚出卷子给身边同学做的时候，有反映说我出的卷子太细了，实则是当时他复习得不够到位，因为干背确实很容易迷茫在复习资料里，分不清孰轻孰重，就硬背脑子胡成一片。我们要做的就是从卷子里汲取经验，帮助大脑构建知识连接网络。
最后考试时发现，考试的卷子出的比我还细节，也不是说它难，就是很多考纲只言片语说了解的部分结果都被考成了大题。

一、选择题

1、下面哪个程序负责 HDFS 数据存储。
A. NameNode B.Jobtracker
C. Datanode D. secondaryNameNode
2、HDFS 中的 block 默认保存几个备份。
A. 3 份 B. 2 份
C. 1 份 D. 不确定
3、下面哪个进程负责 MapReduce 任务调度。
A. NameNode B. Jobtracker
C. TaskTracker D. secondaryNameNode
4、以下哪个不是Hadoop（YARN）的调度器策略。
A. 先进先出调度器 B. 容量调度器
C. 公平调度器 D. 优先级调度器
5、Client 端上传文件的时候下列哪项正确？
A. 数据经过 NameNode 传递给 DataNode
B. Client 端将文件切分为 Block，依次上传
C. Client 只上传数据到一台 DataNode，然后由 NameNode 负责 Block 复制工作
D. 以上都不正确
6、在实验集群的master节点使用jps命令查看进程时，终端出现以下哪项能说明Hadoop主节点启动成功？
A. Namenode,Datanode, NodeManager
B. Namenode,Datanode, secondaryNameNode
C. Namenode,Datanode, HMaster
D. Namenode,ResourceManager, secondaryNameNode
7、若不针对MapReduce编程模型中的key和value值进行特别设置，下列哪一项是MapReduce不适宜的运算。
A. Max B. Min
C. Count D. Average
8、MapReduce编程模型，键值对<key, value>的key必须实现哪个接口？
A. WritableComparable B. Comparable
C. Writable D. LongWritable
9、HBase是分布式列式存储系统，记录按什么集中存放。
A. 列族 B. 列
C. 行 D. 不确定
10、HBase的Region组成中，必须要有以下哪一项。
A. StoreFile B. MemStore
C. HFile D. MetaStore
11、设计分布式数据仓库hive的数据表时，为取样更高效，一般可以对表中的连续字段进行什么操作。
A. 分桶 B. 分区
C. 索引 D. 分表
12、客户端首次查询HBase数据库时，首先需要从哪个表开始查找。
A. .META. B. –ROOT-
C. 用户表 D. 信息表
13、HDFS有一个gzip文件大小75MB和一个LZO（with index）文件大小75MB，客户端设置Block大小为64MB。当运行mapreduce任务分别读取该文件时input split大小分别为：
A. 均为一个map读取64MB，另外一个map读取11MB
B. 均为75MB
C. 读取gizp时inputSplit为75MB，读取LZO时一个map读取64MB，另外一个map读取11MB
D. 读取LZO时inputSplit为75MB，读取gzip时一个map读取64MB，另外一个map读取11MB
14、关于SecondaryNameNode哪项是正确的?
A、它目的是帮助NameNode合并编辑日志,减少NameNode的负担和冷启动时的加载时间
B、它对内存没有要求
C、它是NameNode的热备
D、SecondaryNameNode应与NameNode部署到一个节点
15、把本地文件放到集群里,可以使用下面哪个hadoop shell的命令?
A、hadoop fs -put
B、hadoop fs –push /
C、hadoop fs –put /
D、hadoop -push /
16、如果想要修改集群的备份数量,可以修改下面哪个配置文件?
A、mapred-site.xml
B、core-site.xml
C、hdfs-site.xml
D、hadoop-env.sh
17、以下哪个不是HDFS的守护进程
A、SecondaryNameNode
B、NameNode
C、MrappMaster/YarnChild
D、DataNode
18、大数据至少为以下哪种存储量级?
A、EB B、PB C、TB D、ZB
19、关于HDFS集群中的DataNode的描述不正确的是?
A、一个DataNode上存储的所有数据块可以有相同的
B、存储客户端上传的数据的数据块
C、DataNode之间可以互相通信
D、响应客户端的所有读写数据请求,为客户端的存储和读取数据提供支撑
20、MapReduce的Shuffle过程以下中哪个操作是最后做的？
A、排序 B、合并 C、分区 D、溢写
21、下列关于HDFS的描述正确的是?
A、NameNode磁盘元数据不保存Block的位置信息
B、DataNode通过长连接与NameNode保持通信
C、HDFS集群支持数据的随机读写
D、如果NameNode宕机,SecondaryNameNode会接替它使集群继续工作
22、一个gzip文件大小300MB，客户端设置Block大小为128MB，请问其占用几个Block？
A、1 B、2 C、3 D、4
23、以下哪个不是Hadoop集群具有的优点?
A、高容错性
B、高成本性
C、高可靠性
D、高扩展性
24、Hadoop的三种安装模式不包括以下哪种?
A、二分布式模式
B、完全分布式模式
C、伪分布模式
D、单机模式
25、Hbase的存储核心为：
A、HRegion B、HStore C、StoreFile D、MemStore
【考试时竟然出的选择还算中规中矩】

二、判断题

Hadoop、HBase都支持数据的随机读写。
NameNode 负责管理元数据信息metadata，client 端每次读写请求，它都会从磁盘中读取或会写入 metadata 信息并反馈给 client 端。
MapReduce 的 input split 一定是一个 block。
MapReduce适于PB级别以上的海量数据在线处理。
MapRecue在shuffle阶段基于排序的方法会将key相同的数据聚集在一起。
MapReduce计算过程中，相同的key默认会被发送到同一个reduce task处理。
HBase对于空（NULL）的列，不需要占用存储空间。
HBase可以有列，可以没有列族（column family）。
HDFS既适合超大数据集存储,也适合小数据集的存储。
HDFS以流的形式访问文件系统中的数据。
HDFS有高容错性的特点,并且设计用来部署在低廉的(low-cost)硬件上。
在DataNode上每个block在本地文件系统只会产生一个文件，即实际的数据文件
HDFS的管道式写入，写过程不需要NameNode参与
在Zookeeper集群中可以同时存在多个NameNode
Hive的一个外部表被删除，不仅会删除其元数据，表中的数据也会被删除。

三、简答题

简述大数据技术的特点。（4V+）
启动Hadoop系统，当使用bin/start-all.sh命令启动时，请给出集群各进程启动顺序（顺序用->连接）。
简述HBase的主要技术特点。（本题较为开放，可以从Hbase概念特点、Hbase表特点等方面作答）
Hive数据仓库中，创建了以下外部表，请给出对应的HQL查询语句
CREATE EXTERNAL TABLE sogou_ext (
ts STRING, uid STRING, keyword STRING,
rank INT, order INT, url STRING,
year INT, month INT, day INT, hour INT
) COMMENT ‘This is the sogou search data of extend data’
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ‘\t’
STORED ASTEXTFILE
LOCATION’/sogou_ext/20160508’;
（1）给出独立uid总数的HQL语句
（2）对于keyword，给出其频度最高的20个词的HQL语句（降序排列输出keyword和其频数）
简要描述hadoop安装流程，只描述即可，无需列出具体步骤
简述Hadoop的副本放置策略
【实际考试简答题竟然出了写列举大数据计算模式及其产品，Hadoop生态系统、架构各组件代表产品名。这分明不在考纲里，又被老师摆了一道，凭着依稀记忆写了一些出来】

四、编程应用题

100万个字符串（多个文件，每行字符串以\t隔开），其中有些是相同的（重复），需要把重复的全部去掉，保留没有重复的字符串。请结合MapReduce编程模型给出设计思路或核心代码。
多文件排序，现有多个文件，每个文件只由不大于65535的数字组成且每行只有一个数字，请将这些数字降序排序，并且按照数字的大小分成三个文件，即数字落在0~65535范围三等分的区间上以此划分分区，最后结果文件有三个。
（此处题目较为基础，考试还有可能直接考wordcount，倒排索引，TopN，请自行复习，WritableCompareable、自定义排序代码较为冗长感觉考可能性不大）
HBase Shell指令：
1）创建学生表stud，包括列族：info,course,其中指定列族course的版本为2
2）插入行键为101的学生，在info中姓名name为zhangsan和年龄age为19，在course中插入hadoop课程成绩91，java成绩80（共四行put）
3）更改course成绩版本为3
4）删除stud 101整行数据
【HBase指令必考，结果真出了就和实验一模一样】
【实际考试真题】
一个文件夹下有多个文件，比如a.txt，b.txt，c.txt……每个文件里每一行都只有一个正整数数字，有若干行。结果输出在一个文件里，这个文件里的每一行包含每个文件里所有数字的平均值和对应文件名，以空格隔开。例：
a.txt 129.5
b.txt 100.0
c.txt 899.8
读取文件名使用：
FileSplit inputSplit = (FileSplit)context.getInputSplit();
String fileName = inputSplit.getPath().getName();

参考答案

选择题：
1-5 CABDB
6-10 DDAAB
11-15 ABCAC
16-20 CCBAB
21-25 ACBAB
判断题：
1-5 FFFFT 6-10 TTFFT 11-15 TFTTF
简答题：
1 数据量大（Volume）
类型繁多（Variety）
价值密度低（Value）
速度快时效高（Velocity）
可变性（Variability）、真实性(Veracity)
2 启动顺序：namenode –> datanode -> secondarynamenode -> resourcemanager -> nodemanager
3 列式存储，读写的严格一致性，提供海量数据，数据会自动分片，对于数据故障hbase是有自动的失效检测和恢复能力，提供了方便的与HDFS和MAPREDUCE集成的能力。

高可靠行、高性能、可伸缩性、实时读写

Hbase特点：
数据类型，只有字符串；
数据操作，简单操作，无复杂关联、连接操作；
存储模式，列存储；
数据维护，以插入替代修改删除操作；
可伸缩性，可轻松增加或减少硬件数量。

HBase中的表的特点：
Ø 大：一个表可以有上亿行，上百万列；
Ø 面向列:面向列(族)的存储和权限控制，列(族)独立检索；
Ø 稀疏:对于为空(null)的列，并不占用存储空间，因此表可以设计的非常稀疏。

4（1）select count(distinct(uid)) from sogou_ext;
(2) select keyword, count(*) as cnt from sogou_ext group by keyword order by cnt desc limit 20;

5 1）配置主机名、网络、编辑host文件，重启
2）配置免密登录，关闭防火墙，连接其他机器
3）JDK、Hadoop解压安装，配置hadoop核心文件
4) 复制hadoop文件夹到其他节点，配置环境变量
5）格式化HDFS： hadoop namenode -format
6）启动hadoop： start-all.sh
（流程大体相近即可）
6. 第一个副本：放置在上传文件的 DataNode；如果是集群外提交，则随机挑选一台磁盘不太满，CPU不太忙的节点
第二个副本：放置在于第一个副本不同的机架的节点上
第三个副本：与第一个副本相同机架的的其他节点
更多副本：随机节点

编程应用题：

解题思路：map阶段取出文件中数据作为key，value无关紧要，可以设为NullWritable，在Reduce阶段无论该key有多少value都不处里，直接输出key，即MapReduce自带去重的功能。

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;



import java.io.IOException;

public class WordDeduplicated {
    
    
    public static class DeMapper extends Mapper<LongWritable, Text,Text, NullWritable>{
    
    
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    
    
            String[] words = value.toString().split("\t");
            for (String word:words) {
    
    
                context.write(new Text(word),NullWritable.get());
            }
        }
    }
    public static class DeReducer extends Reducer<Text,NullWritable,Text,NullWritable>{
    
    
        @Override
        protected void reduce(Text key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
    
    
            context.write(key,NullWritable.get());
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
    
    
        Job job =  Job.getInstance(new Configuration());
        job.setJarByClass(WordDeduplicated.class);
        job.setMapperClass(DeMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(NullWritable.class);

        job.setReducerClass(DeReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);

        FileInputFormat.setInputPaths(job,new Path("file:///D:\\mapreduce\\wordcount_input"));
        FileOutputFormat.setOutputPath(job,new Path("file:///D:\\mapreduce\\deduplicated_output"));

        boolean result = job.waitForCompletion(true);
        System.exit(result?0:1);
    }
}

多文件排序，关键在排序，MapReduce默认key为升序，故在map阶段将数字都置为相反数，再在reduce阶段反转回来即可实现降序排列。

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Partitioner;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;


public class MultiFileNumberSort {
    
    
    public static class SortMapper extends Mapper<LongWritable, Text, IntWritable, NullWritable>{
    
    
        @Override
        protected void map(LongWritable key,Text value,Context context) throws IOException, InterruptedException {
    
    
            int number = Integer.parseInt(value.toString().trim());
            context.write(new IntWritable(-number),NullWritable.get());//默认升序，故将number置为相反数
        }
    }
    public static class SortReducer extends Reducer<IntWritable,NullWritable,IntWritable,IntWritable>{
    
    
        int lineNum = 1;
        @Override
        protected void reduce(IntWritable key, Iterable<NullWritable> values,Context context) throws IOException, InterruptedException {
    
    
            context.write(new IntWritable(lineNum),new IntWritable(-key.get()));
            lineNum+=1;
        }
    }
    public static class SortPartitioner extends Partitioner<IntWritable,NullWritable>{
    
    
        @Override
        public int getPartition(IntWritable key, NullWritable value, int numPartitions) {
    
    
            int maxNumber = 65535;
            int bound = maxNumber/numPartitions+1;
            int keyNumber = -key.get();//将负号反转回来
            for(int i=0;i<numPartitions;i++){
    
    
                if(keyNumber<bound*(i+1)&&keyNumber>=i*bound)return i;
            }
            return 0;
        }
    }
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
    
    
        Job job =  Job.getInstance(new Configuration());
        job.setJarByClass(MultiFileNumberSort.class);
        job.setMapperClass(SortMapper.class);
        job.setMapOutputKeyClass(IntWritable.class);
        job.setMapOutputValueClass(NullWritable.class);

        job.setPartitionerClass(SortPartitioner.class);
        job.setNumReduceTasks(3);
        job.setReducerClass(SortReducer.class);
        job.setOutputKeyClass(IntWritable.class);
        job.setOutputValueClass(IntWritable.class);

        FileInputFormat.setInputPaths(job,new Path("file:///D:\\mapreduce\\input"));
        FileOutputFormat.setOutputPath(job,new Path("file:///D:\\mapreduce\\MultiFileNumberSortDesc_output"));

        boolean result = job.waitForCompletion(true);
        System.exit(result?0:1);
    }
}

1）create ‘stud’,‘info’,{NAME=>‘course’,VERSIONS=>2}
2）put ‘stud’,‘101’,‘info:name’,‘zhangsan’ //字符串
put ‘stud’,‘101’,‘info:age’, ‘19’ //整数类型
put ‘stud’,‘101’,‘course:hadoop’,‘91’ //数值型字符串
put ‘stud’,‘101’,‘course:java’,‘80’ //数值型字符串

alter ‘stud’,{NAME=>’course’,VERSIONS=>3}
deleteall ‘stud’,‘101’

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class NumberAverage {
    
    
    public static class MyMapper extends Mapper<LongWritable, Text,Text, IntWritable>{
    
    
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    
    
            FileSplit inputSplit = (FileSplit)context.getInputSplit();
            String fileName = inputSplit.getPath().getName();
            String[] words = value.toString().trim().split(" ");
            for (String word : words) {
    
    
                context.write(new Text(fileName),new IntWritable(Integer.parseInt(word)));
            }
        }
    }
    public static class MyReducer extends Reducer<Text,IntWritable,Text, DoubleWritable>{
    
    
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
    
    
            int sum=0,count=0;
            for (IntWritable value : values) {
    
    
                sum+=value.get();
                count+=1;
            }
            double average = (double) sum/count;
            context.write(key,new DoubleWritable(average));
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
    
    
        Job job =  Job.getInstance(new Configuration());
        job.setJarByClass(NumberAverage.class);
        job.setMapperClass(MyMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);

        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(DoubleWritable.class);
		
		//本地模式下的调试操作，读者自行更改，Maven配置可以看我Hadoop相关文章
        FileInputFormat.setInputPaths(job,new Path("file:///D:\\mapreduce\\input"));
        FileOutputFormat.setOutputPath(job,new Path("file:///D:\\mapreduce\\NumberAverage_output"));

        boolean result = job.waitForCompletion(true);
        System.exit(result?0:1);
    }
}

总结

如有错误欢迎评论区指正。
恭祝你考个满意成绩！

参考网站

【1】 https://blog.csdn.net/weixin_44033192/article/details/106757969
【2】 https://blog.csdn.net/weifenglin1997/article/details/79078056
【3】 https://www.doc88.com/p-1098428825218.html
【4】 https://blog.csdn.net/weixin_45739322/article/details/111468519

华南农业大学2021春《Hadoop大数据处理技术》期末复习卷