大数据_Shuffle、MapReduce编程案例(数据去重、多表查询、倒排索引、使用单元测试)

最新推荐文章于 2024-06-30 18:24:20 发布
最新推荐文章于 2024-06-30 18:24:20 发布
阅读量788 收藏 2
点赞数
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37243717/article/details/79032654
版权 


一、什么是Shuffle（洗牌） ----> MapReduce核心
    1、序列化
    2、排序
    3、分区
    4、合并


二、MapReduce编程案例 ------> 掌握方法：如何开发一个程序
    1、数据去重:
        复习：SQL：distinct去掉重复的数据
                           作用于后面所有的列

    复习（学习）：Oracle中的多表查询
        根据连接条件的不同：
        （1）等值连接
        （2）不等值连接
        （3）外链接
        （4）自连接

        注意：（1）多表查询和子查询，尽量使用哪个？（多表查询）
              （2）一般：多表查询的表的个数<=3 如果超过5个表，性能就差

    2、多表查询：等值连接
          查询员工信息：部门名称、员工姓名

            select d.dname,e.ename
            from emp e,dept d 
            where e.deptno=d.deptno;    

         问题：如果实现三张表？？


    3、多表查询：自连接: 通过表的别名，将同一张表看成多张表
            查询员工信息：老板姓名   员工的姓名

            select b.ename,e.ename          
            from emp b,emp e
            where b.empno=e.mgr;

            注意：产生的笛卡尔积= 原表的平方 ----> 自连接操作不适合操作大表
                  更好的方式：在Oracle中，使用层次查询（树）来取代自连接

    4、倒排索引


    5、使用单元测试：MRUnit

这里写图片描述

去重

package demo.mr.distinct;

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.NullWritable;
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.output.FileOutputFormat;

public class DistinctMain {

    public static void main(String[] args) throws Exception {
        // 创建一个job：job = map + reduce
        Job job = Job.getInstance(new Configuration());

        //指定任务的入口
        job.setJarByClass(DistinctMain.class);

        //指定任务的Mapper和输出的数据类型: k2  v2
        job.setMapperClass(DistinctMapper.class);
        job.setMapOutputKeyClass(Text.class);    //指定k2
        job.setMapOutputValueClass(NullWritable.class);  //指定v2

        //指定任务的Reducer和输出的数据类型: k4 v4
        job.setReducerClass(DistinctReducer.class);
        job.setOutputKeyClass(Text.class);   //指定k4
        job.setOutputValueClass(NullWritable.class);   //指定v4

        //指定输入的路径（map）、输出的路径（reduce）
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        //执行任务
        job.waitForCompletion(true);

    }

}
package demo.mr.distinct;

import java.io.IOException;

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


public class DistinctMapper extends Mapper<LongWritable, Text, Text, NullWritable> {

    @Override
    protected void map(LongWritable key1, Text value1, Context context)
            throws IOException, InterruptedException {
        // 数据  7654,MARTIN,SALESMAN,7698,1981/9/28,1250,1400,30
        String data = value1.toString();

        //分词
        String[] words = data.split(",");

        //将job作为key2进行输出
        context.write(new Text(words[2]), NullWritable.get());
    }

}

package demo.mr.distinct;

import java.io.IOException;

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

public class DistinctReducer extends Reducer<Text, NullWritable, Text, NullWritable> {

    @Override
    protected void reduce(Text k3, Iterable<NullWritable> v3,Context context) throws IOException, InterruptedException {
        context.write(k3, NullWritable.get());
    }
}

笛卡尔积
这里写图片描述

使用MR实现等值连接

这里写图片描述

代码实现

package demo.mr.multitable;

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.NullWritable;
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.output.FileOutputFormat;

public class MultiTableQueryMain {

    public static void main(String[] args) throws Exception {
        // 创建一个job：job = map + reduce
        Job job = Job.getInstance(new Configuration());

        //指定任务的入口
        job.setJarByClass(MultiTableQueryMain.class);

        //指定任务的Mapper和输出的数据类型: k2  v2
        job.setMapperClass(MultiTableQueryMapper.class);
        job.setMapOutputKeyClass(IntWritable.class);    //指定k2
        job.setMapOutputValueClass(Text.class);  //指定v2

        //指定任务的Reducer和输出的数据类型: k4 v4
        job.setReducerClass(MultiTableQueryReducer.class);
        job.setOutputKeyClass(Text.class);   //指定k4
        job.setOutputValueClass(Text.class);   //指定v4

        //指定输入的路径（map）、输出的路径（reduce）
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        //执行任务
        job.waitForCompletion(true);        

    }
}


package demo.mr.multitable;

import java.io.IOException;

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

public class MultiTableQueryMapper extends Mapper<LongWritable, Text, IntWritable, Text> {

    @Override
    protected void map(LongWritable key1, Text value1, Context context)
            throws IOException, InterruptedException {
        // 数据：可能是部门、也可能是员工
        String data = value1.toString();

        //分词
        String[] words = data.split(",");

        //判断数组的长度
        if(words.length == 3){
            //部门表：部门号  部门名称
            context.write(new IntWritable(Integer.parseInt(words[0])), new Text("*" + words[1]));
        }else{
            //员工表：员工的部门号  姓名
            context.write(new IntWritable(Integer.parseInt(words[7])), new Text(words[1]));
        }
    }
}
package demo.mr.multitable;

import java.io.IOException;

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

public class MultiTableQueryReducer extends Reducer<IntWritable, Text, Text, Text> {

    @Override
    protected void reduce(IntWritable k3, Iterable<Text> v3, Context context)
            throws IOException, InterruptedException {
        //定义变量：保存 部门名称 和 员工姓名
        String dname = "";
        String empNameList = "";

        for(Text v:v3){
            String str = v.toString();

            //找到*号的位置
            int index = str.indexOf("*");
            if(index >= 0){
                //代表的是部门名称
                dname = str.substring(1);
            }else{
                //代表的就是员工姓名
                empNameList = str + ";" + empNameList;
            }
        }

        //输出
        context.write(new Text(dname), new Text(empNameList));
    }
}

这里写图片描述

自连接代码实现

package demo.mr.selfjoin;

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

public class SelfJoinMain {

    public static void main(String[] args) throws Exception {
        // 创建一个job：job = map + reduce
        Job job = Job.getInstance(new Configuration());

        //指定任务的入口
        job.setJarByClass(SelfJoinMain.class);

        //指定任务的Mapper和输出的数据类型: k2  v2
        job.setMapperClass(SelfJoinMapper.class);
        job.setMapOutputKeyClass(IntWritable.class);    //指定k2
        job.setMapOutputValueClass(Text.class);  //指定v2

        //指定任务的Reducer和输出的数据类型: k4 v4
        job.setReducerClass(SelfJoinReducer.class);
        job.setOutputKeyClass(Text.class);   //指定k4
        job.setOutputValueClass(Text.class);   //指定v4

        //指定输入的路径（map）、输出的路径（reduce）
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        //执行任务
        job.waitForCompletion(true);
    }

}
package demo.mr.selfjoin;

import java.io.IOException;

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

public class SelfJoinMapper extends Mapper<LongWritable, Text, IntWritable, Text> {

    @Override
    protected void map(LongWritable key1, Text value1, Context context)
            throws IOException, InterruptedException {
        // 数据：7654,MARTIN,SALESMAN,7698,1981/9/28,1250,1400,30
        String data = value1.toString();

        //分词
        String[] words = data.split(",");

        //输出
        //1. 作为老板表
        context.write(new IntWritable(Integer.parseInt(words[0])), new Text("*"+words[1]));

        //2. 作为员工表
        try{
            context.write(new IntWritable(Integer.parseInt(words[3])), new Text(words[1]));
        }catch(Exception ex){
            //如果产生了Exception，表示：大老板
            context.write(new IntWritable(-1), new Text(words[1]));
        }
    }

}
package demo.mr.selfjoin;

import java.io.IOException;

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

public class SelfJoinReducer extends Reducer<IntWritable, Text, Text, Text> {

    @Override
    protected void reduce(IntWritable k3, Iterable<Text> v3, Context context)
            throws IOException, InterruptedException {
        //定义变量：老板姓名  员工姓名
        String bossName = "";
        String empNameList = "";

        for(Text t:v3){
            String str = t.toString();

            //判断是否存在*号
            int index = str.indexOf("*");
            if(index >=0 ){
                //表示：老板姓名
                bossName = str.substring(1);
            }else{
                //员工的姓名
                empNameList = str + ";" + empNameList;
            }
        }

        //输出
        //判断：如果存在老板和员工  才输出
        if(bossName.length() > 0 && empNameList.length() > 0 )
            context.write(new Text(bossName), new Text(empNameList));
    }
}

这里写图片描述

代码实现

package demo.revertedindex;

import java.io.IOException;

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;

public class RevertedIndexMapper extends Mapper<LongWritable, Text, Text, Text> {

    @Override
    protected void map(LongWritable key1, Text value1, Context context)
            throws IOException, InterruptedException {
        //得到数据来自哪个文件:  /indexdata/data01.txt
        String path = ((FileSplit)context.getInputSplit()).getPath().toString();

        //得到最后一个斜线的位置
        int index = path.lastIndexOf("/");
        //得到文件名
        String fileName = path.substring(index + 1);

        //数据：I love Beijing *******
        String data = value1.toString();
        String[] words = data.split(" ");

        //输出
        for(String w:words){
            context.write(new Text(w+":"+fileName), new Text("1"));
        }
    }

}
package demo.revertedindex;

import java.io.IOException;

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

public class RevertedIndexReducer extends Reducer<Text, Text, Text, Text> {

    @Override
    protected void reduce(Text k3, Iterable<Text> v3, Context context)
            throws IOException, InterruptedException {
        // 对combiner数据value，拼加
        String str = "";

        for(Text t:v3){
            str = "("+t.toString()+")" + str;
        }

        //输出
        context.write(k3, new Text(str));
    }

}
package demo.revertedindex;

import java.io.IOException;

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

public class RevertedIndexCombiner extends Reducer<Text, Text, Text, Text> {

    @Override
    protected void reduce(Text k21, Iterable<Text> v21, Context context)
            throws IOException, InterruptedException {
        // 求和：对同一个文件中的某个单词进行求和
        int total = 0;
        for(Text v:v21){
            total = total + Integer.parseInt(v.toString());
        }

        //分离：单词和文件名  k21:  love:data01.txt
        String data = k21.toString();
        //找到：的位置
        int index = data.indexOf(":");

        String word = data.substring(0, index);//单词
        String fileName = data.substring(index+1);//文件名

        //输出
        context.write(new Text(word), new Text(fileName+":"+total));
    }

}
package demo.revertedindex;

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


public class RevertedIndexMain {

    public static void main(String[] args) throws Exception {
        // 创建一个job：job = map + reduce
        Job job = Job.getInstance(new Configuration());

        //指定任务的入口
        job.setJarByClass(RevertedIndexMain.class);

        //指定任务的Mapper和输出的数据类型: k2  v2
        job.setMapperClass(RevertedIndexMapper.class);
        job.setMapOutputKeyClass(Text.class);    //指定k2
        job.setMapOutputValueClass(Text.class);  //指定v2

        //设置任务的combiner
        job.setCombinerClass(RevertedIndexCombiner.class);

        //指定任务的Reducer和输出的数据类型: k4 v4
        job.setReducerClass(RevertedIndexReducer.class);
        job.setOutputKeyClass(Text.class);   //指定k4
        job.setOutputValueClass(Text.class);   //指定v4

        //指定输入的路径（map）、输出的路径（reduce）
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        //执行任务
        job.waitForCompletion(true);

    }

}

单元测试

package demo.wc;

import java.io.IOException;

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

//public class WordCountMapper extends Mapper<k1, v1, k2, v2> {
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

    @Override
    protected void map(LongWritable key1, Text value1, Context context)
            throws IOException, InterruptedException {
        /*
         * context 代表Mapper的上下文
         * 上文：HDFS
         * 下文：Reducer
         */

        //取出数据:  I love Beijing
        String data = value1.toString();

        //分词
        String[] words = data.split(" ");

        //输出
        for(String word:words){
            //            k2 就是 单词                          v2: 记一次数
            context.write(new Text(word), new IntWritable(1));
        }
    }
}
package demo.wc;

import java.io.IOException;

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

//public class WordCountReducer extends Reducer<k3, v3, k4, v4> {
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {

    @Override
    protected void reduce(Text k3, Iterable<IntWritable> v3,Context context) throws IOException, InterruptedException {
        /*
         * context 代表reduce的上下文
         * 上文：Mapper
         * 下文：HDFS
         */

        //对v3进行求和
        int total = 0;
        for(IntWritable v:v3){
            total += v.get();
        }

        //输出：k4 单词     v4 频率
        context.write(k3, new IntWritable(total));
    }

}
package demo.wc;

import java.util.ArrayList;
import java.util.List;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mrunit.mapreduce.MapDriver;
import org.apache.hadoop.mrunit.mapreduce.MapReduceDriver;
import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
import org.junit.Test;

public class MRUnitWordCount {

    @Test
    public void testMapper() throws Exception{
        //设置一个环境变量
        System.setProperty("hadoop.home.dir", "D:\\temp\\hadoop-2.4.1\\hadoop-2.4.1");

        //创建一个测试对象
        WordCountMapper mapper = new WordCountMapper();

        //创建一个MapDriver进行单元测试
        MapDriver<LongWritable, Text, Text, IntWritable> driver = new MapDriver<>(mapper);

        //指定Map的输入数据: k1  v1
        driver.withInput(new LongWritable(1), new Text("I love Beijing"));

        //指定Map的输出：k2   v2  ----> 是我们期望得到结果
        driver.withOutput(new Text("I"), new IntWritable(1))
              .withOutput(new Text("love"), new IntWritable(1))
              .withOutput(new Text("Beijing"), new IntWritable(1));

        //执行单元测试：对比  期望的结果 和 实际的结果
        driver.runTest();
    }

    @Test
    public void testReducer() throws Exception{
        //设置一个环境变量
        System.setProperty("hadoop.home.dir", "D:\\temp\\hadoop-2.4.1\\hadoop-2.4.1");

        //创建一个测试对象
        WordCountReducer reducer = new WordCountReducer();

        //创建一个ReducerDriver进行单元测试
        ReduceDriver<Text, IntWritable, Text, IntWritable> driver = new ReduceDriver<>(reducer);

        //构造v3：List
        List<IntWritable> value3 = new ArrayList<>();
        value3.add(new IntWritable(1));
        value3.add(new IntWritable(1));
        value3.add(new IntWritable(1));


        //指定reducer的输入
        driver.withInput(new Text("Beijing"), value3);


        //指定reducer的输出
        driver.withOutput(new Text("Beijing"), new IntWritable(3));


        //执行测试
        driver.runTest();
    }

    @Test
    public void testJob() throws Exception{
        //设置一个环境变量
        System.setProperty("hadoop.home.dir", "D:\\temp\\hadoop-2.4.1\\hadoop-2.4.1");

        //创建一个测试对象
        WordCountMapper mapper = new WordCountMapper();     
        WordCountReducer reducer = new WordCountReducer();      

        //创建一个Driver
        //MapReduceDriver<K1, V1, K2, V2, K4, V4>
        MapReduceDriver<LongWritable, Text, Text, IntWritable, Text, IntWritable>
                driver = new MapReduceDriver<>(mapper,reducer);

        //指定Map输入的数据
        driver.withInput(new LongWritable(1), new Text("I love Beijing"))
              .withInput(new LongWritable(4), new Text("I love China"))
              .withInput(new LongWritable(7), new Text("Beijing is the capital of China"));

        //指定Reducer输出
//      driver.withOutput(new Text("I"), new IntWritable(2))
//            .withOutput(new Text("love"), new IntWritable(2))
//            .withOutput(new Text("Beijing"), new IntWritable(2))
//            .withOutput(new Text("China"), new IntWritable(2))
//            .withOutput(new Text("is"), new IntWritable(1))
//            .withOutput(new Text("the"), new IntWritable(1))
//            .withOutput(new Text("capital"), new IntWritable(1))
//            .withOutput(new Text("of"), new IntWritable(1));

        //需要考虑排序
        driver.withOutput(new Text("Beijing"), new IntWritable(2))
              .withOutput(new Text("China"), new IntWritable(2))
              .withOutput(new Text("I"), new IntWritable(2))
              .withOutput(new Text("capital"), new IntWritable(1))
              .withOutput(new Text("is"), new IntWritable(1))
              .withOutput(new Text("love"), new IntWritable(2))
              .withOutput(new Text("of"), new IntWritable(1))
              .withOutput(new Text("the"), new IntWritable(1));

        driver.runTest();
    }
}
Casablanca_jhBi
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据学习（八）：mapreduce编程案例-倒排索引创建
01-07
有如下数据 a.txt hello tom hello jim hello kitty hello rose b.txt hello jerry hello jim hello kitty hello jack c.txt hello jerry hello java hello c++ hello c++ 需要输出如下格式: c++ c.txt-->2 ...
MapReduce案列-数据去重
Pythonwudud的博客
12-19 3415
数据去重主要是为了掌握利用并行化思想来对数据进行有意义的筛选，数据去重指去除重复数据的操作。在大数据开发中，统计大数据集上的多种数据指标，这些复杂的任务数据都会涉及数据去重。
MapReduce编程开发之数据去重
feinifi的博客
09-02 1655
MapReduce就是一个利用分而治之的思想做计算的框架，所谓分，就是将数据打散，分成可以计算的小份，治就是将数据合并，相同键的数据合并成一个集合。MapReduce并不能解决所有的问题，因为他的数据类型是键值对，只能解决特定范围的问题。 数据去重算法，其实就是词频统计的一个变种，词频统计是统计文本中的单词出现的次数，如果一个单词出现两次，就算重复，去掉重复的办法就是保留一个副本...
Hadoop：全面深入解析
最新发布
CloudJourney的博客
06-30 1301
本文从定义、架构、原理、应用场景、常见命令、安装与配置、性能优化、安全性、未来发展和社区支持等多个方面对Hadoop进行了全面深入的解析。希望通过本文，读者能够对Hadoop有一个清晰和全面的认识，并能够在实际工作中灵活运用这一强大的工具，解决大规模数据处理和分析的挑战。未来，随着大数据技术的发展，Hadoop必将发挥更大的作用，帮助企业和组织从海量数据中获取更多的洞察和价值。同时，它也可以用于ETL（抽取、转换、加载）过程，将数据从不同源系统提取出来，进行清洗和转换，最后加载到数据仓库中。
MapReduce之去重
zhangdy12307的博客
04-20 1143
MapReduce之去重 模式描述 这个模式过滤整个数据集，过滤应用的最终输出结果是一个唯一记录的集合 目的 在拥有一系列相思的数据集记录中，找到唯一的集合 适用场景 对于数据集中存在重复值进行去重操作，如果数据中没有重复值的话，则不需要这个模式 使用场景为 数据去重 抽取重复值 规避内连接的数据膨胀 问题描述 给定一个用户评论的列表，得到去重的用户ID集 样例输入 样例文本生成代码如下 im...
MapReduce 之 数据去重
CV前沿
05-11 7321
最近要更新一些MapReduce实例应用的系列文章。文章结构上包括以下几个部分：1.、问题背景；2、基于MapReduce的解决思路；3、代码实现；4、运行结果。1. 问题背景随着数据信息量的急速增长，越来越多的人开始关注存储数据的数据去重技术。数据去重是指对所有的数据进行一个有意义的筛选，去除掉冗余的数据。例如统计大数据集上的数据种类个数、从网站日志中计算访问地等都会涉及到数据去重。下面通过一个例
Mapreduce实现Wordcount
qq_43486230的博客
11-19 619
Mapreduce实现Wordcount一、程序实现1.1 mapper类：1.2 reducer类：1.3 main类：二、操作实例2.1 打包2.2 数据操作 一、程序实现 1.1 mapper类： // Mapper的四个参数：第一个Object表示输入key的类型；第二个Text表示输入value的类型；第三个Text表示表示输出键的类型；第四个IntWritable表示输出值的类型。 public static class doMapper extends Mapper<Obj
0324大数据代码与数据_JAVA大数据_文本分析_运用MapReduce做数据分析_
09-30
总的来说，"0324大数据代码与数据_JAVA大数据_文本分析_运用MapReduce做数据分析_"项目涵盖了大数据处理的关键技术，包括Java编程、MapReduce模型、文本分析以及可能的数据存储和可视化。通过学习和实践这个项目，...
词频统计+倒排索引+数据去重+TopN
01-24
在IT领域，尤其是在大数据处理和搜索引擎技术中，"词频统计+倒排索引+数据去重+TopN"是...通过运用MapReduce进行词频统计、构建倒排索引、执行数据去重和获取TopN结果，可以有效地处理大规模数据并提供高效的查询服务。
大数据实验四-MapReduce编程实践
04-03
### 大数据实验四-MapReduce编程实践 #### 一、实验内容与目的 ##### 实验内容概述 本次实验的主要内容是使用MapReduce框架来实现WordCount词频统计功能，即统计HDFS（Hadoop Distributed File System）系统中多个...
大数据实验报告Hadoop编程实现InvertedIndex文档倒排索引程序附源码.doc
12-06
大数据实验报告中，实现了使用Hadoop编程的InvertedIndex文档倒排索引程序。该程序使用Hadoop的MapReduce框架，通过Map、Combine和Reduce三个阶段，实现了文档倒排索引的生成。 标题解释： 大数据实验报告Hadoop...
Hadoop-MapReduce实践示例
06-20
初学大数据hadoop，自己写实践练手的示例，示例非常全，带目录，非常清晰。
007_hadoop中MapReduce应用案例_1_数据去重
08-06
NULL 博文链接：https://zc985552943.iteye.com/blog/2088221
大数据学习（八）：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经典案例—数据去重
一指流沙的博客
06-03 7544
数据去重主要是为了掌握利用并行化思想来对数据进行有意义的筛选，数据去重指去除重复数据的操作。在大数据开发中，统计大数据集上的多种数据指标，这些复杂的任务数据都会涉及数据去重。文件file1.txt本身包含重复数据，并且与file2.txt同样出现重复数据，现要求使用Hadoop大数据相关技术对以上两个文件进行去重操作，并最终将结果汇总到一个文件中。 (1) 编写MapReduce程序，在Map阶段采用Hadoop默认作业输入方式后，将key设置为需要去重的数据，而输出的value可以任意设置为空。 (2)
Mapreduce实例（三）：数据去重
笑看风云路的博客
05-31 2680
MR实现数据去重
第四章：Hadoop编程
06-21
MapReduce Shuffle过程使用MRUnit进行单元测试过程MapReduce 数据压缩：Snappy,Gzip,LZOMapReduce Partitioner,Combiner实现及应用MapReduce编程：实现数据去重，数据二次排序，倒排索引使用MapReduce实现微博情感分析与单元测试使用MapReduce用户终端情况分析与单元测试
014 Shuffle的概念介绍 Shuffle的细节图描述 分区案例 倒排索引案例
C_time的博客
05-30 776
Awk和MapReduce的处理方式比较
hadoop----mapreduce的案例（四）（利用shuffle进行排序）
WQY992的博客
06-13 541
案例四 使用MapReduce程序读取三个文件中的数据，进行排序(利用shuffle阶段的排序) 注意：shuffle阶段的排序是针对key进行排序的 map函数 public class MyMapper extends Mapper<LongWritable, Text, LongWritable, LongWritable>{ @Override protected v...
运用MapReduce编程实现数据去重
05-20
MapReduce是一种分布式计算框架，用于处理大规模数据集。在MapReduce中，数据被分成小块，并分配给多个计算节点进行处理。在进行数据去重时，可以使用MapReduce编程模型来实现。 以下是使用MapReduce编程实现数据去重的步骤： 1. Map阶段：将输入数据切分成小块，并对每个小块进行处理。在处理时，可以使用哈希表来进行数据去重，将每个不同的数据作为键值对的键，将任意值作为值存储在哈希表中。这样，相同的数据将被哈希表合并为一个键值对，完成数据去重。 2. Shuffle阶段：将Map阶段输出的键值对按照键进行排序，将相同的键值对聚合在一起。 3. Reduce阶段：对Shuffle阶段输出的键值对进行处理，将相同的键值对合并为一个键值对输出。这样，就完成了数据去重操作。 下面是使用Python实现MapReduce程序的示例代码： ``` from mrjob.job import MRJob class DataDeduplication(MRJob): def mapper(self, _, line): data = line.strip() yield data, 1 def reducer(self, data, _): yield data, None if __name__ == '__main__': DataDeduplication.run() ``` 在上面的代码中，mapper函数将输入数据作为键值对的键，将任意值作为值输出。在reducer函数中，将相同的键值对合并为一个键值对，输出不包含值的键值对，完成数据去重操作。 以上就是使用MapReduce编程实现数据去重的步骤和示例代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值