MapReduce的分组

最新推荐文章于 2020-04-22 23:54:11 发布
最新推荐文章于 2020-04-22 23:54:11 发布
阅读量1.9k 收藏 16
点赞数 6
分类专栏： mapreduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42636010/article/details/90071896
版权

不想看废话就直接到最后找总结

一：
MapReduce的分组其实就是把相同的key合并到一起
比如map后输出
hadoop 1
hadoop 1
hadoop 1
分组后变成 hadoop <1，1，1> 所以Reducer类的reduce的方法的第二个参数是map传出的value的迭代器，这个迭代器就是 <1，1，1>
在这里插入图片描述
那么问题来，他是怎么比较key是否相同的，一开始我以为是key的equal方法，但是偶然之下注释了equal方法（在我定义的Writable中的equal方法），但是还是分组成功了。这个时候想到了compareTo方法，没错就是它，当这个方法返回0的时候就认为这两个元素相同从而分到一组中。
而且分组的时候key就是原来的key，只是把value加到原来的value后边。为什么这么说呢，测试的时候我定义了一个Writable类，

public static class GroupWritable implements WritableComparable<GroupWritable>{
		private String word;
		private int count ;
		public void write(DataOutput out) throws IOException {
			out.writeUTF(this.word);
			out.writeInt(this.count);
		}
		public void readFields(DataInput in) throws IOException {
			// TODO Auto-generated method stub
			this.word = in.readUTF();
			this.count = in.readInt();
		}
		public int compareTo(GroupWritable o) {
			// TODO Auto-generated method stub
			//return o.count - this.count;
			return this.count - o.count;
		}
//		@Override
//		public boolean equals(Object obj) {	
//			GroupWritable gw = (GroupWritable)obj;
//			return (gw.word == this.word) && (this.count == gw.count);
//		}
		public GroupWritable(String word, int count) {
			super();
			this.word = word;
			this.count = count;
		}
		public GroupWritable() {
			super();
			// TODO Auto-generated constructor stub
		}
		public String getWord() {
			return word;
		}
		public void setWord(String word) {
			this.word = word;
		}
		public int getCount() {
			return count;
		}
		public void setCount(int count) {
			this.count = count;
		}
		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return "word:"+word+" count:"+count;
		}
	}

这个类有两个属性String 和 int ，我在写自己的Writable类的compareTo方法的时候只要两个int 属性相同就返回0.这个时候奇妙的事发生了。
下边是map输出key和value
GroupWritable 后面是value，
(hello，11）1
(world，11）1
(haha，11） 1
分组后的结果成了 (hello，11) <1,1,1>
因为在reduce中我把迭代器当中的元素进行了累加，并在最终结果中得到了（hello 11） 3 的结果
如果没有分到一起，那么最终结果会是
（hello，11）1
(world，11）1
(haha，11） 1

public static class GroupReducer extends Reducer<GroupWritable, IntWritable, GroupWritable, IntWritable>{
		
		@Override
		protected void reduce(GroupWritable key, Iterable<IntWritable> value,Context context)
				throws IOException, InterruptedException {
			int sum = 0 ;
			
			for(IntWritable i : value) {
				sum += i.get();
			}
			context.write(key, new IntWritable(sum));
			

		}
		
		
	}

为什么会分到一起，因为我定义的compareTo方法认为这三个元素相同，然后reducer分组把三个分到一起了，并且以第一个key为key，然后把value追加到迭代器中。

完整代码： 最终得到结果是（hello，11） 3
可以自己输入
(hello，11）1
(world，11）1
(haha，11） 1

package GroupTest;

import java.io.DataInput;
import java.io.DataOutput;
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.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
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 MoreTopNTest.CoursePartition;
import MoreTopNTest.FindPersonalAvgAndPatition;
import MoreTopNTest.StudentWritable;
import MoreTopNTest.FindPersonalAvgAndPatition.MyMapper;
import MoreTopNTest.FindPersonalAvgAndPatition.MyReducer;

public class GroupTestDemo {
	public static class GroupWritable implements WritableComparable<GroupWritable>{
		private String word;
		private int count ;
		public void write(DataOutput out) throws IOException {
			out.writeUTF(this.word);
			out.writeInt(this.count);
			
		}
		public void readFields(DataInput in) throws IOException {
			// TODO Auto-generated method stub
			this.word = in.readUTF();
			this.count = in.readInt();
		}
		public int compareTo(GroupWritable o) {
			// TODO Auto-generated method stub
			return o.count - this.count;
		}
		//把equal注释掉后发现新世界
//		@Override
//		public boolean equals(Object obj) {	
//			GroupWritable gw = (GroupWritable)obj;
//			return (gw.word == this.word) && (this.count == gw.count);
//		}
		public GroupWritable(String word, int count) {
			super();
			this.word = word;
			this.count = count;
		}
		public GroupWritable() {
			super();
			// TODO Auto-generated constructor stub
		}
		public String getWord() {
			return word;
		}
		public void setWord(String word) {
			this.word = word;
		}
		public int getCount() {
			return count;
		}
		public void setCount(int count) {
			this.count = count;
		}
		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return "word:"+word+" count:"+count;
		}
	}
	public static class GroupMapper extends Mapper<LongWritable, Text, GroupWritable, IntWritable>{
		@Override
		protected void map(LongWritable key, Text value,Context context)
				throws IOException, InterruptedException {
			
			String [] splited = value.toString().split(" ");
			GroupWritable gw = new GroupWritable(splited[0],Integer.parseInt(splited[1]));
			context.write(gw,new IntWritable(1));
			
		}
	
	}
	public static class GroupReducer extends Reducer<GroupWritable, IntWritable, GroupWritable, IntWritable>{
	
		@Override
		protected void reduce(GroupWritable key, Iterable<IntWritable> value,Context context)
				throws IOException, InterruptedException {
			int sum = 0 ;
			
			for(IntWritable i : value) {
				sum += i.get();
			}
			context.write(key, new IntWritable(sum));
		

		}
		
		
	}
	public static void main(String [] args) throws IOException, ClassNotFoundException, InterruptedException {
		Job job = Job.getInstance(new Configuration ());
		job.setJarByClass(GroupTestDemo.class);
		
		job.setMapperClass(GroupMapper.class);
		job.setMapOutputKeyClass(GroupWritable.class);
		job.setMapOutputValueClass(IntWritable.class);
		
	
		
		job.setReducerClass(GroupReducer.class);
		job.setOutputKeyClass(GroupWritable.class);
		job.setOutputValueClass(IntWritable.class);
		
		
		FileInputFormat.setInputPaths(job, new Path(args[0]));
		FileOutputFormat.setOutputPath(job, new Path(args[1]));
		
		job.waitForCompletion(true);
		
		
		
	}
	

}

二：ok，那么还有个问题，就是job.setGroupingComparatorClass是干什么用的， 看别人博客都说她是分组用的，于是我在想，这个优先级和compareTo的优先级谁高，
试验一下：
方法：
定义一个job.setGroupingComparatorClass，在这个类中的compare方法都返回-1，同时实现了GroupWritable的compareTo方法，这个方法还是认为两者的属性int属性相同就返回，
然后再主类中job.setGroupingComparatorClass一下。
输入数据还是
(hello，11）1
(world，11）1
(haha，11） 1
预期结果：
如果comparTo方法比GroupingComparatorClass 更高优先级，那么就会把上述三个分到一组中，相反则会分成三组

package GroupTest;

import java.io.DataInput;
import java.io.DataOutput;
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.LongWritable;
import org.apache.hadoop.io.RawComparator;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;
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 MoreTopNTest.CoursePartition;
import MoreTopNTest.FindPersonalAvgAndPatition;
import MoreTopNTest.StudentWritable;
import MoreTopNTest.FindPersonalAvgAndPatition.MyMapper;
import MoreTopNTest.FindPersonalAvgAndPatition.MyReducer;

public class GroupTestDemo {
	public static class GroupWritable implements WritableComparable<GroupWritable>{
		private String word;
		private int count ;
		public void write(DataOutput out) throws IOException {
			out.writeUTF(this.word);
			out.writeInt(this.count);
		}
		public void readFields(DataInput in) throws IOException {
			// TODO Auto-generated method stub
			this.word = in.readUTF();
			this.count = in.readInt();
		}
		public int compareTo(GroupWritable o) {
			// TODO Auto-generated method stub
			//return o.count - this.count;
			return this.count - o.count;
		}
//		@Override
//		public boolean equals(Object obj) {	
//			GroupWritable gw = (GroupWritable)obj;
//			return (gw.word == this.word) && (this.count == gw.count);
//		}
		public GroupWritable(String word, int count) {
			super();
			this.word = word;
			this.count = count;
		}
		public GroupWritable() {
			super();
			// TODO Auto-generated constructor stub
		}
		public String getWord() {
			return word;
		}
		public void setWord(String word) {
			this.word = word;
		}
		public int getCount() {
			return count;
		}
		public void setCount(int count) {
			this.count = count;
		}
		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return "word:"+word+" count:"+count;
		}
	}
	public static class GroupMapper extends Mapper<LongWritable, Text, GroupWritable, IntWritable>{
		@Override
		protected void map(LongWritable key, Text value,Context context)
				throws IOException, InterruptedException {
			
			String [] splited = value.toString().split(" ");
			GroupWritable gw = new GroupWritable(splited[0],Integer.parseInt(splited[1]));
			context.write(gw,new IntWritable(1));
			
			
		}
	
	}
	public static class GroupReducer extends Reducer<GroupWritable, IntWritable, GroupWritable, IntWritable>{
		
		@Override
		protected void reduce(GroupWritable key, Iterable<IntWritable> value,Context context)
				throws IOException, InterruptedException {
			int sum = 0 ;
			
			for(IntWritable i : value) {
				sum += i.get();
			}
			context.write(key, new IntWritable(sum));
			

		}
		
		
	}
	public static void main(String [] args) throws IOException, ClassNotFoundException, InterruptedException {
		Job job = Job.getInstance(new Configuration ());
		job.setJarByClass(GroupTestDemo.class);
		
		job.setMapperClass(GroupMapper.class);
		job.setMapOutputKeyClass(GroupWritable.class);
		job.setMapOutputValueClass(IntWritable.class);
		
		job.setGroupingComparatorClass(MyGroupingComparator.class);
		
		job.setReducerClass(GroupReducer.class);
		job.setOutputKeyClass(GroupWritable.class);
		job.setOutputValueClass(IntWritable.class);
		
		
		FileInputFormat.setInputPaths(job, new Path(args[0]));
		FileOutputFormat.setOutputPath(job, new Path(args[1]));
		
		job.waitForCompletion(true);
		
		
		
	}
	public static class MyGroupingComparator implements RawComparator<GroupWritable>{
		
		public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
			// TODO Auto-generated method stub
			return -1;
		}
		public int compare(GroupWritable o1, GroupWritable o2) {
			// TODO Auto-generated method stub
			//如果是的话就返回1否则返回0
			return -1;
		}
	}

}

最终结果是分成三组，也就是说，这个GroupingComparatorClass会覆盖compareTo方法。

总结:
分组会把相同的key的value分到一个组中（以迭代器的方式，就相当于<value1，value2，value3>），那么怎么比较key是否相同呢，有两种方法，第一种是key的compareTo方法，返回0时认为两个key相同，第二种是设置一个自定义的GroupingComparatorClass(怎么自定义请百度)，然后重写类里compare方法，这个方法会覆盖掉key中的compareTo方法，总而作为比较key是否相同的方法。

其实分析也可以得到，GroupingComparatorClass的比较方法优先级高于自定义数据类型中的compareTo方法，因为每个自定义数据类型都要实现compareTo方法，如果GroupingComparatorClass的比较方法的优先级不高，那么这个类根本就没什么用。

小丫小屁孩
关注
  • 6
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MapReduce排序，分区，分组总结
qq_43206800的博客
07-22 1803
1. 分区 1.1 自定义分区器 1) 自定义分区器继承 Partitioner类，并重写getPartition方法 2) 在driver类中设置使用 job.setPartitionerClass(PhoneNumPartitioner.class); 3) 设置reduce的个数 正常情况下，根据分区器业务来决定设置多少个，说白了就是分区器的逻辑会生成多少个分区， 则设置的多少个reduce 1.2 分区使用的注意事项: 1). reduce个数的设置 如果不设置，red
MapReduce：分区与分组
Jodness' Blogs
05-29 3214
分区、分组 分区：在Mapper的输出时进行，默认会采用HashPartitioner，会根据key值和reduce数进行分组；在写入MapOutputBuffer的缓冲区之前每个kv对就已经获取了对应的分区索引，在溢写时默认会根据分区索引从小到大，key值从小到大进行排序；并且rudecer数决定了分区数量，因为一个reducer只能处理一个分区。自定义分组器通过Job.setPartitio...
mapreduce当中的GroupingComparator分组详解
fengge18306的博客
03-22 677
GroupingComparator是mapreduce当中reduce端的一个功能组件，主要的作用是决定哪些数据作为一组，调用一次reduce的逻辑，默认是每个不同的key，作为多个不同的组，每个组调用一次reduce逻辑，我们可以自定义GroupingComparator实现不同的key作为同一个组，调用一次reduce逻辑 1、分组排序步骤： （1）自定义类继承WritableCompa...
Map Reduce执行过程
renzhixin1314的博客
03-18 1283
Map Reduce 执行过程是数仓hql调优所必须熟知的，也是初高级数仓工程师面试基本必问的一块内容，所以为了面包，巩固学习一下。 Map Reduce 执行过程：map阶段 ---> shuffle阶段 ---> reduce阶段 map阶段 1.分片读取...
Hadoop mapreduce过程key 和value分别存什么值
小爷欣欣
05-04 1万+
转自：https://www.cnblogs.com/gaopeng527/p/5436820.html这里以wordCount为例，直接看图就懂了：（1）inputFormat将hdfs上要处理的文件一行一行的读入，将文件拆分成splits，由于测试用的文件较小，所以每个文件为一个split，并将文件按行分割形成&lt;key,value&gt;对，如图4-1所示。这一步由MapReduce框架...
MapReduce2中自定义排序分组
08-12
本文将详细探讨在 MapReduce2 中如何实现自定义排序和分组，以满足特定的数据处理需求。 首先，了解 MapReduce 的工作流程是必要的。Map 阶段将输入数据分割成多个块，并在各个节点上并行处理。Reduce 阶段则负责...
学生mapreduce成绩分析
06-02
例如，它可以按学生ID或者科目进行分组，并将成绩转化为键值对的形式，如（“学生ID”，[科目，成绩]）。 **Reduce阶段**： Reduce阶段则接收Map阶段产生的中间结果，对同一键的值进行聚合操作。在成绩分析中，...
mapreduce程序
12-08
Reduce任务根据键对Map阶段的输出进行排序，然后将相同键的所有值分组。Reduce函数对每个键及其相关的值列表执行聚合操作，如求和、计数或连接。这个过程可以理解为对数据进行汇总和总结，生成最终的结果。 **...
3 大数据基础 - MapReduce
最新发布
12-20
在这个阶段，Reduce 函数将 Map 阶段的输出按照 Key 分组，并对每组数据进行聚合操作，生成最终的结果。 在 Hadoop 中，MapReduce 是一个核心组件，用来处理大规模数据集。MapReduce 的优点是可以处理大规模数据，...
MapReduce简单程序示例
12-05
首先，Reduce函数会对相同的键进行分组，然后将该键对应的值列表作为参数传递给Reduce函数。这一步骤通常用于计算汇总统计量，如求和、平均值等。同样，Reduce操作也在多台机器上并行进行，以处理海量数据。 ...
大数据第七天---MapReduce详解
hl199612的博客
01-28 754
1.Combiner     Combiner的出现：为什么需要进行Map规约操作 在上述过程中，我们看到至少两个性能瓶颈： （1）如果我们有10亿个数据，Mapper会生成10亿个键值对在网络间进行传输，但如果我们只是对数据求最大值，那么很明显的Mapper只需要输出它所知道的最大值即可。这样做不仅可以减轻网络压力，同样也可以大幅度提高程序效率。                    
mapreduce中split划分分析（新版api）
热门推荐
wisgood的专栏
01-27 1万+
面试的过程中，笔者经常喜欢问一个问题：hadoop中map数是怎么确定的？但发现还是有好多面试者都答不上来。这个问题其实算是比较基础的一个问题，对于理解mapreduce的原理很有帮助。 今天有空结合源码分析一下。 本文以hadoop2.7.2的版本作为分析，代码链接如下。 —— [ github代码地址 ] 本文以org.apache.hadoop.mapreduce包作为讲解(即新AP...
MapReducer中的GroupingComparator分组比较器实现
chuxingbubian的博客
11-26 1007
Pom.xml文件为： （2）实现思路 先介绍一个概念GroupingComparator组比较器，通过WordCount来理解它的作用。 WordCount中map处理完成后的结果数据是这样的： &amp;lt;good,1&amp;gt; &amp;lt;good,1&amp;gt; &amp;lt;good,1&amp;gt; &amp;lt;is,1&amp;gt; &amp;lt;is,1&am
「 Hadoop」mapreduce对温度数据进行自定义排序、分组、分区等
知之可否
03-14 3801
转自  http://www.ptbird.cn/mapreduce-tempreture.html 一、需求说明 1、数据文件说明 hdfs中有一些存储温度的数据文件，以文本形式存储，示例如下： 日期和时间中间是空格，为整体，表示检测站点监测的时间，后面是检测的温度，中间通过制表符 \t 相隔。 2、需求 计算在1949-1955年中,
MapReduce的自制Writable分组输出及组内排序
weixin_34388207的博客
09-03 167
问题描述：输入文件格式如下：name1 2name3 4name1 6name1 1name3 3name1 0要求输出的文件格式如下：name1 0，1，2，6name3 3，4要求是按照第一列分组，name1与name3也是按照顺序排列的，组内升序排序。思路：常规的输出，无法排序key所对应的多个值的顺序。为了排序组内中的值...
MapReduce中的排序和分组
u014033218的专栏
08-11 1300
回顾Map阶段四大步骤　　首先，我们回顾一下在MapReduce中，排序和分组在哪里被执行：map stage 　　从上图中可以清楚地看出，在Step1.4也就是第四步中，需要对不同分区中的数据进行排序和分组，默认情况下，是按照key进行排序和分组。1.2 实验场景数据文件　　在一些特定的数据文件中，不一定都是类似于WordCount单次统计这种规范的数据，比如下面这类数据，它虽然只有两列，但
MapReduce利用分区，排序，分组规则
mrye的博客
04-22 250
数据： order001,u001,小米6,1999.9,2 order001,u001,雀巢咖啡,99.0,2 order001,u001,安慕希,250.0,2 order001,u001,经典红双喜,200.0,4 order001,u001,防水电脑包,400.0,2 order002,u002,小米手环,199.0,3 order002,u002,榴莲,15.0,10 order00...
Mapreduce中分组排序的一些认识
zhigang1007的博客
10-27 747
今天偶然和朋友讨论了下关于Mapreduce中分组排序输出topN的问题。为了方便大家理解，特意将聊天的细节分享给大家。 业务逻辑经常会有topN的需求，通常我们对数据进行排序规则制定之后，我们并不能够按需求获得我们需要的数据，其关键原因就在于我们没有自定义分组。 自定义分组，涉及到的一个关键类为WritableComparator。自定义分组的第一步，就是要编写一个类去继承该类，然后重写其c
用一个MapReduce输出多个key的分区文件
破碎琉璃为哪般
12-08 1339
先看一下要处理的数据类型 19392963501,17816115082,2018-09-18 16:19:44,1431 14081946321,13094566759,2018-05-23 09:34:27,0610 13415701165,18939575060,2018-11-23 21:33:23,1031 15590483587,16303009156,2018-08-02 07:3...
MapReduce分组
07-28
在MapReduce中，"分组"通常指的是将输入数据根据某个特定的键进行分组，以便进一步处理。 在Map阶段，输入数据会被划分为若干个键值对，其中键表示数据的分组依据，值表示实际的数据。然后，Map函数会将每个键值对...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值