hadoop倒排索引实验报告
实验倒排索引的构建及向量空间的模型检索
实验倒排索引的构建及向量空间的模型检索下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。
文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢!本店铺为大家提供各种类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!实验倒排索引的构建及向量空间的模型检索一、引言在信息检索领域，倒排索引是一种重要的数据结构，被广泛应用于搜索引擎和文本检索系统中。
Hadoop中的数据索引和查询优化技术解析
Hadoop中的数据索引和查询优化技术解析Hadoop是一种开源的分布式计算框架，被广泛应用于大数据处理和分析。
在Hadoop中，数据索引和查询优化是关键的技术，它们可以提高数据的访问效率和查询性能。
本文将对Hadoop中的数据索引和查询优化技术进行解析。
一、数据索引技术数据索引是一种用于加速数据访问的技术，它通过建立索引结构来提供快速的数据定位和检索能力。
在Hadoop中，常用的数据索引技术包括B树索引、倒排索引和压缩索引。
1. B树索引B树是一种多路平衡查找树，它可以在有序数据上进行高效的查找操作。
在Hadoop中，B树索引常被用于加速数据的范围查询。
通过将数据按照某个属性进行排序，并构建B树索引，可以使得范围查询的性能得到显著提升。
2. 倒排索引倒排索引是一种常用的文本检索技术，它将文档中的每个单词映射到包含该单词的文档列表中。
在Hadoop中，倒排索引常被用于加速文本数据的关键词搜索。
通过构建倒排索引，可以快速定位包含指定关键词的文档。
3. 压缩索引压缩索引是一种将索引数据进行压缩存储的技术，它可以减小索引的存储空间，并提高索引的读取性能。
在Hadoop中，由于数据量庞大，索引的存储和读取成本往往较高。
通过采用压缩索引技术，可以在一定程度上减小存储空间，提高索引的读取效率。
二、查询优化技术查询优化是指通过改变查询的执行方式，使得查询的执行效率得到提升的一种技术。
在Hadoop中，常用的查询优化技术包括查询重写、查询优化器和查询计划生成器。
1. 查询重写查询重写是指对用户提交的查询进行改写，以使得查询的执行效率得到提升。
在Hadoop中，查询重写常用于优化复杂查询和多表关联查询。
通过改变查询的语法结构或者调整查询的执行顺序，可以减少查询的执行时间和资源消耗。
2. 查询优化器查询优化器是一种自动化工具，用于选择最优的查询执行计划。
在Hadoop中，查询优化器可以根据查询的特点和数据的分布情况，选择最适合的查询执行计划。
hadoop分析
1.前言学习hadoop的童鞋，倒排索引这个算法还是挺重要的。
这是以后展开工作的基础。
首先，我们来认识下什么是倒拍索引：倒排索引简单地就是：根据单词，返回它在哪个文件中出现过，而且频率是多少的结果。
这就像百度里的搜索，你输入一个关键字，那么百度引擎就迅速的在它的服务器里找到有该关键字的文件，并根据频率和其他一些策略（如页面点击投票率）等来给你返回结果。
这个过程中，倒排索引就起到很关键的作用。
2.分析设计倒排索引涉及几个过程：Map过程，Combine过程，Reduce过程。
下面我们来分析以上的过程。
2.1Map过程当你把需要处理的文档上传到hdfs时，首先默认的TextInputFormat类对输入的文件进行处理，得到文件中每一行的偏移量和这一行内容的键值对<偏移量，内容>做为map的输入。
在改写map函数的时候，我们就需要考虑，怎么设计key和value的值来适合MapReduce框架，从而得到正确的结果。
由于我们要得到单词,所属的文档URL,词频，而<key,value>只有两个值，那么就必须得合并其中得两个信息了。
这里我们设计key=单词＋URL，value=词频。
即map得输出为<单词＋URL，词频>，之所以将单词＋URL做为key，时利用MapReduce框架自带得Map端进行排序。
下面举个简单得例子：图1 map过程输入／输出2.2 Combine过程combine过程将key值相同得value值累加，得到一个单词在文档上得词频。
但是为了把相同得key交给同一个reduce处理，我们需要设计为key=单词，value＝URL+词频图2 Combin过程输入/输出2.3Reduce过程reduce过程其实就是一个合并的过程了，只需将相同的key值的value值合并成倒排索引需要的格式即可。
图3 reduce过程输入/输出。
Hadoop实现对Value倒序排序
Hadoop实现对Value倒序排序数据源A 2B 9C 4D 9Z 42要实现的输出Z 42D 9B 9C 4A 2看字符顺序，其实什么也没有，只是按照后⾯的数字进⾏⼀次倒序排序，实现思路，1利⽤hadoop⾃带的排序功能，2.KV互换实现代码public class SVJob {public static void main(String[] args) throws IOException,InterruptedException, ClassNotFoundException {Configuration conf = new Configuration();conf.set("mapred.job.tracker", "192.168.9.181:9001");String[] ars = new String[] {"hdfs://192.168.9.181:9000/user/hadoop/input/examples/SortByValue/","hdfs://192.168.9.181:9000/user/hadoop/output/examples/SortByValue" };String[] otherArgs = new GenericOptionsParser(conf, ars).getRemainingArgs();if (otherArgs.length != 2) {System.err.println("SortByValue: <in> <out>");System.exit(2);}Job job = new Job(conf, "SortByValue");job.setJarByClass(SVJob.class);job.setMapperClass(SVMapper.class);job.setReducerClass(SVReducer.class);job.setMapOutputKeyClass(IntWritable.class);job.setMapOutputValueClass(Text.class);job.setOutputKeyClass(Text.class);job.setOutputValueClass(IntWritable.class);job.setSortComparatorClass(IntWritableDecreasingComparator.class);FileInputFormat.addInputPath(job, new Path(otherArgs[0]));FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));System.exit(job.waitForCompletion(true) ? 0 : 1);}}public class SVMapper extends Mapper<Object, Text, IntWritable, Text> {protected void map(Object key, Text value, Context context)throws IOException, InterruptedException {String line = value.toString();String[] keyValueStrings = line.split("\t");if(keyValueStrings.length != 2){//新⼿，不知道怎么记录⽇志，也不清楚怎么退出各位⼤神如果知道请通知我，谢谢System.err.println("string format error");return;}int outkey = Integer.parseInt(keyValueStrings[1]);String outvalue = keyValueStrings[0];context.write(new IntWritable(outkey), new Text(outvalue));}}public class SVReducer extends Reducer<IntWritable, Text, Text, IntWritable> {protected void reduce(IntWritable key, Iterable<Text> values,Context context)throws IOException, InterruptedException {for(Text value : values){context.write(value, key);}}}因为我们要实现倒序排序要有⾃定义的排序⽅法public class IntWritableDecreasingComparator extends Comparator { @SuppressWarnings("rawtypes")public int compare( WritableComparable a,WritableComparable b){ return pare(a, b);}public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) { return pare(b1, s1, l1, b2, s2, l2);}}这样就完成了，可以⾃定义排序了。
hadoop倒排索引实验报告
大数据技术概论实验报告作业三姓名：郭利强专业：工程管理专业学号： 2015E8009064028目录1.实验要求 (3)2.环境说明 (4)2.1系统硬件 (4)2.2系统软件 (4)2.3集群配置 (4)3.实验设计 (4)3.1第一部分设计 (4)3.2第二部分设计 (6)4.程序代码 (11)4.1第一部分代码 (11)4.2第二部分代码 (17)5.实验输入和结果 (21)实验输入输出结果见压缩包中对应目录 (21)1.实验要求第一部分：采用辅助排序的设计方法，对于输入的N个IP网络流量文件，计算得到文件中的各个源IP地址连接的不同目的IP地址个数，即对各个源IP地址连接的目的IP地址去重并计数举例如下：第二部分：输入N个文件，生成带详细信息的倒排索引举例如下，有4个输入文件：– d1.txt: cat dog cat fox– d2.txt: cat bear cat cat fox– d3.txt: fox wolf dog– d4.txt: wolf hen rabbit cat sheep要求建立如下格式的倒排索引：– cat —>3: 4: {(d1.txt,2,4),(d2.txt,3,5),(d4.txt,1,5)}–单词—>出现该单词的文件个数:总文件个数： {(出现该单词的文件名，单词在该文件中的出现次数，该文件的总单词数),……}2.环境说明2.1系统硬件处理器：Intel Core i3-2350M CPU@2.3GHz×4 内存：2GB磁盘：60GB2.2系统软件操作系统：Ubuntu 14.04 LTS操作系统类型：32位Java版本：1.7.0_85Eclipse版本：3.8Hadoop插件：hadoop-eclipse-plugin-2.6.0.jar Hadoop：2.6.12.3集群配置集群配置为伪分布模式，节点数量一个3.实验设计3.1第一部分设计利用两个Map/Reduce过程，在第一个MR中，读取记录并去除重复记录，第二个MR按照辅助排序设计方法，根据源地址进行分组，统计目的地址数量。
Mapreduce实例——倒排索引
Mapreduce实例——倒排索引实验⽬的1.了解倒排索引的使⽤场景2.准确理解倒排索引的设计原理3.熟练掌握MapReduce倒排索引程序代码编写实验原理"倒排索引"是⽂档检索系统中最常⽤的数据结构，被⼴泛地应⽤于全⽂搜索引擎。
它主要是⽤来存储某个单词（或词组）在⼀个⽂档或⼀组⽂档中的存储位置的映射，即提供了⼀种根据内容来查找⽂档的⽅式。
由于不是根据⽂档来确定⽂档所包含的内容，⽽是进⾏相反的操作，因⽽称为倒排索引（Inverted Index）。
实现"倒排索引"主要关注的信息为：单词、⽂档URL及词频。
下⾯以本实验goods3、goods_visit3、order_items3三张表的数据为例，根据MapReduce的处理过程给出倒排索引的设计思路：（1）Map过程⾸先使⽤默认的TextInputFormat类对输⼊⽂件进⾏处理，得到⽂本中每⾏的偏移量及其内容。
显然，Map过程⾸先必须分析输⼊的<key,value>对，得到倒排索引中需要的三个信息：单词、⽂档URL和词频，接着我们对读⼊的数据利⽤Map操作进⾏预处理，如下图所⽰：这⾥存在两个问题：第⼀，<key,value>对只能有两个值，在不使⽤Hadoop⾃定义数据类型的情况下，需要根据情况将其中两个值合并成⼀个值，作为key或value值。
第⼆，通过⼀个Reduce过程⽆法同时完成词频统计和⽣成⽂档列表，所以必须增加⼀个Combine过程完成词频统计。
这⾥将商品ID和URL组成key值（如"1024600：goods3"），将词频（商品ID出现次数）作为value，这样做的好处是可以利⽤MapReduce 框架⾃带的Map端排序，将同⼀⽂档的相同单词的词频组成列表，传递给Combine过程，实现类似于WordCount的功能。
（2）Combine过程经过map⽅法处理后，Combine过程将key值相同的value值累加，得到⼀个单词在⽂档中的词频，如下图所⽰。
文华学院hadoop系统应用实训报告
文华学院hadoop系统应用实训报告1.前言通过基于MapReduce云计算平台的海量数据处理实验，我们了解了Hadoop的基本架构，已经如何编写MapReduce程序，本实验中我主要使用到的两个程序分别是WordCount（词频统计）和InvertedIndex（反向索引）。
在将这两个程序之前，我会介绍我对Hadoop的理解。
2.Hadoop简介及特性2.1.Hadoop分布式文件系统（HDFS）Hadoop分布式文件系统(HDFS)被设计成适合运行在通用硬件(commodity hardware)上的分布式文件系统。
它和现有的分布式文件系统有很多共同点。
但同时，它和其他的分布式文件系统的区别也是很明显的。
HDFS是一个高度容错性的系统，适合部署在廉价的机器上。
HDFS能提供高吞吐量的数据访问，非常适合大规模数据集上的应用。
HDFS放宽了一部分POSIX约束，来实现流式读取文件系统数据的目的。
2.2.简单的一致性模型HDFS应用需要一个“一次写入多次读取”的文件访问模型。
一个文件经过创建、写入和关闭之后就不需要改变。
这一假设简化了数据一致性问题，并且使高吞吐量的数据访问成为可能。
Map/Reduce 应用或者网络爬虫应用都非常适合这个模型。
目前还有计划在将来扩充这个模型，使之支持文件的附加写操作。
2.3.“移动计算比移动数据更划算”一个应用请求的计算，离它操作的数据越近就越高效，在数据达到海量级别的时候更是如此。
因为这样就能降低网络阻塞的影响，提高系统数据的吞吐量。
将计算移动到数据附近，比之将数据移动到应用所在显然更好。
HDFS为应用提供了将它们自己移动到数据附近的接口。
2.4.数据复制HDFS被设计成能够在一个大集群中跨机器可靠地存储超大文件。
它将每个文件存储成一系列的数据块，除了最后一个，所有的数据块都是同样大小的。
为了容错，文件的所有数据块都会有副本。
每个文件的数据块大小和副本系数都是可配置的。
实操18-MapReduce操作实例-倒排索引
private static Text keyinfo = new Text(); private static final Text valueinfo = new Text("1"); @Override /**
//获取单词 key.set(key.toString().substring(0, indexOf));
//写入上下文中 context.write(key, info);
}
} 3. 创建 Reducer 类 package com.itcast.mr.InvertedIndex;
import java.io.IOException;
//设置 job 对象 job.setJarByClass(InvertedIndexDriver.class); job.setMapperClass(InvertedIndexMapper.class);
job.setCombinerClass(InvertedIndexCombiner.class); job.setReducerClass(InvertedIndexReducer.class);
public class InvertedIndexDriver {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
//获取 job 对象 Configuration conf = new Configuration(); Job job = Job.getInstance(conf);
Hadoop报告
2.2 MapReduce 并行程序设计
MapReduce 整体工作原理如下：首先， client 发起任务请求，接着 server 会 fork 一些进程，包括一个 master 和一些 map worker，以及一些 reduce worker。其 中 master 中包含 job tracker，用来进行任务分发与监控，而且每个 worker 里面包 含 task tracker。然后，job tracker 把数据处理任务分发给各个 map，每个 map 都分 到一些数据集，一个子数据集只能由一个 map 来处理。其中，map 处理完结果是 存放在内存里的，这里会进行 partition，将数据结果拆分成与 reduce 等量的任务。 如果有 N 个 map，M 个 reduce，那么 partition 就会将 map 结果拆分成 M 份。当一 个 map 节点内存快满的时候，进行 spill 把数据导入本地磁盘，这个时候进行简单 的分类与化简，也即 sort 和 combiner。而 reduce 端则从各个 map 的磁盘中获取自 己所属的 partition，将数据进行分类与合并，然后进行 reduce 的操作，完成分布式 处理。
的文档和重复的次数，并将结果输出。
1.3 设计思路
首先搭建 Hadoop 分布式集群环境，配置 Hadoop 环境，安装 JDK 配置 JAVA 环境，安装 Eclipse，配置 Eclipse 并导入 Hadoop-eclipse jar 包，编写 Map/Reduce 程序。
1
பைடு நூலகம் 电子科技大学成都学院实践专周设计报告
项目4 MapReduce分布式计算框架-任务4.5 MapReduce经典案例—倒排索引
章节概要
MapReduce是Hadoop系统核心组件之一，它是一种可用于大数据并行处理的计算模型、 框架和平台，主要解决海量数据的计算，是目前分布式计算模型中应用较为广泛的一种。
本章通过对MapReduce原理、编程模型及案例进行深入讲 解。
CONTENTS
PART 01
案例分析
PART 02
案例实现
is
file1.txt:1;file2.txt:2
simple
file1.txt:1;file2.txt:1
powerful file2.txt:1
bye
file3.txt:1
Hello
file3.txt:1
Title Works About Help
案例分析
2. 案例需求及分析
首先，使用默认的TextInputFormat类对每个输入文件进行处理，得到文本 中每行的偏移量及其内容。Map过程首先分析输入的<key，value>键值对，经 过处理可以得到倒排索引中需要的三个信息：单词、文档名称和词频。
BITC
项目4 MapReduce分布式计算框架
任务4.5 NE
理解MapReduce的 核心思想
学习目标
THREE
了解MapReduce的 优化策略
TWO
掌握MapReduce的编程 模型和工作原理
FOUR
掌握MapReduce常见 编程组件的使用
Title Works About Help
Title Works About Help
案例实现
3. Reduce阶段实现
根据Combine阶段的输出结果形式，同样在cn.itcast.mr.InvertedIndex 包 下 ， 自 定 义 Reducer 类 InvertedIndexMapper ， 主 要 用 于 接 收 Combine 阶 段输出的数据，并最终案例倒排索引文件需求的样式，将单词作为key，多个
大数据倒排序实验报告(3篇)
第1篇一、实验目的1. 了解倒排序算法的基本原理和操作步骤。
2. 掌握在Hadoop平台上实现倒排序算法的方法。
3. 分析倒排序算法在处理大规模数据集时的性能表现。
二、实验环境1. 操作系统：Ubuntu 18.042. Hadoop版本：Hadoop3.3.13. 编程语言：Java三、实验内容本实验旨在实现一个基于Hadoop的倒排序算法，以处理大规模数据集。
倒排序算法的基本思想是将数据集中的元素按照逆序排列。
1. 实验步骤（1）创建Hadoop项目（2）编写MapReduce程序，包括Map阶段和Reduce阶段（3）在Hadoop集群上运行倒排序程序（4）分析倒排序算法的性能表现2. Map阶段在Map阶段，输入数据被分割成多个小文件，每个小文件包含一部分数据。
Map任务负责读取每个小文件，并对数据进行逆序排序，然后将结果输出到Reduce任务。
3. Shuffle阶段Shuffle阶段负责将Map任务输出的中间结果按照键（key）进行分组，并将具有相同键的数据发送到对应的Reduce任务。
4. Reduce阶段在Reduce阶段，Reduce任务接收来自Shuffle阶段的中间结果，对具有相同键的数据进行逆序排序，并将最终结果输出到HDFS。
四、实验结果与分析1. 数据集本实验使用的数据集包含1000万条记录，每条记录包含一个整数键和一个字符串值。
2. 性能表现（1）处理时间在Hadoop集群上运行倒排序程序，处理1000万条记录所需的时间约为1小时。
（2）资源消耗在实验过程中，Hadoop集群的CPU和内存资源消耗相对较低。
3. 结果分析（1）倒排序算法在处理大规模数据集时表现出良好的性能。
（2）倒排序算法在MapReduce框架下具有较高的可扩展性。
（3）倒排序算法在处理具有相同键的数据时，可以有效地进行逆序排序。
五、实验结论1. 倒排序算法在处理大规模数据集时具有较高的性能和可扩展性。
hadoop实验报告
hadoop实验报告1. 引言随着互联网的快速发展和大数据时代的到来，传统的数据处理方法已经无法满足海量数据的处理需求。
在这个背景下，分布式存储和计算框架Hadoop应运而生。
本篇文章将从搭建集群环境、数据导入、任务执行和性能评估等方面进行Hadoop实验的报告。
2. 搭建集群环境在实验开始之前，我们需要搭建一个Hadoop集群环境。
首先，我们需要准备一台主节点和若干台从节点。
主节点将负责整个集群的协调工作，从节点将执行具体的任务。
通过配置和启动Hadoop的各个组件，我们可以实现数据的并行计算和故障容错。
为了确保集群的高可用性和性能，我们还可以使用Hadoop的分布式文件系统HDFS来存储数据。
3. 数据导入数据的导入是Hadoop实验的第一步。
在本次实验中，我们选择了一份包含大量文本数据的文件作为输入。
通过Hadoop提供的命令行工具，我们可以将数据导入到HDFS中进行后续的处理。
不同的数据导入方式可以根据实际需求选择，一般包括本地文件上传、网络数据传输等。
4. 任务执行在集群环境搭建完成并将数据导入到HDFS之后，我们可以开始执行具体的计算任务。
Hadoop支持两种模型：MapReduce和Spark。
MapReduce是Hadoop最早的计算模型，其核心思想是将大规模的数据集划分成许多小的数据块，由多个Mapper和Reducer并行地执行计算任务。
而Spark则是一种更加灵活和高效的计算模型，它将数据集以弹性分布式数据集（RDD）的形式存储在内存中，通过多次迭代快速进行计算。
5. 性能评估对于一个分布式计算框架来说，性能评估是非常重要的。
通过对Hadoop实验中的任务执行时间、计算效率和数据处理能力等指标的测量，我们可以评估集群的性能瓶颈并寻找优化的方法。
常见的性能评估指标包括吞吐量、数据处理速度和并发处理能力等。
6. 结果与讨论在本次实验中，我们成功搭建了一个Hadoop集群环境，并将大量的文本数据导入到HDFS中。
软件综合实习-倒排文档实验报告
倒排文档实验报告1.实验题目建立倒排索引的过程，统计一下词的分布情况。
2.需求分析本程序将文件中的单词作为关键字，然后建立单词与文件的映射关系，同时还需要记录文件中单词出现的频数等信息。
①输入的形式和输入值的范围:第一行输入要查询的单词，第二行文本的总行数，第三行频次排名，剩下的为文本(每个单词之间用空格隔开)②输出的形式:第一行输出该词所在的行数序号（多个的话，按照从小到大排序输出，中间空格隔开，序号从一开始记），如果没有出现，输出 -1，第二行输出频次排名R的单词出现的次数。
③程序能实现的功能:对输入的文本进行倒排索引，排列出每个单词出现的频率和出现的行数，最后输出查询单词的行数序号和频次排名R出现的次数。
3.概要设计(1)为了实现上述程序功能，定义一个数组的结构体struct shu{char L[50];int hshu;};(2)本函数包括三个函数①主函数main( )②对单词的索引循环函数for循环函数③对频次的大小排列的函数temp( )4.详细设计部分重要伪码算法BSBI NDEXConSTRUCTION()n <- 0while(all documents have not been processed)do n<-n+1block <- PARSENEXTBLOCK() //文档分析BSBI-INVERT(block)WRITEBLOCKTODISK(block,fn)MERGEBLOCKS(f1,...,fn;fmerged)1）主函数的设计：int main(){struct shu{char L[50];int hshu;};int k[10];char str;int row,f;printf("请输入要查询的单词：");scanf("%c",&str);printf("输入行数：");scanf("%d",&row);printf("输入频率:");scanf("%d",&f);shu a[20];int i,j;getchar();2)利用循环语句对查询的单词进行倒排索引，列出单词的频次排名，并从大到小排列：for(i=0;i<30;i++)time[i]=1;for(i=1;i<=row;i++)for(j=0;a[i].L[j]!='\0';j++){c=a[i].L[j];if(str==c){printf("%d ",i);}if(c>='a'&&c<='z'||c>='A'&&c<='Z'){ch[w++]=c;}else{if((a[i].L[j-1]>='a'&&a[i].L[j-1]<='z')||(a[i].L[j-1]>='A'&&a[i].L[j-1]<='Z ')){ch[w]='\0';strcpy(b[n++],ch);w=0;if(n>=1){for(t=0;t<n-1;t++)if(!strcmp(b[n-1],b[t])){time[t]++;n--;break;}}}}}3)对查询的单词出现的行数进行大小排列：int temp;for(j=0;j<n-1;j++){for(i=0;i<n-1-j;i++){if(time[i+1]>time[i]){temp=time[i];time[i]=time[i+1];time[i+1]=temp;}}}printf("\n");5．调试分析(略)6．使用说明程序名为experiment2.exe，运行环境为vc6等。
hadoop 实验报告
hadoop 实验报告Hadoop 实验报告Hadoop 是一个开源的分布式计算框架，能够高效地处理大规模数据集。
本次实验旨在通过搭建 Hadoop 环境，并运行一些简单的任务，来探索 Hadoop 的特性和功能。
一、Hadoop 环境搭建为了搭建 Hadoop 环境，我们需要准备一台运行 Linux 操作系统的计算机，并安装 Java 开发环境。
接下来，我们下载 Hadoop 的二进制文件，并解压到指定的目录。
然后，我们需要对 Hadoop 进行一些配置，如指定数据存储路径、设置集群节点等。
最后，我们启动 Hadoop，验证环境是否搭建成功。
二、Hadoop 的基本概念在开始运行任务之前，我们需要了解一些 Hadoop 的基本概念。
首先是Hadoop 的核心组件，包括 Hadoop 分布式文件系统（HDFS）和 Hadoop 资源调度器（YARN）。
HDFS 负责将数据分布式存储在集群中的各个节点上，而YARN 则负责管理集群资源和任务调度。
另外，Hadoop 还提供了一个用于编写和运行分布式计算任务的编程模型，即 MapReduce。
三、运行 MapReduce 任务为了熟悉 Hadoop 的编程模型，我们编写了一个简单的 MapReduce 任务。
该任务的目标是统计一篇文档中各个单词的出现次数。
在编写任务之前，我们需要先将文档拆分成多个小块，并将这些小块分发到集群中的各个节点上。
然后，我们定义 Map 函数和 Reduce 函数，分别用于处理每个小块的数据和最终的汇总。
最后，我们运行任务，并查看结果。
四、Hadoop 的优势和应用场景Hadoop 的优势主要体现在处理大规模数据集时的高效性和可靠性。
由于数据被分布式存储和处理，Hadoop 能够充分利用集群中的各个节点，实现高并发和高吞吐量。
此外，Hadoop 还具有容错性，即使某个节点出现故障，任务仍然可以继续执行。
因此，Hadoop 在大数据分析、机器学习和日志处理等领域得到了广泛的应用。
倒排索引实验报告
一、实验目的1. 理解倒排索引的概念和原理。
2. 学习倒排索引的构建方法。
3. 评估倒排索引在信息检索中的应用性能。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 数据集：某中文文本数据集，包含10万篇文档，约5GB。
三、实验步骤1. 数据预处理（1）读取数据集：从本地文件系统读取文本数据集，存储为Python列表。
（2）分词处理：使用jieba分词库对文本进行分词，得到分词后的列表。
（3）去除停用词：从分词后的列表中去除停用词，如“的”、“了”、“在”等。
2. 倒排索引构建（1）初始化倒排索引：创建一个空字典，用于存储倒排索引。
（2）遍历文档：遍历数据集中的每篇文档，对每篇文档进行以下操作：a. 遍历分词后的列表，获取每个词；b. 对于每个词，在倒排索引字典中查找该词是否已存在；c. 如果存在，将该词对应的文档ID加入列表；d. 如果不存在，创建一个新的键值对，键为该词，值为一个空列表，然后将文档ID加入列表。
（3）输出倒排索引：将构建好的倒排索引输出到文件中，以便后续检索使用。
3. 检索性能评估（1）查询语句：编写查询语句，如“信息检索”。
（2）检索过程：根据查询语句，在倒排索引中查找相关词，获取对应的文档ID列表。
（3）检索结果：对检索到的文档进行排序，并输出前10个文档。
（4）性能评估：统计检索过程中的时间消耗，包括构建倒排索引的时间和检索查询的时间。
四、实验结果与分析1. 倒排索引构建时间：约5分钟。
2. 检索查询时间：约0.5秒。
3. 检索准确率：约80%。
4. 实验结果分析：（1）倒排索引构建时间较短，说明构建过程较为高效。
（2）检索查询时间较短，说明倒排索引在检索过程中具有较好的性能。
（3）检索准确率较高，说明倒排索引在信息检索中具有较好的效果。
五、实验总结1. 通过本次实验，深入理解了倒排索引的概念和原理。
2. 掌握了倒排索引的构建方法，并成功构建了一个包含10万篇文档的倒排索引。
mapreduce倒排索引算法
Mapreduce程序设计报告姓名：学号：题目：莎士比亚文集倒排索引算法1、实验环境联想pc机虚拟机：VM 10.0操作系统：Centos 6.4Hadoop版本：hadoop 1.2.1Jdk版本：jdk-7u25Eclipse版本：eclipse-SDK-4.2.2-linux-gtk-x86_642、实验设计及源程序2.1实验说明对莎士比亚文集文档数据进行处理，对莎士比亚文集文档数据进行倒排索引处理，结果输出到指定文件2.2实验设计（1）InvertedIndexMapper类这个类实现Mapper 接口中的map 方法，输入参数中的value 是文本文件中的一行，利用正则表达式对数据进行处理，使文本中的非字母和数字符号转换成空格，然后利用StringTokenizer 将这个字符串拆成单词，最后将输出结果,outkey为单词+单词所在的文件名，outvalue为1。
public static class InvertedIndexMapperextends Mapper<Object, Text, Text, IntWritable>{private final static IntWritable one = new IntWritable(1);public void map(Object key, Text value, Context context) throws IOException, InterruptedException {//获取文件名以及预处理F ileSplit filesplit =(FileSplit)context.getInputSplit();S tring filename =filesplit.getPath().getName();String line=value.toString();String s;//利用正则表达式除去非数字和字母的符号Pattern p =pile("[^\\w+]");Matcher m=p.matcher(line);S tring line2=m.replaceAll(" ");S tringTokenizer itr = new StringTokenizer(line2); //按照空格对字符串进行划分while (itr.hasMoreTokens()) {s=itr.nextToken().toLowerCase();if(!ls.contains(s)){Text filename_num=new Text(s+","+filename);//将单词和单词所在的文件名进行合并context.write(filename_num, one);}}}} (2)InvertedIndexPartitioner类这个类是自定义的Partitioner类,通过复写getPartition() 方法来自定义子集的分区key。
【大数据实验】使用hadoop实现倒排索引
【⼤数据实验】使⽤hadoop实现倒排索引零碎记事 ⾃上次写博客，已经过了半年了。
这半年时间⾥，我退出了ACM，转⼊了计算机视觉的研究中，ACM的价值观与⾃⼰的价值观还是有所不符，感觉⾃⼰并不是那么适合⼀条路⾛到⿊的竞赛，被束缚住了，还是诗与歌的⽣活更适合⾃⼰，能⼒低点⼜何妨，还是⽣活重要，所以转向压⼒稍低点(?)的科研项⽬⾥。
退出ACM后，也停⽌了刷OJ题，以写题解为主的博客，理所当然地失去了写作源泉，⼀停，就是半年。
说起来，当初转⼊计算机视觉研究的时候，还想着以后博客更新与这个领域相关的东西呢，可惜⾄今为⽌并没学到多少东西，仍然属于半吊⼦状态，实在是没内容拿得出⼿。
那，为什么现在⼜更博客了呢？看标题，还是⼤数据领域的。
这要跟本⼈⽬前就读的⼤数据专业说起，这个专业是学校新开的，⽽我们⼜是其第⼀届学⽣，学校对课程难度拿捏不太准，于是⾃开学后，发⽣了⼀系列离谱的事情，这⾥不吐不快。
开学后，第⼀件事是考上学期遗留下来必须得线下考的试，我们专业在这场考试中，挂掉了60%以上的⼈。
这只是个开端，之后学校排错了课程。
⼤数据的实验课，需要java和Linux作为前置课程，⽽这两个课程⼜是我们这个学期的⼆选⼀选修课（没错，java跟Linux，本来我们这学期只学其中⼀个，个⼈也很疑惑java为什么会是选修。
），怎么考虑本都是下学期才上的，但是不知怎么的排到了这个学期。
然后教务处还发现java跟Linux是选修，就在第⼆周把这两门课紧急调整成了必修，课表课程喜加⼆(⼤数据实验 + 原本没选的java或Linux两者其⼀)，于是这个学期12门课程，加上⼀个数据结构课设，做个游戏出来的那种。
学校也是很厉害，这么多个课，居然也不冲突，可能我们专业就两个班，专业课都是两个班⼀起上，⼀个教室就能装得下，课表哪有空直接把课放哪就⾏了，好排。
冲突是不冲突了，反⼈类的安排⾃然还是有的，就拿Java说事，Java有实验课，上这个实验课我们得跨校区去上，⼀般来讲，如果有两节连上的情况，那应该是放在同⼀个时间段⽐较合适，不⽤跑来跑去嘛。
大数据Hadoop入门第十九讲 案例：倒排索引
倒排索引概述
一般正常的索引是根据记录来确定属性值的方式，但是在实际的应用中，常 常有需要根据属性值确定记录的情况，这种情况下，一般普通的索引方式无法 进行，这个时候就需要引入倒排索引(inverted index)。直白来讲倒排索引就 是根据值查询记录的索引方式。
倒排索引--图
案例
使用MR任务构建一个根据文档中的单词映射文档uri地址的倒排索引，创建 要求如下所示：
1. 各个文件需要根据指定的关键词创建倒排索引 2. 去掉文件中特殊字符(!,.)和黑名单字符(其他文件指定)（涉及到 ChainMapper和map side join） 3. 计算关键词在文档中出现次数，最终结果按照次数从高到低进行排序；格 式为keyword -> file1,file2,file3(依赖关系组合MR任务解决该要求)
Hadoop倒排索引例子
package cn.yws;
for(Text value:values)
{
sum+=Integer.parseInt(value.toString());
}
int splitindex=key.toString().indexOf(":");
//file2:1;file3:2;file1:1
infoText.set(key.toString().substring(splitindex+1)+":"+sum);
protected void reduce(Text key, Iterable<Text> values,
Context context)
throws IOException, InterruptedException {
//super.reduce(key, values, context);
int sum=0;
//合成
job.setCombinerClass(Combine.class);
//规约
job.setReducerClass(Reduce.class);
//设置映射Map输出类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
信息检索与搜索引擎技术_实验3 倒排索引、正排索引
XXXX大学信息工程与自动化学院学生实验报告课程名称：信息检索与搜索引擎技术一、上机目的及内容1.上机目的熟悉索引的作用和重要性；熟悉正排索引和倒排索引及其建立；2.上机内容对 Doc1:清华/大学/清华/主页 Doc2:世纪/清华 Doc3:北京/大学建立正排索引和倒排索引二、实验环境Windows操作系统 PC机一台，MyEclipse三、实验原理将词项集合建立成为倒排索引的过程分为两个步骤:首先要将文本词项集合处理成正排索引,在建立正排索引的时候把词项列表的结构建立起来;然后再有正排索引建立成倒排索引.正排索引的建立方法:1.顺序扫描集合中的词项.2.当遇到在文档中第一次出现的词项时,要更新词项表,如果词项列表中已近含有这个词,则把改词的DF加1,否则添加这个词项,置DF为1.3.然后处理词项,生成词项的出现记录信息,插入到对应词项的Hit List中。
正排索引建立完成之后，依照索引中的WordID 为单位，将DocID进行填充，然后按照WordID对所有单位进行从小到大的排序，就可以得到基本的倒排索引。
要得到由WordID为键值的索引项，只需要再将WordID和DocID的存贮位置互换，并按照WordID进行归并即可。
最后再将词项列表中的Pointer指针置为指向对应词项的索引项存储地址。
这样得到的索引就可以用来进行检索了。
四、实验记录package com.liu.suoyin;import java.util.*;public class Suoyin {public static void main(String[] args) {Zhengpai zp=suoyin();daopai(zp);}public static Zhengpai suoyin(){String[][] doc ={{"清华","大学","清华","主页"},{"世纪","清华"},{"北京","大学"}};List<Cixiang> cixiang=new ArrayList<Cixiang>();List<Jilu> jilu=new ArrayList<Jilu>();for(int i=0;i<doc.length;i++)for(int j=0;j<doc[i].length;j++){if(cixiang.size()==0){Cixiang ci=new Cixiang();ci.worldID=0;ci.term=doc[i][j];ci.DF=1;ci.doc=i;cixiang.add(ci);Jilu jl=new Jilu();jl.docID=i;jl.wordID=0;jl.NoOfHit=1;jl.HitLise.add(j);jilu.add(jl);}else{int k;for(k=0;k<cixiang.size();k++){Cixiang ci=(Cixiang)cixiang.get(k);if(ci.term.equals(doc[i][j])){if(ci.doc!=i)ci.DF++;cixiang.set(k,ci);int m;for( m=jilu.size()-1;m>-1;m--){if(ci.doc==jilu.get(jilu.size()-1).docID && ci.worldID==jilu.get(m).wordID){Jilu jl=jilu.get(m);jl.HitLise.add(j);jl.NoOfHit++;jilu.set(m,jl);break;}if(m==0){Jilu jl=new Jilu();jl.docID=i;jl.wordID=ci.worldID;jl.NoOfHit=1;jl.HitLise.add(j);jilu.add(jl);}}break;}}if(k==(cixiang.size())){Cixiang ci=new Cixiang();ci.worldID=cixiang.size();ci.term=doc[i][j];ci.DF=1;cixiang.add(ci);Jilu jl=new Jilu();jl.docID=i;jl.wordID=ci.worldID;jl.NoOfHit=1;jl.HitLise.add(j);jilu.add(jl);}}System.out.println("worldID Term DF");for(int l=0;l<cixiang.size();l++){System.out.print(((Cixiang)cixiang.get(l)).worldID+"\t");System.out.print(((Cixiang)cixiang.get(l)).term+"\t");System.out.println(((Cixiang)cixiang.get(l)).DF);}System.out.println();System.out.println("DocID WorldID No.ofHit Hitlist");for(int l=0;l<jilu.size();l++){System.out.print("doc"+(1+((Jilu)jilu.get(l)).docID)+"\t");System.out.print(((Jilu)jilu.get(l)).wordID+"\t");System.out.print(((Jilu)jilu.get(l)).NoOfHit+"\t ");for(int m=0;m<((Jilu)jilu.get(l)).HitLise.size();m++)System.out.print( (int)((Jilu)jilu.get(l)).HitLise.get(m)+" ");System.out.println();}Zhengpai zhengpai=new Zhengpai();zhengpai.cixiang=cixiang;zhengpai.jilu=jilu;return zhengpai;}public static void daopai(Zhengpai zp){List<Cixiang> cixiang=new ArrayList<Cixiang>();List<Jilu> jilu=new ArrayList<Jilu>();for(int i=0;i<zp.cixiang.size();i++){Cixiang ci=zp.cixiang.get(i);for(int j=0;j<zp.jilu.size();j++){if(i==zp.jilu.get(j).wordID){jilu.add(zp.jilu.get(j));}}cixiang.add(ci);}for(int i=0;i<cixiang.size();i++){int k=0;for(int j=0;j<jilu.size();j++){if(i==jilu.get(j).wordID){if(cixiang.get(i).pointer[0]==-1){cixiang.get(i).pointer[0]=j;}k=j;}cixiang.get(i).pointer[1]=k;}System.out.println();System.out.println("worldID Term DF pointer");for(int l=0;l<cixiang.size();l++){System.out.print(((Cixiang)cixiang.get(l)).worldID+"\t");System.out.print(((Cixiang)cixiang.get(l)).term+"\t");System.out.print(((Cixiang)cixiang.get(l)).DF+" ");System.out.println(((Cixiang)cixiang.get(l)).pointer[0]+","+((Cixiang)cixiang.get(l)).pointer[1]);}System.out.println("\nWorldID DocID No.ofHit Hitlist");for(int l=0;l<jilu.size();l++){System.out.print(((Jilu)jilu.get(l)).wordID+"\t");System.out.print("doc"+(1+((Jilu)jilu.get(l)).docID)+"\t");System.out.print(((Jilu)jilu.get(l)).NoOfHit+"\t ");for(int m=0;m<((Jilu)jilu.get(l)).HitLise.size();m++)System.out.print( (int)((Jilu)jilu.get(l)).HitLise.get(m)+" ");System.out.println();}}}class Cixiang{int worldID;String term;int DF;int doc;int[] pointer={-1,-1};}class Zhengpai{List<Cixiang> cixiang=new ArrayList<Cixiang>();List<Jilu> jilu=new ArrayList<Jilu>();}class Jilu{int docID;int wordID;int NoOfHit;List<Integer> HitLise=new ArrayList<Integer>();}运行结果：a.正排索引b.倒排索引四、实验总结倒排索引源于实际应用中需要根据属性的值来查找记录。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
大数据技术概论实验报告作业三姓名：郭利强专业：工程管理专业学号： 2015E8009064028目录1.实验要求 (3)2.环境说明 (4)2.1系统硬件 (4)2.2系统软件 (4)2.3集群配置 (4)3.实验设计 (4)3.1第一部分设计 (4)3.2第二部分设计 (6)4.程序代码 (11)4.1第一部分代码 (11)4.2第二部分代码 (17)5.实验输入和结果 (21)实验输入输出结果见压缩包中对应目录 (21)1.实验要求第一部分：采用辅助排序的设计方法，对于输入的N个IP网络流量文件，计算得到文件中的各个源IP地址连接的不同目的IP地址个数，即对各个源IP地址连接的目的IP地址去重并计数举例如下：第二部分：输入N个文件，生成带详细信息的倒排索引举例如下，有4个输入文件：– d1.txt: cat dog cat fox– d2.txt: cat bear cat cat fox– d3.txt: fox wolf dog– d4.txt: wolf hen rabbit cat sheep要求建立如下格式的倒排索引：– cat —>3: 4: {(d1.txt,2,4),(d2.txt,3,5),(d4.txt,1,5)}–单词—>出现该单词的文件个数:总文件个数： {(出现该单词的文件名，单词在该文件中的出现次数，该文件的总单词数),……}2.环境说明2.1系统硬件处理器：Intel Core i3-2350M CPU@2.3GHz×4 内存：2GB磁盘：60GB2.2系统软件操作系统：Ubuntu 14.04 LTS操作系统类型：32位Java版本：1.7.0_85Eclipse版本：3.8Hadoop插件：hadoop-eclipse-plugin-2.6.0.jar Hadoop：2.6.12.3集群配置集群配置为伪分布模式，节点数量一个3.实验设计3.1第一部分设计利用两个Map/Reduce过程，在第一个MR中，读取记录并去除重复记录，第二个MR按照辅助排序设计方法，根据源地址进行分组，统计目的地址数量。
第一个MR设计：自定义StringPair{源地址，目的地址}类型，实现WritableComparable，在map过程读取文件，输出<StringPair,NullWritable>,reduce过程去除重复记录输出<StringPair.toString, NullWritable >。
在第二个MR设计：1.在Map过程读取第一个MR的输出，对value值进行拆分，并以拆分得到的源地址和目的地址初始化StringPair对象作为输出键，输出值为1。
public void map(Object key, Text value, Context context)throws IOException, InterruptedException {String[] records = value.toString().split("\t");String sourceip = records[0];String desip=records[1];context.write(new StringPair(sourceip,desip),one);}2.定义GroupComparator类，继承WritableComparator类，并重载compare方法，对Map过程输出按照StringPair.first排序，完成按照源地址分组。
public static class GroupComparator extends WritableComparator {protected GroupComparator() {super(StringPair.class, true);}@Overridepublic int compare(WritableComparable w1,WritableComparable w2) {StringPair ip1=(StringPair)w1;StringPair ip2=(StringPair)w2;return ip1.getFirst().compareTo(ip2.getFirst());}}3.在Reduce过程统计分组中的所有值，得到源地址连接不同目的地址数量。
public void reduce( StringPair key, Iterable<IntWritable> values, Context context)throws IOException, InterruptedException {int sum = 0;for (IntWritable val:values) {sum += val.get();}statistic.set(sum);context.write(key.getFirst(), statistic);}}3.2第二部分设计利用两个Map/Reduce过程，第一个MR统计各个文件中的所有单词的出现次数，以及各个文件单词总数，第二个MR根据统计结果处理加工得到单词倒排索引。
第一个MR设计：1.在Map过程中，重写map类，利用StringTokenizer类，将map 方法中的value值中存储的文本，拆分成一个个的单词，并获取文件名，以两种格式进行输出< filename+word,1>或者<filename,1>。
public void map(Object key, Text value, Context context)throws IOException, InterruptedException {//获取文件名FileSplit fileSplit= (FileSplit)context.getInputSplit();String fileName = fileSplit.getPath().getName();//获取单词在单个文件中出现次数，及文件单词总数StringTokenizer itr= new StringTokenizer(value.toString());for(; itr.hasMoreTokens(); ) {String word =removeNonLetters( itr.nextToken().toLowerCase());String fileWord = fileName+"\001"+word;if(!word.equals("")){context.write(new Text(fileWord), new IntWritable(1));context.write(new Text(fileName), new IntWritable(1));}}}2.在Reduce过程中，统计得到每个文件中每个单词的出现次数，以及每个文件的单词总数，输出<key,count>。
public void reduce(Text key, Iterable<IntWritable> values, Context context)throws IOException, InterruptedException {int sum = 0;for (IntWritable val : values) {sum += val.get();}context.write(key,new IntWritable(sum));}}第二个MR设计：1.Map过程读取第一个MR的输出，对value值进行拆分，重新组合后输出键为固定Text类型值index，值为filename+word+count或者filename+count。
public void map(Object key, Text value, Context context)throws IOException, InterruptedException {String valStr = value.toString();String[] records = valStr.split("\t");context.write(new Text("index"),new Text(records[0]+"\001"+records[1]));}}2.Reduce过程中定义四个HashMap，Map<String,Integer> wordinfilescount，key为单词+文件名，value为单词在该文件中出现的次数；Map<String,Integer> filescount ，key为文件名，value为文件的单词总数；Map<String,Integer> wordinfiles，key为单词，value为单词在多少个文件中出现；Map<String,String> indexes，key为单词，value为倒排索引。
读取values值，根据设定分隔符拆分，判断拆分后长度如果为2，则该值为文件名+文件单词总数，将拆分后的文件名及文件单词总数，组成键值对放入Map<String,Integer> filescount；拆分后长度如果为3，则该值为文件名+单词+单词在该文件中出现次数，将拆分后的文件名+单词及单词在该文件中出现次数组成键值对放入Map<String,Integer> wordinfilescount，同时统计单词在多少个文件中出现，并组成键值对放入Map<String,Integer> wordinfiles。
遍历Map<String,Integer> wordinfilescount，将单词作为键，“单词->出现该单词的文件个数:总文件个数：{(出现该单词的文件名，单词在该文件中的出现次数，该文件的总单词数)”作为值，放入Map<String,String> indexes中。
遍历Map<String,String> indexes获取倒排索引并输出全部索引。
public void reduce( Text key, Iterable<Text> values, Context context)throws IOException, InterruptedException {//拆分输入，获取单词出现在几个文件中以及在该文件中出现次数，各个文件的单词总数，总文件数for (Text val : values) {String valStr = val.toString();String[] records = valStr.split("\001");switch(records.length){case 2:filescount.put(records[0], Integer.parseInt(records[1]));break;case 3:{wordinfilescount.put(valStr, Integer.parseInt(records[2]));if(!wordinfiles.containsKey(records[1])){wordinfiles.put(records[1], 1);}else{wordinfiles.put(records[1], wordinfiles.get(records[1])+1);}};break;}}//处理获取倒排索引for (Entry<String, Integer> entry : wordinfilescount.entrySet()) {String valStr = entry.getKey();String[] records = valStr.split("\001");String word = records[1];if(!indexes.containsKey(word)){StringBuilder sb = new StringBuilder();sb.append(word).append("->").append(wordinfiles.get(word)).append(":").append(filescount.size()).append(":").append("{(").append( records[0]).append(",").append(entry.getValue()).append(",").append(filescount.get( records[0])).append(")");indexes.put(word,sb.toString() );}else{StringBuilder sb = new StringBuilder();sb.append(",(").append( records[0]).append(",").append(entry.getValue()).append(",").append(filescount.get( records[0])).append(")");indexes.put(word,indexes.get(word)+sb.toString() ); }}for (Entry<String, String> entry : indexes.entrySet()) {context.write(new Text(entry.getValue()+"}"), NullWritable.get());}}}4.程序代码4.1第一部分代码1.IpStatistics.java/*** Licensed to the Apache Software Foundation (ASF) under one* or more contributor license agreements. See the NOTICE file* distributed with this work for additional information* regarding copyright ownership. The ASF licenses this file* to you under the Apache License, Version 2.0 (the* "License"); you may not use this file except in compliance* with the License. You may obtain a copy of the License at** /licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/import java.io.IOException;import java.util.ArrayList;import java.util.Collections;import parator;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Map.Entry;import java.util.StringTokenizer;import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.io.IntWritable;import org.apache.hadoop.io.NullWritable;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 org.apache.hadoop.util.GenericOptionsParser;import org.apache.hadoop.fs.Path;public class IpStatistics {//第一个Map/Reduce的map类，用于去重public static class RemoveMapper extendsMapper<Object, Text, StringPair, NullWritable> {public void map(Object key, Text value, Context context)throws IOException, InterruptedException {StringTokenizer itr = new StringTokenizer(value.toString());while (itr.hasMoreTokens()) {String nextToken =itr.nextToken();String[] records = nextToken.split(",");String sourceip = records[0].replace("<", "");String destinationip = records[1].replace(">", "");context.write(newStringPair(sourceip,destinationip),NullWritable.get() );}}}//第二个Map/Reduce过程map类，用于统计public static class StatisticsMapper extendsMapper<Object, Text, StringPair, IntWritable> {IntWritable one=new IntWritable(1);public void map(Object key, Text value, Context context)throws IOException, InterruptedException {String[] records = value.toString().split("\t");String sourceip = records[0];String desip=records[1];context.write(new StringPair(sourceip,desip),one);}}//按照源地址分组public static class GroupComparator extends WritableComparator {protected GroupComparator() {super(StringPair.class, true);}@Overridepublic int compare(WritableComparable w1,WritableComparable w2) {StringPair ip1=(StringPair)w1;StringPair ip2=(StringPair)w2;return ip1.getFirst().compareTo(ip2.getFirst());}}//第一个Map/Reduce过程reduce过程，去重public static class RemoveReducer extendsReducer<StringPair, IntWritable, Text, NullWritable> {public void reduce( StringPair key, Iterable<IntWritable> values, Context context)throws IOException, InterruptedException {context.write(new Text(key.toString()), NullWritable.get());}}//第二个Map/Reduce过程reduce过程，统计public static class StatisticsReducer extendsReducer<StringPair, IntWritable, Text, IntWritable> {private IntWritable statistic = new IntWritable();public void reduce( StringPair key, Iterable<IntWritable> values, Context context)throws IOException, InterruptedException {int sum = 0;for (IntWritable val:values) {sum += val.get();}statistic.set(sum);context.write(key.getFirst(), statistic);}}//去重任务public static void RemoveTask(String[] args) throws Exception{Configuration conf = new Configuration();String master="127.0.0.1";conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");conf.set("er", "hadoop");conf.set("","yarn");conf.set("yarn.resourcemanager.address", master+":8032");conf.set("yarn.resourcemanager.scheduler.address", master+":8030");conf.set("mapred.jar","ipstatistics.jar");String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();if (otherArgs.length < 3) {System.err.println("Usage: ipstatistics <in> [<in>...] <out>");System.exit(2);}Job job = new Job(conf, "ipstatisticsRemoving");job.setMapperClass(RemoveMapper.class);job.setReducerClass(RemoveReducer.class);job.setOutputKeyClass(StringPair.class);job.setOutputValueClass(NullWritable.class);FileInputFormat.addInputPath(job, new Path(otherArgs[0]));FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));job.waitForCompletion(true) ;}//统计任务public static void StatisticsTask(String[] args) throws Exception{ Configuration conf = new Configuration();String master="127.0.0.1";conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");conf.set("er", "hadoop");conf.set("","yarn");conf.set("yarn.resourcemanager.address", master+":8032");conf.set("yarn.resourcemanager.scheduler.address", master+":8030");conf.set("mapred.jar","ipstatistics.jar");String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();if (otherArgs.length < 3) {System.err.println("Usage: ipstatistics <in> [<in>...] <out>");System.exit(2);}Job job = new Job(conf, "ipstatisticsStatistics");job.setMapperClass(StatisticsMapper.class);job.setGroupingComparatorClass(GroupComparator.class);job.setReducerClass(StatisticsReducer.class);job.setOutputKeyClass(StringPair.class);job.setOutputValueClass(IntWritable.class);FileInputFormat.addInputPath(job, new Path(otherArgs[1]));FileOutputFormat.setOutputPath(job, new Path(otherArgs[2]));System.exit(job.waitForCompletion(true) ? 0 : 1);}public static void main(String[] args) throws Exception {RemoveTask(args);StatisticsTask(args);}}2.StringPair.javaimport org.apache.hadoop.io.Text;import org.apache.hadoop.io.WritableComparable;import java.io.DataInput;import java.io.DataOutput;import java.io.IOException;public class StringPair implements WritableComparable<StringPair> {private Text first;private Text second;public StringPair() {this.first = new Text();this.second = new Text();}public StringPair(String first, String second) {set(new Text(first), new Text(second));}public StringPair(Text first, Text second) {set(first, second);}public void set(Text first, Text second) {this.first = first;this.second = second;}public Text getFirst() {return first;}public Text getSecond() {return second;}public void write(DataOutput out) throws IOException {first.write(out);second.write(out);}public void readFields(DataInput in) throws IOException {first.readFields(in);second.readFields(in);}@Overridepublic int hashCode() {return first.hashCode() * 163 + second.hashCode();}@Overridepublic boolean equals(Object obj) {if (obj instanceof StringPair) {StringPair ip = (StringPair) obj;return first.toString().equals(ip.first.toString())&& second.toString().equals(ip.second.toString());}4.2第二部分代码import java.io.IOException;import java.util.HashSet;import java.util.Map;import java.util.Set;import java.util.StringTokenizer;import java.util.HashMap;import java.util.Map.Entry;import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.fs.Path;import org.apache.hadoop.io.IntWritable;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.Mapper.Context;import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;import org.apache.hadoop.mapreduce.lib.input.FileSplit;import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;import org.apache.hadoop.util.GenericOptionsParser;public class InverseV3 {/** 第一个mr的map类，获取每个单词在单个文件中出现次数，输入为每个文件行偏移量，输出为<word+filename,1>* 或<filename,1>*/public static class statisticsMap extendsMapper<Object, Text, Text, IntWritable> {private Text mapKey = new Text("key");@Overridepublic void map(Object key, Text value, Context context)throws IOException, InterruptedException {//获取文件名FileSplit fileSplit= (FileSplit)context.getInputSplit();String fileName = fileSplit.getPath().getName();//获取单词在单个文件中出现次数，及文件单词总数StringTokenizer itr= new StringTokenizer(value.toString());for(; itr.hasMoreTokens(); ) {String word =removeNonLetters( itr.nextToken().toLowerCase());String fileWord = fileName+"\001"+word;if(!word.equals("")){context.write(new Text(fileWord), new IntWritable(1));context.write(new Text(fileName), new IntWritable(1));}}}//去掉字符串非字母字符public static String removeNonLetters(String original){StringBuffer aBuffer=new StringBuffer(original.length());char aCharacter;for(int i=0;i<original.length();i++){aCharacter=original.charAt(i);if(Character.isLetter(aCharacter)){aBuffer.append(aCharacter);}}return new String(aBuffer);}}//第一个mr的reduce类，统计汇总出现单词的文件个数，及每个文件中单词出现个数及每个文件单词个数,public static class statisticsReduce extendsReducer<Text, IntWritable, Text, IntWritable> {@Overridepublic void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {int sum = 0;for (IntWritable val : values) {sum += val.get();}context.write(key,new IntWritable(sum));}}public static class InverseMapper extendsMapper<Object, Text, Text, Text> {public void map(Object key, Text value, Context context)throws IOException, InterruptedException {String valStr = value.toString();String[] records = valStr.split("\t");context.write(new Text("index"),new Text(records[0]+"\001"+records[1]));}}public static class InverseReducer extendsReducer<Text, Text, Text, NullWritable> {private Map<String,Integer> wordinfilescount = newHashMap<String,Integer>();//key为单词+文件名，value为单词在该文件中出现的次数private Map<String,Integer> filescount = new HashMap<String,Integer>();//key为文件名，value为文件的单词总数private Map<String,Integer> wordinfiles = new HashMap<String,Integer>();//key为单词，value为单词在多少的文件中出现private Map<String,String> indexes = new HashMap<String,String>();//key为单词，value为倒排索引public void reduce( Text key, Iterable<Text> values, Context context)throws IOException, InterruptedException {//拆分输入，获取单词出现在几个文件中以及在该文件中出现次数，各个文件的单词总数，总文件数for (Text val : values) {String valStr = val.toString();String[] records = valStr.split("\001");switch(records.length){case 2:filescount.put(records[0], Integer.parseInt(records[1]));break;case 3:{wordinfilescount.put(valStr, Integer.parseInt(records[2]));if(!wordinfiles.containsKey(records[1])){wordinfiles.put(records[1], 1);}else{wordinfiles.put(records[1], wordinfiles.get(records[1])+1);}};break;}}//处理获取倒排索引for (Entry<String, Integer> entry : wordinfilescount.entrySet()) {String valStr = entry.getKey();String[] records = valStr.split("\001");String word = records[1];if(!indexes.containsKey(word)){StringBuilder sb = new StringBuilder();sb.append(word).append("->").append(wordinfiles.get(word)).append(":").append(filescount.size()).append(":").append("{(").append( records[0]).append(",").append(entry.getValue()).append(",").append(filescount.get( records[0])).append(")");indexes.put(word,sb.toString() );}else{StringBuilder sb = new StringBuilder();sb.append(",(").append( records[0]).append(",").append(entry.getValue()).append(",").append(filescount.get( records[0])).append(")");indexes.put(word,indexes.get(word)+sb.toString() );}}for (Entry<String, String> entry : indexes.entrySet()) {context.write(new Text(entry.getValue()+"}"), NullWritable.get());}}}//统计单词在文件中出现次数及单个文件单词总数public static void StatisticsTask(String[] args) throws Exception{ Configuration conf = new Configuration();String master="127.0.0.1";conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");conf.set("er", "hadoop");conf.set("","yarn");conf.set("yarn.resourcemanager.address", master+":8032");conf.set("yarn.resourcemanager.scheduler.address", master+":8030");conf.set("mapred.jar","invertdindex.jar");String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();if (otherArgs.length < 3) {System.err.println("Usage: ipstatistics <in> [<in>...] <out>");System.exit(2);}Job job = new Job(conf, "invertd index1");job.setMapperClass(statisticsMap.class);job.setReducerClass(statisticsReduce.class);job.setOutputKeyClass(Text.class);job.setOutputValueClass(IntWritable.class);FileInputFormat.addInputPath(job, new Path(otherArgs[0]));FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));job.waitForCompletion(true) ;}//根据统计结果输出倒排索引public static void InverseTask(String[] args) throws Exception{ Configuration conf = new Configuration();String master="127.0.0.1";conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");conf.set("er", "hadoop");conf.set("","yarn");conf.set("yarn.resourcemanager.address", master+":8032");conf.set("yarn.resourcemanager.scheduler.address", master+":8030");conf.set("mapred.jar","invertdindex.jar");String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();if (otherArgs.length < 3) {System.err.println("Usage: ipstatistics <in> [<in>...] <out>");System.exit(2);}Job job = new Job(conf, "invertd index2");job.setMapperClass( InverseMapper.class);job.setReducerClass( InverseReducer.class);job.setOutputKeyClass(Text.class);job.setOutputValueClass(Text.class);FileInputFormat.addInputPath(job, new Path(otherArgs[1]));FileOutputFormat.setOutputPath(job, new Path(otherArgs[2]));System.exit(job.waitForCompletion(true) ? 0 : 1);}public static void main(String[] args) throws Exception {StatisticsTask(args);InverseTask(args);}}5.实验输入和结果实验输入输出结果见压缩包中对应目录。