MapReduce功能实现五---去重(Distinct)、计数(Count)

最新推荐文章于 2024-06-15 16:13:44 发布
最新推荐文章于 2024-06-15 16:13:44 发布
阅读量1.3w 收藏 49
点赞数 6
分类专栏： hadoop MapReduce功能实现 文章标签： mapreduce 去重Distinct 计数Count
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37739193/article/details/76102486
版权

MapReduce功能实现系列：
      MapReduce功能实现一—Hbase和Hdfs之间数据相互转换
      MapReduce功能实现二—排序
      MapReduce功能实现三—Top N
      MapReduce功能实现四—小综合(从hbase中读取数据统计并在hdfs中降序输出Top 3)
      MapReduce功能实现五—去重(Distinct)、计数(Count)
      MapReduce功能实现六—最大值(Max)、求和(Sum)、平均值(Avg)
      MapReduce功能实现七—小综合(多个job串行处理计算平均值)
      MapReduce功能实现八—分区(Partition)
      MapReduce功能实现九—Pv、Uv
      MapReduce功能实现十—倒排索引(Inverted Index)
      MapReduce功能实现十一—join
 

一、去重

类似于db中的select distinct(x) from table , 去重处理甚至比WordCount还要简单：

[hadoop@h71 q1]$ vi hello.txt
hello world
hello hadoop
hello hive
hello hadoop
hello world
hello world
[hadoop@h71 q1]$ hadoop fs -mkdir /user/hadoop/dedup_in
[hadoop@h71 q1]$ hadoop fs -put hello.txt /user/hadoop/dedup_in

java代码：

import java.io.IOException;
 
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
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 org.apache.hadoop.util.GenericOptionsParser;
 
public class Dedup {
 
    public static class RemoveDupMapper extends Mapper<Object, Text, Text, NullWritable> {
    	public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
    		context.write(value, NullWritable.get());
    	}
    }
 
    public static class RemoveDupReducer extends Reducer<Text, NullWritable, Text, NullWritable> {
    	public void reduce(Text key, Iterable<NullWritable> values, Context context)
        throws IOException, InterruptedException {
    		context.write(key, NullWritable.get());
    	}
    }
 
    public static void main(String[] args) throws Exception{
        Configuration conf = new Configuration();
        conf.set("mapred.jar","Dedup.jar");   //去掉这行也能运行，目前还不知道这行有什么用
        String[] ioArgs=new String[]{"dedup_in","dedup_out"};
        String[] otherArgs = new GenericOptionsParser(conf, ioArgs).getRemainingArgs();
        if (otherArgs.length != 2) {
        	System.err.println("Usage: Data Deduplication <in> <out>");
        	System.exit(2);
        }
        
        Job job = new Job(conf, "Data Deduplication");
        job.setJarByClass(Dedup.class);
 
        //设置Map、Combine和Reduce处理类
        job.setMapperClass(RemoveDupMapper.class);
        job.setCombinerClass(RemoveDupReducer.class);
        job.setReducerClass(RemoveDupReducer.class);
 
        //设置输出类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);
 
        //设置输入和输出目录
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
	}
}

在Linux中运行代码：

[hadoop@h71 q1]$ /usr/jdk1.7.0_25/bin/javac Dedup.java 
[hadoop@h71 q1]$ /usr/jdk1.7.0_25/bin/jar cvf xx.jar Dedup*class
[hadoop@h71 q1]$ hadoop jar xx.jar Dedup

查看结果：

[hadoop@h71 q1]$ hadoop fs -cat /user/hadoop/dedup_out/part-r-00000
hello hadoop
hello hive
hello world

二、计数器的使用

[hadoop@h71 q1]$ hadoop fs -mkdir /user/hadoop/mapinput
[hadoop@h71 q1]$ hadoop fs -put hello.txt /user/hadoop/mapinput

java代码：

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Counter;
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;
 
/**
 * mapreduce中计数器的使用
 */
public class WordCountApp {
 
	private static final String INPUT_PATH = "hdfs://h71:9000/user/hadoop/mapinput";
	private static final String OUTPUT_PATH = "hdfs://h71:9000/user/hadoop/mapoutput";
	
	public static void main(String[] args) throws IOException, URISyntaxException, 
	      ClassNotFoundException, InterruptedException {
		Configuration conf = new Configuration();
		conf.set("mapred.jar","wcapp.jar");		
 
		final FileSystem fileSystem = FileSystem.get(new URI(OUTPUT_PATH), conf);
		fileSystem.delete(new Path(OUTPUT_PATH), true);
		
		final Job job = new Job(conf, WordCountApp.class.getSimpleName());
		job.setJarByClass(WordCountApp.class);
		
		FileInputFormat.setInputPaths(job, INPUT_PATH);
		job.setMapperClass(MyMapper.class);
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(LongWritable.class);
		
		job.setReducerClass(MyReducer.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(LongWritable.class);
		FileOutputFormat.setOutputPath(job, new Path(OUTPUT_PATH));
		
		job.waitForCompletion(true);
	}
 
	public static class MyMapper extends Mapper<LongWritable, Text, Text, LongWritable> {
		protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
			final String line = value.toString();
			StringTokenizer tokenizer = new StringTokenizer(line);
			final Counter counter = context.getCounter("Sensitive", "hello");
			if (value.toString().contains("hello")) {
				counter.increment(1L);   //当查询到包含hello的词语时，计数器加1
			}
			while(tokenizer.hasMoreTokens()) {
				String target = tokenizer.nextToken();
				if(target.equals("hello")){		//只过滤输出hello的计数
				context.write(new Text(target), new LongWritable(1));
				}
			}
		}
	}
	
	public static class MyReducer extends Reducer<Text, LongWritable, Text, LongWritable> {
		@Override
		protected void reduce(Text key, Iterable<LongWritable> value,
				Reducer<Text, LongWritable, Text, LongWritable>.Context context)
				throws IOException, InterruptedException {
			long times = 0l;
			while (value.iterator().hasNext()) {
				times += value.iterator().next().get();
			}
			context.write(key, new LongWritable(times));
		}
	}
}

[hadoop@h71 q1]$ /usr/jdk1.7.0_25/bin/javac WordCountApp.java 
[hadoop@h71 q1]$ /usr/jdk1.7.0_25/bin/jar cvf xx.jar WordCountApp*class
[hadoop@h71 q1]$ hadoop jar xx.jar WordCountApp

在控制台打印的信息中你会看到：

        Sensitive
                hello=6
[hadoop@h71 q1]$ hadoop fs -cat /user/hadoop/mapoutput/part-r-00000
hello   6

三、记录计数(Count)

[hadoop@h71 q1]$ vi ceshi.txt
2
8
8
3
2
3
5
3
0
2
7
[hadoop@h71 q1]$ hadoop fs -put ceshi.txt /input

这个跟WordCount略有不同,类似于Select Count(*) from tables的效果,代码也超级简单，直接拿WordCount改一改就行了：

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 RowCount {
	
    public static class RowCountMapper extends Mapper<Object, Text, Text, IntWritable> {
        private final static IntWritable one = new IntWritable(1);
        private final  static Text countKey = new Text("count");
        public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
                context.write(countKey, one);
        }
    }
 
    public static class RowCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
        private IntWritable result = new IntWritable();
        public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            result.set(sum);
            context.write(key, result);
        }
    }
 
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
        if (otherArgs.length < 2) {
            System.err.println("Usage: RowCount <in> [<in>...] <out>");
            System.exit(2);
        }
 
        Job job = Job.getInstance(conf, "word count");
        job.setJarByClass(RowCount.class);
        job.setMapperClass(RowCountMapper.class);
        job.setCombinerClass(RowCountReducer.class);
        job.setReducerClass(RowCountReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        for (int i = 0; i < otherArgs.length - 1; ++i) {
            FileInputFormat.addInputPath(job, new Path(otherArgs[i]));
        }
        FileOutputFormat.setOutputPath(job,
                new Path(otherArgs[otherArgs.length - 1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

[hadoop@h71 q1]$ /usr/jdk1.7.0_25/bin/javac RowCount.java 
[hadoop@h71 q1]$ /usr/jdk1.7.0_25/bin/jar cvf xx.jar RowCount*class
[hadoop@h71 q1]$ hadoop jar xx.jar RowCount /input/ceshi.txt /output

[hadoop@h71 q1]$ hadoop fs -cat /output/part-r-00000
count   11

注：如果只想输出一个数字，不需要"count"这个key，可以改进一下：

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 org.apache.hadoop.util.GenericOptionsParser;
 
import java.io.IOException;
 
public class RowCount2 {
 
    public static class RowCount2Mapper extends Mapper<LongWritable, Text, LongWritable, NullWritable> {
        public long count = 0;
        public void map(LongWritable key, Text value, Context context)
                throws IOException, InterruptedException {
            count += 1;
        }
        protected void cleanup(Context context) throws IOException, InterruptedException {
            context.write(new LongWritable(count), NullWritable.get());
        }
    }
 
    public static class RowCount2Reducer extends Reducer<LongWritable, NullWritable, LongWritable, NullWritable> {
        public long count = 0;
        public void reduce(LongWritable key, Iterable<NullWritable> values, Context context)
                throws IOException, InterruptedException {
            count += key.get();
        }
        protected void cleanup(Context context) throws IOException, InterruptedException {
            context.write(new LongWritable(count), NullWritable.get());
        }
    }
 
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
        if (otherArgs.length < 2) {
            System.err.println("Usage: FindMax <in> [<in>...] <out>");
            System.exit(2);
        }
 
        Job job = Job.getInstance(conf, "RowCount2");
        job.setJarByClass(RowCount2.class);
        job.setMapperClass(RowCount2Mapper.class);
        job.setCombinerClass(RowCount2Reducer.class);
        job.setReducerClass(RowCount2Reducer.class);
        job.setOutputKeyClass(LongWritable.class);
        job.setOutputValueClass(NullWritable.class);
 
        for (int i = 0; i < otherArgs.length - 1; ++i) {
            FileInputFormat.addInputPath(job, new Path(otherArgs[i]));
        }
        FileOutputFormat.setOutputPath(job,
                new Path(otherArgs[otherArgs.length - 1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

[hadoop@h71 q1]$ hadoop fs -cat /output/part-r-00000
11

这样输出结果就只有一个数字11了。

注意：这里context.write(xxx)只能写在cleanup方法中，该方法在Mapper和Reducer接口中都有，在map方法及reduce方法执行完后，会触发cleanup方法，大家可以尝试下，把context.write(xxx)写在map和reduce方法中试试看，结果会出现多行记录，而不是预期的仅1个数字。

小强签名设计
关注
  • 6
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【大数据教程】MapReduce基本架构、统计文件中每个字符出现的次数，IP去重、计算每个人的最高分，总分
微信号：RunsenLiu
02-17 1351
【大数据教程】MapReduce基本架构、统计文件中每个字符出现的次数，IP去重、计算每个人的最高分，总分
华为练习jar包mapreduce-examples-mrs-2.0
11-18
mapreduce-examples-mrs-2.0
【Hive】MapReduce 如何实现 Hive SQL 的基本操作-count
每天更新大数据面经和技术
09-05 451
count
Hadoop一课一得
最新发布
tzm_1的博客
06-15 862
本文详细介绍了Hadoop课程的内容和学习路径，希望能够帮助读者更好地理解和应用这一强大的大数据处理工具。
9.聚合函数count+distinct+group + MapReduce
12-06 1322
1.max最大值 min最小值mongoDB不像SQL那样有min() 和max()函数。但是可以通过sort排序和limit限制返回来得到想要的结果找到投票数helpful_votes**最多**的评论：（最大值，按照降序排列，并限制返回第1条记录）db.reviews.find({}).sort({helpful_votes : -1}).limit(1)找到投票数helpful_votes**
MapReduce实现sql的原理
Cxf2018的博客
04-28 443
1.join的实现原理 select u.name, o.orderid from order o join user u on o.uid = u.uid; 在map阶段的输出中给每个value一个tag，用于区分数据来源，在shuffle过程将具有相同key的数据合并在一起，在reduce阶段对key相同的不同来源的数据进行join。 2.group by的实现原理 select rank, isonline, count(*) from city group by rank, isonline
MapReduce之去重计数类应用
跟着大数据和AI去旅行
03-27 1509
应用需求在大数据文件中包含了大量的记录，每条记录记载了某事物的一些属性，需要根据某几个属性的组合，去除相同的重复组合，并统计其中某属性的统计值。解决方法在此类应用中，将计算过程分为两个步骤。 第一步，map 函数将每条记录中需要关注的属性组合作为关键字，将空字符串作为值，生成的<键-值>对作为中间值输出。 第二步，reduce 函数则将输入的中间结果的 key 作为新的 key,value仍然取
Hadoop阅读笔记（二）——利用MapReduce求平均数和去重
baixieyun4655的博客
12-25 232
前言：圣诞节来了，我怎么能虚度光阴呢？！依稀记得，那一年，大家互赠贺卡，短短几行字，字字融化在心里；那一年，大家在水果市场，寻找那些最能代表自己心意的苹果香蕉梨，摸着冰冷的水果外皮，内心早已滚烫。这一年……我在博客园-_-#，希望用dt的代码燃烧脑细胞，温暖小心窝。 上篇《Hadoop阅读笔记（一）——强大的MapReduce》主要介绍了MapReduce的在大数据集上处理的优势以及运...
MapReduce下的k-means算法实验报告广工（附源码）
01-10
在这个实验报告中，学生被要求在MapReduce框架下实现k-means聚类算法。k-means是一种广泛应用的无监督学习方法，用于将数据集分成k个不同的簇，使得每个数据点都尽可能接近其所属簇的中心。 k-means算法的基本步骤...
MapReduce操作实例-数据去重.pdf
07-11
`DedupReducer`类实现了`reduce`方法，这是MapReduce的第二步。Reducer接收到由Mapper生成的中间键值对，即所有相同的键（行）及其对应的空值。在这里，Reducer简单地将每个唯一的键（已去重的行）写回到输出，值...
Hadoop 3.x（MapReduce）----【MapReduce 概述】---- 代码
09-12
Hadoop 3.x（MapReduce）----【MapReduce 概述】---- 代码 Hadoop 3.x（MapReduce）----【MapReduce 概述】---- 代码 Hadoop 3.x（MapReduce）----【MapReduce 概述】---- 代码 Hadoop 3.x（MapReduce）----...
大数据学习（八）：mapreduce编程案例-计算访问次数最多的5个网站
01-20
数据 2017/07/28 qq.com/a 2017/07/28 qq.com/bx 2017/07/28 qq.com/by 2017/07/28 qq.com/by3 2017/07/28 qq.com/news 2017/07/28 sina.com/news/socail 2017/07/28 163.com/ac 2017/07/28 sina.com/news/socail 2017/07/28 163.com/sport 2017/07/28 163.com/ac 2017/07/28 sina.com/play 2017/07/28 163.com/sport 2017/07
MapReduce综合应用案例 - 招聘数据清洗-结果
04-02
MapReduce综合应用案例 - 招聘数据清洗-结果
第三节 MapReduce(一)
云深不知处
09-18 1335
从上图来看，基本上属于MapReduce转变的前身设计思路，从MapReduce命名上来看有两部分组成，Map意思映射，Reduce为规约。可以按照下面的方式理解Map和Reduce。输入（input）一个大文件，通过切片（split）之后，将数据分成多个切片。每个文件切片由单独的节点进行处理，这就是Map方法。将各个节点计算的结果进行汇总，并得到最终结果，这就是Reduce方法。任务job = Map+Reduce，Map输出，就是Reduce的输入。
MapReduce实现基本SQL操作的原理
gan785160627的博客
07-27 918
Join的实现原理 select u.name, o.orderid from order o join user u on o.uid = u.uid; 在map阶段的输出中给每个value一个tag，用于区分数据来源，在shuffle过程将具有相同key的数据合并在一起，在reduce阶段对key相同的不同来源的数据进行join。 Group By的实现原理  select r...
MapReduce之distinct
踏云追月
01-29 2847
适用场景： 当我们希望去除数据集中的重复数据或者某些字段重复的数据就可以使用这个模式。 结构： 这个模式使用了MapReduce框架的功能，将相同的key分组到一起来实现去重。这个模式使用mapper做数据的转换，在reducer中不需要做太多工作。在这个模式中可以使用combiner,如果有大量重复的数据，combiner将非常有用。重复的记录在数据集中经常会相对邻近，因此comb
开发实战角度：distinct实现原理及具体优化总结
涤生大数据
01-22 1280
Distinct是一种常用的操作，在所有数据库的SQl语言中都是一个非常重要的操作，。基本原理是将输入的数据集按照指定的列进行分组，在每个分组内部去除重复的值，最后将每个分组的唯一值合并成一个结果集。最近一位好学的小伙伴在学习的过程中，学习到count distinct 的这块内容的时候，，今天就来给大家总结一下。group by的操作适合我们的聚合时distinct息息相关的，所以在我们总结distinct 之前 ，我们不得不先来看一下group by 操作的具体实现原理。
Hadoop生态圈（二十四）- MapReduce Counter计数器
程序园@大Null
02-05 1230
MapReduce计数器概述，MapReduce内置计数器，MapReduce自定义计数器，Map-Reduce Framework Counters，File System Counters Counters，Job Counters，File Input | Output Format Counters，MapReduce自定义计数器案例
用map实现数组去重
weixin_45484698的博客
09-16 892
js

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小强签名设计

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值