凡人多烦事01

这个屌丝很懒，什么也没留下！

热门标签

头歌大数据MapReduce基础编程_大数据技术原理头歌

作者：凡人多烦事01 | 2024-05-07 01:16:12

踩

大数据技术原理头歌

文章目录

第1关：合并去重

任务描述

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

编程要求

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

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

测试说明

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

20150101     x
20150102     y
20150103     x
20150104     y
20150105     z
20150106     x
1
2
3
4
5
6

输入文件B的样例如下：

20150101      y
20150102      y
20150103      x
20150104      z
20150105      y
1
2
3
4
5

根据输入文件A和B合并得到的输出文件C的样例如下：

20150101      x
20150101      y
20150102      y
20150103      x
20150104      y
20150104      z
20150105      y
20150105      z
20150106      x
1
2
3
4
5
6
7
8
9

示例代码


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.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 Merge {
    /**  
     * @param args  
     * 对A,B两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C  
     */  
    //重载map函数，直接将输入中的value复制到输出数据的key上  
    /********** Begin **********/  
    public static class Map extends Mapper<Object, Text, Text, Text>{  
        private static Text text = new Text();  
        public void map(Object key, Text value, Context context) throws IOException,InterruptedException{  
            text = value;  
            context.write(text, new Text(""));  
        }  
    }  
    /********** End **********/  
    //重载reduce函数，直接将输入中的key复制到输出数据的key上  
    /********** Begin **********/  
    public static class Reduce extends Reducer<Text, Text, Text, Text>{  
        public void reduce(Text key, Iterable<Text> values, Context context ) throws IOException,InterruptedException{  
            context.write(key, new Text(""));  
        }  
    }  
    /********** 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 duplicate removal");  
        job.setJarByClass(Merge.class);  
        job.setMapperClass(Map.class);  
        job.setCombinerClass(Reduce.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);  
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

第1关：第2关：整合排序

任务描述

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

编程要求

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

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

测试说明

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

输入文件2的样例如下：

输入文件3的样例如下：

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

示例代码

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 text = value.toString();  
            data.set(Integer.parseInt(text));  
            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 val : 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/num_Partition+1;  
            int keynumber = key.get();  
            for (int i = 0; i<num_Partition; i++){  
                if(keynumber<bound * (i+1) && keynumber>=bound * i){  
                    return i;  
                }  
            }  
            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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

第3关：信息挖掘

任务描述

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

编程要求

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

孙子在前，祖父在后；
孙子相同，祖父的名字按照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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出文件内容如下：

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
1
2
3
4
5
6
7
8
9
10
11
12
13

示例代码

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 child_name = new String();  
            String parent_name = new String();  
            String relation_type = new String();  
            String line = value.toString();  
            int i = 0;  
            while(line.charAt(i) != ' '){  
                i++;  
            }  
            String[] values = {line.substring(0,i),line.substring(i+1)};  
            if(values[0].compareTo("child") != 0){  
                child_name = values[0];  
                parent_name = values[1];  
                relation_type = "1";//左右表区分标志  
                context.write(new Text(values[1]), new Text(relation_type+"+"+child_name+"+"+parent_name));  
                //左表  
                relation_type = "2";  
                context.write(new Text(values[0]), new Text(relation_type+"+"+child_name+"+"+parent_name));  
                //右表  
            }  
    /********** 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++;  
            }  
            int grand_child_num = 0;  
            String grand_child[] = new String[10];  
            int grand_parent_num = 0;  
            String grand_parent[]= new String[10];  
            Iterator ite = values.iterator();  
            while(ite.hasNext()){  
                String record = ite.next().toString();  
                int len = record.length();  
                int i = 2;  
                if(len == 0) continue;  
                char relation_type = record.charAt(0);  
                String child_name = new String();  
                String parent_name = new String();  
                //获取value-list中value的child  
                while(record.charAt(i) != '+'){  
                    child_name = child_name + record.charAt(i);  
                    i++;  
                }  
                i=i+1;  
                //获取value-list中value的parent  
                while(i<len){  
                    parent_name = parent_name+record.charAt(i);  
                    i++;  
                }  
                //左表，取出child放入grand_child  
                if(relation_type == '1'){  
                    grand_child[grand_child_num] = child_name;  
                    grand_child_num++;  
                }  
                else{//右表，取出parent放入grand_parent  
                    grand_parent[grand_parent_num] = parent_name;  
                    grand_parent_num++;  
                }  
            }
            if(grand_parent_num != 0 && grand_child_num != 0 ){  
                for(int m = 0;m<grand_child_num;m++){  
                    for(int n=0;n<grand_parent_num;n++){  
                        context.write(new Text(grand_child[m]), new Text(grand_parent[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);  
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】

头歌大数据MapReduce基础编程_大数据技术原理头歌

文章目录

第1关：合并去重

任务描述

相关知识

编程要求

测试说明

示例代码

第1关：第2关：整合排序

任务描述

相关知识

编程要求

测试说明

示例代码

第3关：信息挖掘

任务描述

相关知识

编程要求

测试说明

示例代码