大数据学习心得-2020-09-19--MR案例三枚（倒排索引、top10、寻找共同好友）

最新推荐文章于 2022-02-16 17:33:41 发布
最新推荐文章于 2022-02-16 17:33:41 发布
阅读量228 收藏 3
点赞数
分类专栏： 大数据学习笔记 文章标签： 大数据 java mapreduce hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/airleaya/article/details/108680382
版权

案例一：倒排索引案例（多job串联）

  • 需求

    有大量的文本，需要建立搜索索引

    • 数据输入

      • 文件1

        E:\work\test\input\II\a.txt

        Remilya Scarlet jiejie
Frandre Scarlet meimei
Scarlet

      • 文件2

        E:\work\test\input\II\b.txt

        Remilya Scarlet
weiyan weiyan weiyan weiyan
weiyan weiyan weiyan weiyan
weiyan weiyan weiyan weiyan
jiejie jiejie jiejie

      • 文件3

        E:\work\test\input\II\c.txt

        Frandre Scarlet meimei
meimei meimei meimei
Scarlet
Scarlet

    • 期望输出

      • 每一个单词为输出的键，其在每个文件中出现的次数与文件名连接后全部拼接为值

        Frandre	a.txt---1,c.txt---1,
Remilya	a.txt---1,b.txt---1,
Scarlet	c.txt---3,b.txt---1,a.txt---3,
jiejie	b.txt---3,a.txt---1,
meimei	a.txt---1,c.txt---4,
weiyan	b.txt---12,c.txt---1,a.txt---2,

  • 代码实现

    mapper1:

    import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import java.io.IOException;

/**
 * 进行稍微有所变动的wordCount即可
 */
public class Mapper1 extends
        Mapper<LongWritable, Text,Text, IntWritable> {
    private String fileName;

    /**
     * 获取文件名
     */
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        FileSplit split = (FileSplit) context.getInputSplit();
        fileName = split.getPath().getName();
    }

    private Text k_out = new Text();
    private IntWritable v_out = new IntWritable(1);

    /**
     * 只要切割输入字符串，将每个单词后拼接上文件名即可作为键输出
     */
    @Override
    protected void map(LongWritable key,
                       Text value, Context context)
            throws IOException, InterruptedException {
        String[] words = value.toString().split(" ");
        for (String word : words) {
            k_out.set(word+"-"+fileName);
            context.write(k_out,v_out);
        }
    }
}

    reducer1

    import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * 累加即可
 */
public class Reducer1 extends Reducer<Text, IntWritable,Text,IntWritable> {
    private IntWritable v_out = new IntWritable();
    /**
     * 累加即可
     */
    @Override
    protected void reduce(Text key,
                          Iterable<IntWritable> values, Context context)
            throws IOException, InterruptedException {
        int sum = 0;
        for (IntWritable value : values) {
            sum += value.get();
        }
        v_out.set(sum);
        context.write(key,v_out);
    }
}

    mapper2

    import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * 采用k-v输入格式，通过"-"切割k-v
 */
public class Mapper2 extends Mapper<Text, Text, Text, Text> {
    /**
     * map直接用父类实现直接写出也可以
     * 这里修改一下value的连接符，不影响业务
     */
    private Text v_out = new Text();
    @Override
    protected void map(Text key,
                       Text value, Context context)
            throws IOException, InterruptedException {
        //修改value连接符
        String[] v = value.toString().split("\t");
        v_out.set(v[0]+"---"+v[1]);
        context.write(key,v_out);
    }
}

    reducer2

    import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * 拼接同一个键的值
 * 使达到预期效果
 */
public class Reducer2 extends Reducer<Text, Text, Text, Text> {
    /**
     * 拼接值
     */
    private Text v_out = new Text();
    @Override
    protected void reduce(Text key,
                          Iterable<Text> values, Context context)
            throws IOException, InterruptedException {
        StringBuffer sb = new StringBuffer();
        boolean first = true;
        for (Text value : values) {
        sb.append(value.toString()+",");
        }
        v_out.set(sb.toString());
        context.write(key,v_out);
    }
}

    driver

    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.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputFormat;
import org.apache.hadoop.mapreduce.lib.jobcontrol.ControlledJob;
import org.apache.hadoop.mapreduce.lib.jobcontrol.JobControl;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

/**
 * 在driver中设置
 */
public class MyDriver {
    public static void main(String[] args) throws IOException, InterruptedException {
        //设置输入输出路径
        Path input = new Path("e:/work/test/input/II");
        Path output1 = new Path("e:/work/test/output1");
        Path output2 = new Path("e:/work/test/output2");

        //两份配置文件
        Configuration conf1 = new Configuration();
        Configuration conf2 = new Configuration();
        //设置job2的k-vinputformat的分隔符
        conf2.set("mapreduce.input.keyvaluelinerecordreader.key.value.separator","-");

        //删除可能存在的输出路径
        FileSystem fs = FileSystem.get(conf1);
        if(fs.exists(output1)){
            fs.delete(output1,true);
        }
        if(fs.exists(output2)){
            fs.delete(output2,true);
        }

        //获取俩job
        Job job1 = Job.getInstance(conf1);
        Job job2 = Job.getInstance(conf2);

        /**************************************************/
        //设置job1的信息
        job1.setMapperClass(Mapper1.class);
        job1.setReducerClass(Reducer1.class);

        job1.setOutputKeyClass(Text.class);
        job1.setOutputValueClass(IntWritable.class);

        FileInputFormat.setInputPaths(job1,input);
        FileOutputFormat.setOutputPath(job1,output1);
        /**************************************************/
        //设置job2的信息
        job2.setMapperClass(Mapper2.class);
        job2.setReducerClass(Reducer2.class);

        job2.setOutputKeyClass(Text.class);
        job2.setOutputValueClass(Text.class);

        job2.setInputFormatClass(KeyValueTextInputFormat.class);

        FileInputFormat.setInputPaths(job2,output1);
        FileOutputFormat.setOutputPath(job2,output2);
        /**************************************************/

        //设置job名称
        job1.setJobName("job1");
        job2.setJobName("job2");

        //将两个任务关联起来
        JobControl jobControl = new JobControl("jobs");

        //创建controlledJob，保证两个job的同步关系
        ControlledJob controlledJob1 = new ControlledJob(job1.getConfiguration());
        ControlledJob controlledJob2 = new ControlledJob(job2.getConfiguration());

        //将两个job连接，保证controlledJob2在controlledJob1之后运行
        controlledJob2.addDependingJob(controlledJob1);

        jobControl.addJob(controlledJob1);
        jobControl.addJob(controlledJob2);

        //运行job Control1
        Thread jobControlThread = new Thread(jobControl);
        //设置此线程为守护线程
        jobControlThread.setDaemon(true);
        jobControlThread.start();
        while (true){
            if(jobControl.allFinished()){
                return;
            }
        }
    }
}

案例二：TOPN案例

  • 需求

    • 已知输入数据为

      E:\work\test\input\top10\top10inputfile.txt

      13470253144	180	180	360
13509468723	7335	110349	117684
13560439638	918	4938	5856
13568436656	3597	25635	29232
13590439668	1116	954	2070
13630577991	6960	690	7650
13682846555	1938	2910	4848
13729199489	240	0	240
13736230513	2481	24681	27162
13768778790	120	120	240
13846544121	264	0	264
13956435636	132	1512	1644
13966251146	240	0	240
13975057813	11058	48243	59301
13992314666	3008	3720	6728
15043685818	3659	3538	7197
15910133277	3156	2936	6092
15959002129	1938	180	2118
18271575951	1527	2106	3633
18390173782	9531	2412	11943
84188413	4116	1432	5548

      每列分别代表着手机号、上行、下行、总流量

      现要求使用流量最多的top10

    • 采用降序排序，输出时使用一个count计数器只输出前十的数据即可

  • 代码

    FlowBean（setter、getter生成器略

    import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/**
 * FlowBean实现WritableComparable接口，使得其可排序
 */
public class FlowBean implements WritableComparable {
    private long upFlow;
    private long downFlow;
    private long sumFlow;

    /**
     * 实现compareTo方法实现排序
     */
    public int compareTo(Object o) {
        FlowBean bean = (FlowBean) o;
        if(sumFlow > bean.getSumFlow()){
            return -1;
        }else if (sumFlow == bean.getSumFlow()){
            return 0;
        }else{
            return 1;
        }
    }

    public void write(DataOutput out) throws IOException {
        out.writeLong(upFlow);
        out.writeLong(downFlow);
        out.writeLong(sumFlow);
    }

    public void readFields(DataInput in) throws IOException {
        upFlow = in.readLong();
        downFlow = in.readLong();
        sumFlow = in.readLong();
    }

    @Override
    public String toString() {
        return upFlow+"\t"+downFlow+"\t"+sumFlow;
    }
}

    mapper

    import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * 将可排序的FlowBean直接作为键输出
 * 值为其手机号
 */
public class TopMapper extends
        Mapper<LongWritable, Text,FlowBean, Text> {
    private FlowBean k_out = new FlowBean();
    private Text v_out = new Text();
    /**
     * map方法将流量数据封装到FlowBean中
     * 然后写出k-v，
     * 由于FlowBean中实现了compareTo方法，所以回按照总流量排序
     */
    @Override
    protected void map(
            LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
        String[] line = value.toString().split("\t");
        v_out.set(line[0]);
        k_out.setUpFlow(Long.parseLong(line[1]));
        k_out.setDownFlow(Long.parseLong(line[2]));
        k_out.setSumFlow(Long.parseLong(line[3]));
        context.write(k_out,v_out);
    }
}

    redcuer

    import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * reduce类中申请一个成员变量count，当count为10后不再输出数据即可
 * 如果需要解决并列问题，修改count计数在循环和判断语句间的位置即可
 */
public class TopReducer extends
        Reducer<FlowBean, Text,Text,FlowBean> {
    private int count;

    @Override
    protected void setup(Context context)
            throws IOException, InterruptedException {
        count = 0;
    }

    @Override
    protected void reduce(
            FlowBean key, Iterable<Text> values, Context context)
            throws IOException, InterruptedException {
        //遍历以免出现总流量相同的情况
        for (Text value : values) {
            if(count < 10){
                context.write(value,key);
                count++;
            }
        }
    }
}

    driver设置略

  • 运行结果：

    13509468723	7335	110349	117684
13975057813	11058	48243	59301
13568436656	3597	25635	29232
13736230513	2481	24681	27162
18390173782	9531	2412	11943
13630577991	6960	690	7650
15043685818	3659	3538	7197
13992314666	3008	3720	6728
15910133277	3156	2936	6092
13560439638	918	4938	5856

    符合预期，案例完成

案例三：计算共同好友

  • 需求

    • 有如下好友数据，冒号前为该用户，冒号后为该用户的好友。此处的好友为单向好友

    • 输入数据

      E:\work\test\input\friends\friends.txt

      A:B,C,D,F,E,O
B:A,C,E,K
C:F,A,D,I
D:A,E,F,L
E:B,C,D,M,L
F:A,B,C,D,E,O,M
G:A,C,D,E,F
H:A,C,D,E,O
I:A,O
J:B,O
K:A,C,D
L:D,E,F
M:E,F,G
O:A,H,I,J

      要求求出两两相对用户的共同好友，预期输出数据为：

      A-B	E C 
A-C	D F 
A-D	E F 
A-E	D B C 
A-F	O B C D E 
A-G	F E C D 
A-H	E C D O 
A-I	O 
A-J	O B 
A-K	D C 
A-L	F E D 
A-M	E F 
B-C	A 
B-D	A E 
B-E	C 
B-F	E A C 
B-G	C E A 
B-H	A E C 
B-I	A 
B-K	C A 
B-L	E 
B-M	E 
B-O	A 
C-D	A F 
C-E	D 
C-F	D A 
C-G	D F A 
C-H	D A 
C-I	A 
C-K	A D 
C-L	D F 
C-M	F 
C-O	I A 
D-E	L 
D-F	A E 
D-G	E A F 
D-H	A E 
D-I	A 
D-K	A 
D-L	E F 
D-M	F E 
D-O	A 
E-F	D M C B 
E-G	C D 
E-H	C D 
E-J	B 
E-K	C D 
E-L	D 
F-G	D C A E 
F-H	A D O E C 
F-I	O A 
F-J	B O 
F-K	D C A 
F-L	E D 
F-M	E 
F-O	A 
G-H	D C E A 
G-I	A 
G-K	D A C 
G-L	D F E 
G-M	E F 
G-O	A 
H-I	O A 
H-J	O 
H-K	A C D 
H-L	D E 
H-M	E 
H-O	A 
I-J	O 
I-K	A 
I-O	A 
K-L	D 
K-O	A 
L-M	E F

  • 思路

    • 思路：
      • 首先分割数据，建立好友-用户的k-v对，然后合并为好友-用户们输出
      • 然后再在作为值得用户们中两两配对，输出。
      • 最后归并数据即可

  • 代码

    mapper1

    import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * mapper1负责将用户：好友数据切割
 * 并以好友-用户形式得k-v对输出
 */
public class Mapper1 extends
        Mapper<LongWritable, Text, Text, Text> {
    private Text k_out = new Text();
    private Text v_out = new Text();

    @Override
    protected void map(
            LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
        //切割行
        String[] line = value.toString().split(":");
        //切割键的部分
        String[] friends = line[1].split(",");
        k_out.set(line[0]);
        for (String friend : friends) {
            v_out.set(friend.toString());
            context.write(k_out,v_out);
        }
    }
}

    reducer1

    import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * reducer1负责把mapper1分割处理好的数据进行归并，
 */
public class Reducer1 extends
        Reducer<Text, Text, Text, Text> {
    private Text v_out = new Text();
    @Override
    protected void reduce(
            Text key, Iterable<Text> values, Context context)
            throws IOException, InterruptedException {
        String temp = "";
        //连接“好友”数据对应的所有用户
        for (Text value : values) {
            temp += value.toString() + ",";
        }
        v_out.set(temp);
        //输出
        context.write(key,v_out);
    }
}

    mapper2

    import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;
import java.util.Arrays;

/**
 * 同样使用kvinputformat
 * k为好友，v为对应的所有用户，由\t分割
 * 此步将k对应的所有v两两对应
 */
public class Mapper2 extends
        Mapper<LongWritable, Text, Text, Text> {
    private Text k_out = new Text();
    private Text v_out = new Text();
    @Override
    protected void map(
            LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
        //切割行
        String[] line = value.toString().split("\t");
        //设置value
        v_out.set(line[0]);
        String[] users = line[1].split(",");
        //使用户变得有序，方便后续组合不会出现因为次序颠倒而两两相悖的情况
        Arrays.sort(users);
        for (int i = 0; i < users.length; i++) {
            for (int j = i+1; j < users.length; j++) {
                //两两拼接
                k_out.set(users[i]+"-"+users[j]);
                context.write(k_out,v_out);
            }
        }
    }
}

    reducer2

    import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * 负责最终的数据颠倒写出
 */
public class Reducer2 extends
        Reducer<Text, Text, Text, NullWritable> {
    private Text k_out = new Text();
    @Override
    protected void reduce(
            Text key, Iterable<Text> values, Context context)
            throws IOException, InterruptedException {
        String temp = key.toString() + " ";
        for (Text value : values) {
            temp += value.toString() + " ";
        }
        k_out.set(temp);
        context.write(k_out,NullWritable.get());
    }
}

    driver

    *略

  • 输出结果：

    A-B F 
A-C F B K G H 
A-D F G H C K 
A-E B F G H D 
A-F G C D 
A-H O 
A-I O C 
A-J O 
A-K B 
A-L D 
A-M F 
A-O I F H 
B-C A F E 
B-D F E A 
B-E F A 
B-F A 
B-L E 
B-M E F 
B-O A F J 
C-D E G A K F H 
C-E B A F H G 
C-F G A 
C-K B 
C-L E 
C-M E F 
C-O F A H 
D-E F L H A G 
D-F G A L C 
D-I C 
D-L E 
D-M E F 
D-O A F H 
E-F M L D G A 
E-G M 
E-K B 
E-L D 
E-M F 
E-O A F H 
F-G M 
F-I C 
F-L D 
F-O A 
H-I O 
H-J O 
I-J O 
L-M E 
M-O F

    符合预期

airleaya
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据讲课笔记5.5 MR案例——倒排索引
howard2005的专栏
10-09 806
1. 理解倒排索引； 2. 实现倒排索引
倒排索引总结
许诗宇的博客
06-22 833
目录 倒排索引简介 Elasticsearch 建立倒排索引 参考了 https://www.cnblogs.com/cjsblog/p/10327673.html 倒排索引简介 倒排索引（Inverted Index）也叫反向索引，有反向索引必有正向索引。通俗地来讲，正向索引是通过key找value，反向索引则是通过value找key。 先来回忆一下我们是怎么插入一条索引记录的： curl -X PUT "localhost:9200/user/_doc/1" -H 'Content-..
倒排索引基本总结
forestLight的专栏
09-29 1098
1.      作用：事先建立好倒排索引表，可以加速单词查找。 2.      内容：包含单词出现的文档号、文档中的出现次数和文档中的位置（后面两个不一定有）。 3.      查询：单个词语，直接找到倒排表中的那一项。 句子查询，用这些单词在倒排表中的文档类求与运算。
写倒排索引的总结
CY_TEC的博客
07-11 747
这次小作业的任务是对18000篇文章中的单词建立倒排索引，并保存成“单词.idx”文件输出。 要处理的文件每一行的格式是：《文章ID》 《句子ID》 句子。所有的数据一共包含180个二进制文件，名字分别是docs1、docs2... ...、docs180。其中每一个docs中有100篇文章，每一篇文章又包含若干个句子。 首先要读出所有单词，并记录其《文章ID》 《句子ID》。为了方便写入
倒排索引之我见
qq_38237482的博客
12-02 212
最近上数据结构课 上到b树的时候，课上的引子便是搜索引擎的结构基础：倒排索引，引起了我极大的兴趣 要知道google 百度这类公司便是应用这一结构为基石的，想想还是蛮有趣的 首先我们来回想一下在使用搜索引擎时的过程，输入一个或多个关键字，然后搜索引擎就返回了一个结果列表 最直白简单的想法是，搜索引擎遍历所有的文档，从中挑选与关键字相关的文档，那么这叫做【正想索引】 但是不得不否认这种想法是
三菱MR-J4-B系列伺服驱动使用及配置方法
11-20
三菱MR-J4-B系列伺服驱动的使用方法，接线，参数配置，程序调用，原理图，FX5-80/40SSC运动控制模块
hudi-hadoop-mr-bundle-0.11.0.jar
06-28
hudi-hadoop-mr-bundle-0.11.0.jar 配合文档
三菱PLC工控板 2N-20MR-10AD-惠亚控-学习使用-说明.zip
05-22
分享三菱PLC工控板 2N-20MR-10AD-惠亚控-学习使用-说明，资料仅供学习研究。
三菱MR-J4系列伺服驱动器E7.1和32.3故障报警处理总结.docx
最新发布
05-30
三菱MR-J4系列伺服驱动器E7.1和32.3故障报警处理总结
MR-JET-G实现CC-LINK IE Field Basic通信
03-09
MR-JET-G实现CC-LINK IE Field Basic通信 MR-JET-G是一种高性能的伺服驱动器，能够实现CC-LINK IE Field Basic通信。CC-LINK IE Field Basic是一种工业现场总线协议，广泛应用于工厂自动化、机器人控制、运动控制等...
【Elastic Search学习总结】4. 倒排索引
FullStackDeveloper0的博客
03-26 194
目录 1.倒排索引列表可以包含文档的ID、词频TF、位置信息，同时注意倒排索引列表里面的单词是不重复的 2. 分词器的标准化分词的规则是无视大小写、单复数、同义词的 案例一 【提示】第一列是单词ID； 第二列是单词； 第三列是文档编号 总结 倒排索引列表可以包含文档的ID、词频TF、位置信息，同时注意倒排索引列表里面的单词是不重复...
Hadoop之MR（查找共同好友）
qq_37668945的博客
01-02 1856
1.需求：给出A-O个人中每个人的好友列表，求出哪些人两两之间有共同好友，以及他们的共同好友都有谁 2.思路：此题旨在求两人之间的共同好友，原信息是&lt;人，该人的所有好友&gt;，因此首先以好友为键，人为值，交给reduce找出拥有此好友的所有人；再将这些人中两两配对作为键，之前的键（好友）作为值交给reduce去合并 简而言之我打算分成两个步骤，两次迭代 1）求出每一个人都是哪些人的共同好...
Map reduce程序----求共同好友
weixin_57136153的博客
01-20 1989
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分
【hadoop学习项目】10. 使用多级MR找出两两用户之间的共同好友
STAR GAME
02-16 1122
0. 项目结构 数据内容 刘灵薇 孙初丹,孙听兰,李秋翠,李绿春 王访琴 刘忆翠,钱语芙,钱平蝶 赵雅蕊 刘灵薇,刘雅蕊 王含蕾 钱语芙,李书蕾,李忆翠 钱雅蕊 李秋春,李初丹,孙听蓉 王绿春 李含烟,刘谷丝,孙秋春,钱雅蕊,赵语芙,钱南松,钱绿春,王听兰 刘含玉 赵绿春,王幻珊,刘语芙,赵怜菡,孙绿春,赵从蓉,赵南松,刘幻灵,王忆翠 钱凌瑶 孙诗云,王乐瑶,钱海露,孙从蓉 李含蕾 李从蓉,李从蓉,刘怜菡,钱灵雁 钱幻灵 赵书蕾,赵秋翠,刘幻珊,刘幻灵,刘雪青,钱夏彤,赵含蕾 刘夏彤 刘忆翠,钱诗云,王
MR关于Join笔记及共同好友案例的实现
quancuizuishuai的博客
07-24 256
join 1.map 端 join  应用于一个大文件和一个小文件的场景，小文件可以直接读取到内存中，这样每个mappertask都可以有一份小文件的数据，每次map处理数据从大文件中读取一条数据跟小文件中比对，如果有key与之对应，那么相连之后输出  下面是一个简单案例部分代码 小文件的路径需要在驱动类中指定 map中具体实现的业务逻辑 2.reduce端join  应用于两个大文件的场景，在map阶段对两个文件同时进行读取，在获得数据的同时为其打上“标签”（用来区分两个不同的文件中的数据），然后co
倒排索引的简单实现
eriol的思考空间
09-06 623
首先看一个例子：       假设有3篇文章，file1, file2, file3，文件内容如下：    file1 (单词1，单词2，单词3，单词4....) file2 (单词a，单词b，单词c，单词d....) file3 (单词1，单词a，单词3，单词d....)       那么建立的倒排索引就是这个样子：   单词1 (file1,file3) 单词...
MapReduce------找出共同好友
洛云凡
08-08 204
实现思路： 某个人是哪些人的好友，将结果输出到文件。比如，A B,C,D,E （A是BCDE共同的好友）第一个程序结束。 跑第二次程序，将有A好友的人 两两组合形成 <B-C，A>格式的数据，最终跑出B-C A,D,E.....的数据。 第一个mr程序 import java.io.IOException; import org.apache.h...
十二道MR习题 - 4 - TopN问题
weixin_34334744的博客
09-27 162
题目： 有一个很大的文件，这文件中的内容全部都是数字，要求尝试从这个文件中找出最大的10个数字。 分析： 看起来像是一个比较简单的问题。不用大数据框架的话，也能比较轻易的实现：就是逐个读取文件中的每个数字，放到一个大顶堆结构中；将大顶堆放满以后，每读取一个数字就将之和大顶堆中的最小值进行比较，如果其大于这个最小值的话，就将其放入堆中，并将堆中的最小值删除；这样读取到最后，堆中剩下来的内容就是to...
MR基础案例（六）TOP N
BackToMe的博客
09-06 541
任务需求 需要求出wordcount的前3名 的数据 TopN.java package MR; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Lo...
WM-G-MR-09的天线接口与阻抗匹配如何设计
04-30
WM-G-MR-09是一款4G LTE模块，天线接口设计和阻抗匹配对于模块的性能和稳定性非常重要。以下是一些设计建议： 1. 选择合适的天线：要选择与模块相匹配的天线，包括天线类型、增益、频段等参数。根据不同的应用场景...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值