MapReduce练习-----倒排索引

最新推荐文章于 2024-10-12 11:19:00 发布
最新推荐文章于 2024-10-12 11:19:00 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： # Hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyz_home/article/details/79949076
版权 
数据1：
huangbo love xuzheng
huangxiaoming love baby huangxiaoming love mimi
liangchaowei love liujialing

数据2：
hello huangbo
hello xuzheng
hello huangxiaoming

题目一：编写 MapReduce 求出以下格式的结果数据：统计每个关键词在每个文档中当中的第几行出现了多少次。
例如，huangxiaoming 关键词的格式：

huangixaoming  mapreduce-4-1.txt:2,2; mapreduce-4-1.txt:4,1;mapreduce-4-2.txt:3,1

首先是进行文件的额切分，拼接添加行号，以单词为key，文件名和行号进行拼接做为value，然后通过第二个MapRudece程序将数据组合成我们需要的。样式。

第一个MapReduce程序

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.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;

public class Question3_1_1 {
		public static class MRMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

			Text k = new Text();
			IntWritable v = new IntWritable(1);
			int num = 0;

			@Override
			protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

				String line = value.toString();
				//行号
				num++;

				String[] words = line.split(" ");

				//huangixaoming  mapreduce-4-1.txt:2,2; mapreduce-4-1.txt:4,1;mapreduce-4-2.txt:3,1
				FileSplit inputSplit = (FileSplit) context.getInputSplit();
				//通过切片获取文件的名称
				String fileName = inputSplit.getPath().getName();
				for (String word : words) {
					//单词+文件名+行号  作为key输出
					k.set(word + ":" + fileName+ ":" + (num));
					System.out.println(word + "--" + fileName+ "--" + (num));
					context.write(k, v);

				}
				
			}

		}

		public static class MRReducer extends Reducer<Text, IntWritable, Text, NullWritable> {

			Text t = new Text();
			@Override
			protected void reduce(Text key, Iterable<IntWritable> values, Context context) 
					throws IOException, InterruptedException {
				//获取到key 单词+文件名+行号；
				//根据key相同，进行累加相同的word出现了几次
				int count = 0;
				for (IntWritable value : values) {

					count += value.get();
				}
				
				//转化输出
				t.set(key.toString()+","+count);
				context.write(t,NullWritable.get());

			}

		}

		public static void main(String[] args) throws Exception {

			Configuration conf = new Configuration();
			FileSystem fs = FileSystem.get(conf);
			Job job = Job.getInstance(conf);
			
			job.setJarByClass(Question3_1_1.class);

			job.setMapOutputKeyClass(Text.class);
			job.setMapOutputValueClass(IntWritable.class);
			job.setOutputKeyClass(Text.class);
			job.setOutputValueClass(NullWritable.class);

			FileInputFormat.setInputPaths(job, new Path("G:/test/q3/input"));
			
			if(fs.exists(new Path("G:/test/q3/output_3_1"))){
				fs.delete(new Path("G:/test/q3/output_3_1"), true);
			}
			FileOutputFormat.setOutputPath(job, new Path("G:/test/q3/output_3_1"));

			job.setMapperClass(MRMapper.class);
			job.setReducerClass(MRReducer.class);

			System.exit(job.waitForCompletion(true) ? 1:0);

		}


}

第二个MapReduce程序


import java.io.IOException;

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.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;

public class Question3_1_2 {
	
	public static class MRMapper extends Mapper<LongWritable, Text, Text, Text>{
		@Override
		protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
			String line = value.toString();
			String[] files = line.split(":");
			//k.set(word + ":" + fileName+ ":" + (num));
			//baby:mapreduce-4-1.txt:2,1
			String str = files[1]+":"+files[2];
			context.write(new Text(files[0]), new Text(str));
		}
	}
	
	public static class MRReducer extends Reducer<Text, Text, Text, Text>{
		@Override
		protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
			StringBuffer sb = new StringBuffer();
			for (Text text : values) {
				sb.append(text.toString()+";");
			}
			context.write(key, new Text(sb.toString()));
		}
	}
	
	public static void main(String[] args) throws Exception {
		
		Configuration conf = new Configuration();
		FileSystem fs = FileSystem.get(conf);
		Job job = Job.getInstance(conf);
		job.setJarByClass(Question3_1_2.class);
		
		job.setMapperClass(MRMapper.class);
		job.setReducerClass(MRReducer.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(Text.class);
		
		FileInputFormat.setInputPaths(job, new Path("G:/test/q3/output_3_1"));
		
		if(fs.exists(new Path("G:/test/q3/output_3_2"))){
			fs.delete(new Path("G:/test/q3/output_3_2"), true);
		}
		FileOutputFormat.setOutputPath(job, new Path("G:/test/q3/output_3_2"));
		
		System.exit(job.waitForCompletion(true) ? 1:0);
	}


}
题目二：编写 MapReduce 程序求出每个关键词在每个文档出现了多少次，并且按照出现次数降序排序。
例如：
huangixaoming  mapreduce-4-1.txt,3;mapreduce-4-2.txt,1
以上答案的含义：
关键词 huangxiaoming 在第一份文档 mapreduce-4-1.txt 中出现了 3 次，在第二份文档mapreduce-4-2.txt 中出现了 1 次。

方案：先统计出每个关键词在某个文件中的出现次数，然后再进行排序。


import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.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;

public class Question3_2_1 {
		public static class MRMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

			Text k = new Text();
			IntWritable v = new IntWritable(1);

			@Override
			protected void map(LongWritable key, Text value, Context context) 
					throws IOException, InterruptedException {

				String line = value.toString();

				String[] words = line.split(" ");

				//huangixaoming  mapreduce-4-1.txt:2,2; mapreduce-4-1.txt:4,1;mapreduce-4-2.txt:3,1
				FileSplit inputSplit = (FileSplit) context.getInputSplit();
				String fileName = inputSplit.getPath().getName();
				for (String word : words) {
					k.set(word + ":" + fileName);
					context.write(k, v);

				}
				
			}

		}

		public static class MRReducer extends Reducer<Text, IntWritable, Text, NullWritable> {

			Text t = new Text();
			@Override
			protected void reduce(Text key, Iterable<IntWritable> values, Context context) 
					throws IOException, InterruptedException {

				int count = 0;
				for (IntWritable value : values) {

					count += value.get();
				}
				t.set(key.toString()+","+count);
				context.write(t,NullWritable.get());

			}

		}

		public static void main(String[] args) throws Exception {

			Configuration conf = new Configuration();
			FileSystem fs = FileSystem.get(conf);
			Job job = Job.getInstance(conf);
			
			job.setJarByClass(Question3_2_1.class);

			job.setMapOutputKeyClass(Text.class);
			job.setMapOutputValueClass(IntWritable.class);
			job.setOutputKeyClass(Text.class);
			job.setOutputValueClass(NullWritable.class);

			FileInputFormat.setInputPaths(job, new Path("G:/test/q3/input"));
			
			if(fs.exists(new Path("G:/test/q3/output_3_3"))){
				fs.delete(new Path("G:/test/q3/output_3_3"), true);
			}
			FileOutputFormat.setOutputPath(job, new Path("G:/test/q3/output_3_3"));

			job.setMapperClass(MRMapper.class);
			job.setReducerClass(MRReducer.class);

			System.exit(job.waitForCompletion(true) ? 1:0);

		}


}
使用自定义对象，将上面的结果组合成一个自定义对象，然后根据关键词分组，根据出现次数排序； 

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class Question3_2_2 {
	//huangixaoming  mapreduce-4-1.txt,3;mapreduce-4-2.txt,1
	//yangmi:mapreduce-4-1.txt,1
	public static class MRMapper extends Mapper<LongWritable, Text, TestBean, NullWritable>{
		@Override
		protected void map(LongWritable key, Text value, Context context) 
				throws IOException, InterruptedException {
			
			String[] line =  value.toString().split(":");
			TestBean tb = new TestBean(line[0],line[1].split(",")[0],Integer.parseInt(line[1].split(",")[1]));
			context.write(tb,NullWritable.get());
		}
	}
	
	public static class MRReducer extends Reducer<TestBean, NullWritable, Text, Text>{
		Text k = new Text();
		Text v = new Text();
		@Override
		protected void reduce(TestBean key, Iterable<NullWritable> values, Context context)
				throws IOException, InterruptedException {
			
			StringBuffer sb = new StringBuffer();
			for (NullWritable nv : values) {
				sb.append(key.getFileName()+","+key.getNum()+";");
			}
			k.set(key.getName());
			v.set(sb.toString());
			context.write(k, v);
		}
	}
	
	public static void main(String[] args) throws Exception {
		
		Configuration conf = new Configuration();
		FileSystem fs = FileSystem.get(conf);
		Job job = Job.getInstance(conf);
		job.setJarByClass(Question3_2_2.class);
		
		job.setMapperClass(MRMapper.class);
		job.setReducerClass(MRReducer.class);
		job.setMapOutputKeyClass(TestBean.class);
		job.setMapOutputValueClass(NullWritable.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(Text.class);
		job.setGroupingComparatorClass(UserGC.class);
		
		FileInputFormat.setInputPaths(job, new Path("G:/test/q3/output_3_3"));
		
		if(fs.exists(new Path("G:/test/q3/output_3_4"))){
			fs.delete(new Path("G:/test/q3/output_3_4"), true);
		}
		FileOutputFormat.setOutputPath(job, new Path("G:/test/q3/output_3_4"));
		
		System.exit(job.waitForCompletion(true) ? 1:0);
	}


}
自定义数据类型：TestBean  
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

import org.apache.hadoop.io.WritableComparable;

public class TestBean implements WritableComparable<TestBean>{
	private String name;
	private String fileName;
	private int num;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getFileName() {
		return fileName;
	}
	public void setFileName(String fileName) {
		this.fileName = fileName;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public TestBean() {
		super();
		// TODO Auto-generated constructor stub
	}
	public TestBean(String name, String fileName, int num) {
		super();
		this.name = name;
		this.fileName = fileName;
		this.num = num;
	}
	@Override
	public void write(DataOutput out) throws IOException {
		out.writeUTF(name);
		out.writeUTF(fileName);
		out.writeInt(num);
	}
	@Override
	public void readFields(DataInput in) throws IOException {
		name = in.readUTF();
		fileName = in.readUTF();
		num = in.readInt();		
	}
	@Override
	public int compareTo(TestBean o) {
		
		if(o.getName().compareTo(this.getName()) == 0){
			int flag = o.getNum()-this.getNum();
			if(flag == 0){
				return 0;
			}else if(flag > 0){
				return 1;
			}else{
				return -1;
			}
		}else{
			return o.getName().compareTo(this.getName());
		}
		
	}
	
	
}

自定义分组组件：UserGC


import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;

public class UserGC extends WritableComparator{

	public UserGC() {
		super(TestBean.class,true);
	}

	@Override
	public int compare(WritableComparable a, WritableComparable b) {
		TestBean pa = (TestBean) a;	
		TestBean pb = (TestBean) b;	
		
		
		return pa.getName().compareTo(pb.getName());
	}
	
}
_a_0_
关注
专栏目录
MapReduce--倒排索引
jianjian1992的专栏
08-04 4849
文档倒排算法简介Inverted Index(倒排索引)是目前几乎所有支持全文检索的搜索引擎都要依赖的一个数据结构。基于索引结构，给出一个词(term)，能取得含有这个term的文档列表(the list of documents) Web Search中的问题主要分为三部分： crawling(gathering web content) ,网页爬虫，收集数据 indexing(construc
MapReduce倒排索引
weixin_39791537的博客
06-09 1048
    倒排索引就是某个单词在那些文件中出现的次数，而在最开始学习的Wordcount中是某个文件中那些单词出现的次数，两者正好相反，就像在搜索引擎上搜索一个单词，下面就会罗列出这个单词在哪些文件里出现过。     首先我们就要想好，什么是key,什么是value，map输出的结果是什么，reduce怎样处理才能够得到想要的结果。     在倒排索引中，我们需要得到单词-文件名-次数，因为这个...
mapreduce实现倒排索引
踏云追月
01-27 1296
目的： 产生一个数据集的索引以便提供更快的搜索或数据丰富能力。 动机： 对大的数据集建立一个关键字的索引，通常可以方便通过指定关键字搜索到其包含特定值的对应记录。尽管创建倒排索引的过程需要预先进行额外的处理，但花费时间做预处理可以极大地缩减查询时所需要的时间。 适用场景： 倒排索引通常用在需要快速搜索查询响应的场景。可以对一个查询的结果进行预处理并存入数据库中。
MapReduce经典案例-倒排索引
最新发布
qianwanfuweng的博客
10-12 1015
Combine阶段的实现，对每个单词进行词频统计，大致思路是，创建一个四有对象，来基本上确定键值对的格式，然后重写reduce放大没见过键值对的格式设置为单词，将键值对的格式改为：文档名称：单词次数。大概思路是，先生成一个对象用于储存单词还有文档的名称，然后重写map方法，将单词和文件名以键值对的方法进行输出，方便下一阶段Combine的实现。如果不顺利，出现了类似于下面这种信息的报错，可能是大家之前的虚拟机出现了问题，大家进行了一个恢复快照的操作。那么解决的方法是，大家回到hadoop01的终端，输入。
ES 倒排索引
aganliang的专栏
05-14 516
参考：https://www.cnblogs.com/cjsblog/p/10327673.html 正向索引和倒排索引，都是索引，方便快速查找；两者实现原理不一样，应用场景不一样。 正向索引是通过 key找到value 倒排索引是通过value找到key 倒排索引由以下几个部分组成： term：分词器分析后，形成的一个个单词叫做term term dictionary：单词字典，term的集合 term index：单词索引，可以快速找到这个单词，一般用B-Tree索引。是不是可以.
MapReduce倒排索引简单实现
在路上的学习者
11-10 3580
倒排索引：
MapReduce练习之倒排索引
学习笔记
06-06 342
0. 问题TF-IDF 实现统计多个文档中一个单词出现的频数和出现在哪个文档中 在map中读取当前文档的每一行数据,得到当前文档路径 mapkey(单词:文档路径),mapvalue(数值1) 在map端设置Combiner类(整合数据,减少向reduce端传输数据的网络开销) 将map的输出重新组合输出&amp;lt;单词,文档路径:单词频数&amp;gt; 输入文件为三篇txt英文文档 输出文件格式为 ...
MapReduce练习二（单表关联，多表关联，倒排索引）
login_sonata的博客
06-28 2710
相关链接： MapReduce练习一（计数，去重，排序，平均成绩） MapReduce练习二（单表关联，多表关联，倒排索引） 一些省略的代码可以在练习一中找到。一，单表关联要求：给出child-parent（孩子—父母）表，要求输出grandchild-grandparent（孙子—爷奶）表。Map输出2个表，第一个表key为父母，设一个标识位tag=L，value为tag+孩子+父母，称为左
Hadoop—MapReduce练习（数据去重、数据排序、平均成绩、倒排索引）
热门推荐
Oner.wv的专栏
03-03 1万+
1. wordcount程序 先以简单的wordcount为例。 Mapper： package cn.nuc.hadoop.mapreduce.wordcount; import java.io.IOException; import org.apache.commons.lang.StringUtils; import org.apache.hadoop.io.IntWri...
MapReduce作业之--实现网页排名算法PageRank(1)
笨鸟的专栏
05-03 3702
今天准备写MapReduce的第四个作业，实现pa
Windows下实现MapReduce的程序实例.zip
06-03
MapReduce是一种分布式计算模型，由Google在2004年提出，主要用于处理和生成大规模数据集。这个模型将复杂的计算任务分解为两个...通过实际操作和练习，你将能够更好地理解和应用这些概念，解决复杂的数据处理问题。
MapReduce入门（三）倒排索引
weixin_30856965的博客
10-13 400
什么是倒排索引？ 倒排索引源于实际应用中需要根据属性的值来查找记录。这种索引表中的每一项都包括一个属性值和具有该属性值的各记录的地址。由于不是由记录来确定属性值，而是由属性值来确定记录的位置，因而称为倒排索引(inverted index)。带有倒排索引的文件我们称为倒排索引文件，简称倒排文件(inverted file)。 我感觉搜索引...
Mapreduce实例（六）：倒排索引
笑看风云路的博客
06-01 3044
MR实现倒排索引
MapReduce实现倒排索引
破碎琉璃为哪般
12-03 616
倒排索引这个名字让人很容易误解成A-Z，倒排成Z-A；但实际上缺不是这样的。 一般我们是根据问文件来确定文件内容，而倒排索引是指通过文件内容来得到文档的信息，也就是根据一些单词判断他在哪个文件中。 知道了这一点下面就好做了： 准备一些元数据 下面我们要进行两次MapReduce处理 第一次 package com.invalid; import java.io.IOException; im...
MapReduce练习 - 倒排索引
GYT0313
12-06 360
问题描述 读取多个文件的内容，计算内容在那个文件有出现，并且计算其出现的次数（权重），如下： 已有三个文件，其内容如下： 经过处理，其处理结果如下： 以第一行为例： 表示在file1.txt，file2.txt各包含1个 Hadoop。 准备输入文件： 上传到 hdfs://master:9000/data/indvertedIndex2: 代码思路： 在Mapper端： 根据输入内...
MapReduce课后练习
qq_30136729的博客
12-02 4703
1【单选题】 下列说法错误的是________。 A、Map函数将输入的元素转换成<key,value>形式的键值对 B、Hadoop框架是用Java实现的，MapReduce应用程序则一定要用Java来写 C、不同的Map任务之间不能互相通信 D、MapReduce框架采用了Master/Slave架构，包括一个Master和若干个Slave 2【单选题】 在使用MapReduce程序WordCount进行词频统计时，对于文本行“hello hadoop hello world”，经过Word
mapreduce之倒排索引
a805814077的博客
10-03 808
mapreduce中倒排索引的使用
mapreduce 倒排索引
あずにゃん梓喵的博客
04-30 378
代码下载链接： https://pan.baidu.com/s/1VhxRXB63vz_4QZyKVFqoZQ 提取码：2v0l 1.读取的文件中第一行数据：key=偏移量0。value=第一行内容 2.经过了maptask：key=单词:文件名。value=次数1 3.经过了局部合并combiner：key=单词。value=文件名:次数N 4.每个各自的mapredu...
MapReduce之倒排索引
sjw2020的博客
05-11 214
static { System.setProperty(“hadoop.home.dir”,“E:/x3/hadoop-2.9.2”); } //map public static class MyMapper extends Mapper<LongWritable,Text,Text,Text>{ @Override protected void map(LongWritable key, Text value, Context context) throws IOExcept
使用MapReduce实现TF-IDF算法详细步骤
"案例TF-IDF.pdf是一个关于使用MapReduce实现TF-IDF算法的教程，作者提供了源码供参考。TF-IDF是一种在信息检索和文本挖掘中常用的权重计算方法，用于评估一个词在文档中的重要性。这个案例分为三次MapReduce作业来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值