（图文详细）云计算与大数据实训作业答案（之篇一MapReduce基础编程）

Myth丶恋晨 2022-05-23 06:48 1206阅读 0赞

*   *  （图文详细）云计算与大数据实训作业答案（之篇一MapReduce基础编程 ）
        
         *   *  第1关 合并去重
             *  第2关 整合排序
             *  第3关 信息挖掘

## （图文详细）云计算与大数据实训作业答案（之篇一MapReduce基础编程 ） ##

MapReduce是一种编程模型，用于大规模数据集（大于1TB）的并行运算。概念”Map（映射）”和”Reduce（归约）” 当前的软件实现是指定一个Map（映射）函数，用来把一组键值对映射成一组新的键值对，指定并发的Reduce（归约）函数，用来保证所有映射的键值对中的每一个共享相同的键组。MapReduce是Hadoop进行分布式数据计算的模式，即将文件分发Map到各节点进行计算，然后在将各节点计算结果汇总Reduce成最终结果。

如图所示：  
![这里写图片描述][70]  
本实训项目的主要内容是基于Hadoop分布式系统的MapReduce基础编程，从三个方面介绍MapReduce相关知识，并设置了三个关卡在线考察大家的Hadoop编程能力。

#### 第1关 合并去重 ####

**任务描述**  
本关任务：编程实现文件合并和去重操作。

**相关知识**  
为了实现文件的合并去重，我们首先要知道文件中都有些什么，将文件内容进行“拆解”，映射（Map）到不同节点；然后在通过归约（Reduce）去除重复部分。  
Map过程

**用法如下：**  
重载map函数，直接将输入中的value复制到输出数据的key上

public static class Map extends Mapper<Object, Text, Text, Text> { }

**Reduce过程**  
重载reduce函数，直接将输入中的key复制到输出数据的key上

public static class Reduce extends Reducer<Text, Text, Text, Text>{ }

**编程要求**  
对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。  
为了完成文件合并去重的任务，你编写的程序要能将含有重复内容的不同文件合并到一个没有重复的整合文件，规则如下：

第一列按学号排列；
    学号相同，按x,y,z排列。

**测试说明**  
程序会对你编写的代码进行测试：  
输入已经指定了测试文本数据：需要你的程序输出合并去重后的结果。  
下面是输入文件和输出文件的一个样例供参考。  
输入文件A的样例如下：  
20150101 x  
20150102 y  
20150103 x  
20150104 y  
20150105 z  
20150106 x

输入文件B的样例如下：  
20150101 y  
20150102 y  
20150103 x  
20150104 z  
20150105 y

根据输入文件A和B合并得到的输出文件C的样例如下：  
20150101 x  
20150101 y  
20150102 y  
20150103 x  
20150104 y  
20150104 z  
20150105 y  
20150105 z  
20150106 x

开始你的任务吧，祝你成功！

**代码如下：**

#### 第2关 整合排序 ####

**任务描述**  
本关任务：编写程序实现对输入文件的排序。

**相关知识**  
为了实现文件的整合排序，我们首先要知道文件中都有些什么，将文件内容进行“拆解”，映射（Map）到不同节点；然后在通过归约（Reduce）的过程中进行排序输出。

**Map过程**  
1、 输入多个文件，每个文件中的每行内容均为一个整数；  
2、map函数读取输入中的value，将其转化成IntWritable类型，最后作为输出key。

**用法如下：**

public static class Map extends Mapper<Object, Text, IntWritable, IntWritable>{ 
        private static IntWritable data = new IntWritable();
        }

**Reduce过程**  
1、reduce函数将map输入的key复制到输出的value上；  
2、根据输入的value-list中元素的个数决定key的输出次数,定义一个全局变量line\_num来代表key的位次。

**用法如下：**

public static class Reduce extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable>{ 
        private static IntWritable line_num = new IntWritable(1);
        }

返回Partiton ID

1、自定义Partition函数，此函数根据输入数据的最大值和MapReduce框架中Partition的数量获取将输入数据按照大小分块的边界；  
2、 根据输入数值和边界的关系返回对应的Partiton ID。

public static class Partition extends Partitioner<IntWritable, IntWritable>{ 
        public int getPartition(IntWritable key, IntWritable value, int num_Partition){
        int Maxnumber = 65223;//int型的最大数值
        }
    }

**编程要求**

为了完成合并文件并排序的功能，你编写的程序要能将整合排序后的结果输出，规则如下：

*  现在有多个输入文件，每个文件中的每行内容均为一个整数。要求读取所有文件中的整数，进行升序排序后，输出到一个新的文件中;
 *  输出的数据格式为每行两个整数，第一个数字为第二个整数的排序位次，第二个整数为原待排列的整数。

**测试说明**  
程序会对你编写的代码进行测试：  
下面是输入文件和输出文件的一个样例供参考。  
输入文件1的样例如下：

> 33  
> 37  
> 12  
> 40

输入文件2的样例如下：

> 4  
> 16  
> 39  
> 5

输入文件3的样例如下：

> 1  
> 45  
> 25

根据输入文件1、2和3得到的输出文件如下：

> 1 1  
> 2 4  
> 3 5  
> 4 12  
> 5 16  
> 6 25  
> 7 33  
> 8 37  
> 9 39  
> 10 40  
> 11 45

开始你的任务吧，祝你成功！

**代码如下：**

import java.io.IOException;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IntWritable;
    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 org.apache.hadoop.util.GenericOptionsParser;
    
    
    public class MergeSort { 
    
        /** * @param args * 输入多个文件，每个文件中的每行内容均为一个整数 * 输出到一个新的文件中，输出的数据格式为每行两个整数，第一个数字为第二个整数的排序位次，第二个整数为原待排列的整数 */
        //map函数读取输入中的value，将其转化成IntWritable类型，最后作为输出key
        public static class Map extends Mapper<Object, Text, IntWritable, IntWritable>{ 
    
            private static IntWritable data = new IntWritable();
            public void map(Object key, Text value, Context context) throws IOException,InterruptedException{
                /********** Begin **********/
            String line = value.toString();
            data.set(Integer.parseInt(line));
            context.write(data, new IntWritable(1));
                /********** End **********/
    
            }
        }
    
        //reduce函数将map输入的key复制到输出的value上，然后根据输入的value-list中元素的个数决定key的输出次数,定义一个全局变量line_num来代表key的位次
        public static class Reduce extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable>{ 
            private static IntWritable line_num = new IntWritable(1);
    
            public void reduce(IntWritable key, Iterable<IntWritable> values, Context context) throws IOException,InterruptedException{
                /********** Begin **********/
               for(IntWritable num : values) {
                 context.write(line_num, key);
                 line_num = new IntWritable(line_num.get() + 1);
        }
                /********** End **********/
      }
    }
    
        //自定义Partition函数，此函数根据输入数据的最大值和MapReduce框架中Partition的数量获取将输入数据按照大小分块的边界，然后根据输入数值和边界的关系返回对应的Partiton ID
        public static class Partition extends Partitioner<IntWritable, IntWritable>{ 
            public int getPartition(IntWritable key, IntWritable value, int num_Partition){
                /********** Begin **********/
                int Maxnumber = 65223;//int型的最大数值
                int bound = Maxnumber / numPrtitions + 1;
                int Keynumber = key.get();
                for(int i = 0; i < numPartitions; i++){
                  if(Keynumber < bound * i && Keynumber >= bound * (i - 1)) {
                    return i - 1;
          }
        }
                return -1 ;
                /********** End **********/
    
            }
        }
    
        public static void main(String[] args) throws Exception{
            // TODO Auto-generated method stub
            Configuration conf = new Configuration();
            conf.set("fs.default.name","hdfs://localhost:9000");
            String[] otherArgs = new String[]{
       "input","output"}; /* 直接设置输入参数 */
            if (otherArgs.length != 2) {
                System.err.println("Usage: wordcount <in> <out>");
                System.exit(2);
                }
            Job job = Job.getInstance(conf,"Merge and Sort");
            job.setJarByClass(MergeSort.class);
            job.setMapperClass(Map.class);
            job.setReducerClass(Reduce.class);
            job.setPartitionerClass(Partition.class);
            job.setOutputKeyClass(IntWritable.class);
            job.setOutputValueClass(IntWritable.class);
            FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
            FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
            System.exit(job.waitForCompletion(true) ? 0 : 1);
    
        }
    
    }

#### 第3关 信息挖掘 ####

**任务描述**  
本关任务：对给定的表格进行信息挖掘。

**相关知识**  
**Map过程**

1、 Map将输入文件按照空格分割成child和parent，然后正序输出一次作为右表，反序输出一次作为左表，需要注意的是在输出的value中必须加上左右表区别标志；  
2、在Map阶段，将父子关系与相反的子父关系，同时在各个value前补上前缀-与+标识此key-value中的value是正序还是逆序产生的，之后进入context

public static class Map extends Mapper<Object, Text, Text, Text>{ 
       public void map(Object key, Text value, Context context) throws IOException,InterruptedException{
                    String child_name = new String();
                    String parent_name = new String();
        }
      }

**Reduce过程**

public static class Reduce extends Reducer<Text, Text, Text, Text>{ 
        public void reduce(Text key, Iterable<Text> values,Context context) throws IOException,InterruptedException{
                    if(time == 0){   //输出表头
                        context.write(new Text("grand_child"), new Text("grand_parent"));
                        time++;
                    }
        }
     }

**编程要求**  
为了完成信息挖掘的任务，你编写的程序要能挖掘父子辈关系，给出祖孙辈关系的表格。规则如下：

孙子在前，祖父在后
    孙子相同，祖父的名字按照A-Z排列

**测试说明**  
程序会对你编写的代码进行测试：  
下面给出一个child-parent的表格，要求挖掘其中的父子辈关系，给出祖孙辈关系的表格。

输入文件内容如下：

> child parent  
> Steven Lucy  
> Steven Jack  
> Jone Lucy  
> Jone Jack  
> Lucy Mary  
> Lucy Frank  
> Jack Alice  
> Jack Jesse  
> David Alice  
> David Jesse  
> Philip David  
> Philip Alma  
> Mark David  
> Mark Alma

输出文件内容如下：

> grandchild grandparent  
> Steven Alice  
> Steven Jesse  
> Jone Alice  
> Jone Jesse  
> Steven Mary  
> Steven Frank  
> Jone Mary  
> Jone Frank  
> Philip Alice  
> Philip Jesse  
> Mark Alice  
> Mark Jesse

开始你的任务吧，祝你成功！  
**代码如下：**

import java.io.IOException;
    import java.util.*;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IntWritable;
    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 org.apache.hadoop.util.GenericOptionsParser;
    
    public class simple_data_mining { 
        public static int time = 0;
    
        /** * @param args * 输入一个child-parent的表格 * 输出一个体现grandchild-grandparent关系的表格 */
        //Map将输入文件按照空格分割成child和parent，然后正序输出一次作为右表，反序输出一次作为左表，需要注意的是在输出的value中必须加上左右表区别标志
        public static class Map extends Mapper<Object, Text, Text, Text>{ 
            public void map(Object key, Text value, Context context) throws IOException,InterruptedException{
                /********** Begin **********/
                 String line = value.toString();
                 String[] childAndParent = line.split(" ");
                 List<String> list = new ArrayList<>(2);
                  for (String childOrParent : childAndParent) {
                     if (!"".equals(childOrParent)) {
                         list.add(childOrParent);
                      }
                  } 
                  if (!"child".equals(list.get(0))) {
                      String childName = list.get(0);
                      String parentName = list.get(1);
                      String relationType = "1";
                      context.write(new Text(parentName), new Text(relationType + "+"
                            + childName + "+" + parentName));
                      relationType = "2";
                      context.write(new Text(childName), new Text(relationType + "+"
                            + childName + "+" + parentName));
                  }
    
                /********** End **********/
            }
        }
    
        public static class Reduce extends Reducer<Text, Text, Text, Text>{ 
            public void reduce(Text key, Iterable<Text> values,Context context) throws IOException,InterruptedException{
                    /********** Begin **********/
    
                    //输出表头
                   if (time == 0) {
                    context.write(new Text("grand_child"), new Text("grand_parent"));
                    time++;
                }
    
                //获取value-list中value的child
                List<String> grandChild = new ArrayList<>()
                //获取value-list中value的parent
                List<String> grandParent = new ArrayList<>();
                    //左表，取出child放入grand_child
                for (Text text : values) {
                    String s = text.toString();
                    String[] relation = s.split("\\+");
                    String relationType = relation[0];
                    String childName = relation[1];
                    String parentName = relation[2];
                    if ("1".equals(relationType)) {
                        grandChild.add(childName);
                    } else {
                        grandParent.add(parentName);
                    }
                }
    
                    //右表，取出parent放入grand_parent
                   int grandParentNum = grandParent.size();
                   int grandChildNum = grandChild.size();
                   if (grandParentNum != 0 && grandChildNum != 0) {
                    for (int m = 0; m < grandChildNum; m++) {
                        for (int n = 0; n < grandParentNum; n++) {
                            //输出结果
                        context.write(new Text(grandChild.get(m)), new Text(
                                    grandParent.get(n)));
                        }
                    }
                }
    
                    /********** End **********/
    
            }
        }
        public static void main(String[] args) throws Exception{
            // TODO Auto-generated method stub
            Configuration conf = new Configuration();
            conf.set("fs.default.name","hdfs://localhost:9000");
            String[] otherArgs = new String[]{
       "input","output"}; /* 直接设置输入参数 */
            if (otherArgs.length != 2) {
                System.err.println("Usage: wordcount <in> <out>");
                System.exit(2);
                }
            Job job = Job.getInstance(conf,"Single table join");
            job.setJarByClass(simple_data_mining.class);
            job.setMapperClass(Map.class);
            job.setReducerClass(Reduce.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(Text.class);
            FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
            FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
            System.exit(job.waitForCompletion(true) ? 0 : 1);
    
        }
    
    }

[70]: /images/20220523/1eeddaaee18048eea190ef6b62a6b2f3.png