MapReduce框架运用及案例分析（详解）---------------资料分享在最后的链接

最新推荐文章于 2024-08-17 21:28:57 发布
最新推荐文章于 2024-08-17 21:28:57 发布
阅读量1.1k 收藏 5
点赞数
分类专栏： MapReduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41166135/article/details/81986902
版权

所有的实例都在本地进行，启动使用上篇文章的第三种方式
1.电影评分的平均值（所用文件rating.json）
原始数据:{“movie”:”1193”,”rate”:”5”,”timeStamp”:”978300760”,”uid”:”1”}
结果显示：1000 3
1002 4
1003 2
1004 2
1005 2
思路：利用JSON转换工具将数据封装为对象，方便去使用，在Map阶段，将movie和rate作为key、value值，在Reduce阶段将movie和平均评分作为key、value值
(1)封装代码块

public class MovieBean {
private String movie;
private int rate;
private String timeStamp;
private String uid;
public String getMovie() {
    return movie;
}
public void setMovie(String movie) {
    this.movie = movie;
}
public int getRate() {
    return rate;
}
public void setRate(int rate) {
    this.rate = rate;
}
public String getTimeStamp() {
    return timeStamp;
}
public void setTimeStamp(String timeStamp) {
    this.timeStamp = timeStamp;
}
public String getUid() {
    return uid;
}
public void setUid(String uid) {
    this.uid = uid;
}
@Override
public String toString() {
    return "MovieBean [movie=" + movie + ", rate=" + rate + ", timeStamp=" + timeStamp + ", uid=" + uid + "]";
}

（2）具体的map、reduce实现


import java.io.File;
import java.io.IOException;

import org.apache.commons.io.FileUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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;
import org.codehaus.jackson.map.ObjectMapper;


public class Avg {
public static class MapTask extends Mapper<LongWritable, Text, Text, IntWritable>   {
    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context)
            throws IOException, InterruptedException {
        ObjectMapper objectMapper = new ObjectMapper();//使用ObjectMapper类进行json的转换
        MovieBean bean = objectMapper.readValue(value.toString(), MovieBean.class);
        context.write(new Text(bean.getMovie()), new IntWritable(bean.getRate()));  //读每一行数据，将电影和评分找出来
    }
}

public static class ReduceTask extends Reducer<Text, IntWritable, Text, IntWritable>{
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values,
            Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
        int sum = 0;
        int count = 0;
        for (IntWritable intWritable : values) {
            sum += intWritable.get();//进行评分的求和
            count++;                 //进行电影个数的统计
        }
        context.write(new Text(key), new IntWritable(sum/count));//求出平均评分

    }
}


public static void main(String[] args) {
    try {
        //System.setProperty("HADOOP_USER_NAME", "SIMPLE");
        Configuration conf = new Configuration();

        Job job = Job.getInstance(conf);

        // 设置map和reduce，以及提交的jar
        job.setMapperClass(MapTask.class);
        job.setReducerClass(ReduceTask.class);
        job.setJarByClass(Avg.class);

        // 设置输入输出类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        // 判断文件是否存在
        File file = new File("d:\\data\\out\\movie");
        if (file.exists()) {
            FileUtils.deleteDirectory(file);
        }
        // 输入和输出目录
        FileInputFormat.addInputPath(job, new Path("D:\\data\\in\\movie\\rating.json"));
        FileOutputFormat.setOutputPath(job, new Path("d:\\data\\out\\movie"));

        // 提交任务
        boolean completion = job.waitForCompletion(true);
        System.out.println(completion ? "你很优秀！！！" : "滚去调bug！！");

    } catch (Exception e) {
        e.printStackTrace();
        // TODO: handle exception
    }

}
}

2.求两个用户之间的共同好友
原始数据：A:B,C,D,F,E,O
B:A,C,E,K
A和B的共同好友是C和E
结果： 第一个mapreduce:B-C A B-D A
第二个mapreduce:A-B E C A-C D F
思路：1.因为每个用户的共同好友利用mapreduce不好实现，所以反过来求好友的用户
这样就能求出来好友有哪些用户，两两组合起来用户就是用户的共同好友
2.根据第一个结果将结果的Value值两两组合起来就OK

（1）

public class Compile {
  public static class MapTask extends Mapper<LongWritable, Text,Text, Text>{
      @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
            throws IOException, InterruptedException {
        String[] user = value.toString().split(":");//将用户和好友分开
        String[] friend = user[1].split(",");       //将好友分开
            for (String string1 : friend) {
                context.write(new Text(string1),new Text(user[0]) );
                                                   //key是好友，value是用户

            }
        }
  }
  public static class ReduceTask extends Reducer<Text, Text, Text, Text>{
      @Override
    protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, Text>.Context context)
            throws IOException, InterruptedException {
        //利用集合将两个用户进行组合，求出共同好友
          List<String> userList = new ArrayList<>();
          for (Text string : values) {
              userList.add(string.toString());

        }
          Collections.sort(userList); //需要排序是因为避免A-B/B-Akey值不相同的情况，排完序从前往后遍历就OK
          for(int i=0;i<userList.size()-1;i++) {
              for(int j=i+1;j<userList.size();j++) {
                  context.write(new Text(userList.get(i)+"-"+userList.get(j)), key);
              }
          }

    }
  }
  public static void main(String[] args) {
      try {

            Configuration conf = new Configuration();

            Job job = Job.getInstance(conf);
            job.setMapperClass(MapTask.class);
            job.setReducerClass(ReduceTask.class);
            job.setJarByClass(Compile.class);

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

            FileSystem fs = FileSystem.get(conf);
            if(fs.exists(new Path("d:\\data\\out\\friend"))) {
                fs.delete(new Path("d:\\data\\out\\friend"),true);
            }

            FileInputFormat.addInputPath(job, new Path("e:\\data\\friend.txt"));
            FileOutputFormat.setOutputPath(job, new Path("d:\\data\\out\\friend"));

            boolean completion = job.waitForCompletion(true);
            System.out.println(completion?"成功":"失败");
        }
        catch(Exception e) {

        }
        }

（2）将每两个用户的好友求出来,资料是friend


 class Compile2 {
     public static class MapTask extends Mapper<LongWritable, Text,Text, Text>{
         @Override
        protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
                throws IOException, InterruptedException {
            String[] split = value.toString().split("\t");//以tab分隔，将两个用户的共同好友传给reduce
            context.write(new Text(split[0]), new Text(split[1]));
      }
      public static class ReduceTask extends Reducer<Text, Text, Text, Text>{
          @Override
        protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, Text>.Context context)
                throws IOException, InterruptedException {
              String friends="";
            for (Text text : values) {
                friends += text+" ";
            }
          context.write(new Text(key),new Text(friends));//将共同好友求出

            }


        }
      }
      public static void main(String[] args) {
          try {

                Configuration conf = new Configuration();

                Job job = Job.getInstance(conf);
                job.setMapperClass(MapTask.class);
                job.setReducerClass(ReduceTask.class);
                job.setJarByClass(Compile2.class);

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

                FileSystem fs = FileSystem.get(conf);
                if(fs.exists(new Path("d:\\data\\out\\friend1"))) {
                    fs.delete(new Path("d:\\data\\out\\friend1"),true);
                }

                FileInputFormat.addInputPath(job, new Path("d:\\data\\out\\friend\\part-r-00000"));
                FileOutputFormat.setOutputPath(job, new Path("d:\\data\\out\\friend1"));

                boolean completion = job.waitForCompletion(true);
                System.out.println(completion?"成功":"失败");
            }
            catch(Exception e) {

            }
            }

3.求出每个网站的上行流量、下行流量以及流量总和（自己定义Hadoop的序列化类）资料是DATA
原始数据
15639120688 http://v.baidu.com/movie 3936 12058
13905256439 http://movie.youku.com 10132 538
结果
blog.csdn.net FlowBean [up=239908231, down=238717280, sum=478625511]
image.baidu.com FlowBean [up=118511778, down=117759776, sum=236271554]
思路：将同一个网址作为key，流量作为value，当计算他们的流量总和，因为value涉及三个数据，不好管理，所以封装起来。
（1）`import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

import org.apache.hadoop.io.Writable;

public class FlowBean implements Writable { //实现这个接口去增加hadoop的序列化类型
private long up;
private long down;
private long sum;

public void set(long up, long down) {
this.up = up;
this.down = down;
this.sum = up+down;
}
public long getUp() {
return up;
}
public void setUp(long up) {
this.up = up;
}
public long getDown() {
return down;
}
public void setDown(long down) {
this.down = down;
}
public long getSum() {
return sum;
}
public void setSum(long sum) {
this.sum = sum;
}
@Override
public String toString() {
return “FlowBean [up=” + up + “, down=” + down + “, sum=” + sum + “]”;
}
**@Override //序列化与反序列化
public void readFields(DataInput in) throws IOException {
up = in.readLong();
down = in.readLong();
sum = in.readLong();

}
@Override
public void write(DataOutput out) throws IOException {
// TODO Auto-generated method stub
out.writeLong(up);
out.writeLong(down);
out.writeLong(sum);

}`**
(2)MapReduce的实现

public class FlowMR {
    public static class MapTask extends Mapper<LongWritable, Text, Text, FlowBean> {
        public String reg(String url) {//为了实现截取中间的网址
            Pattern pattern = Pattern.compile("(\\w+\\.)?(\\w+\\.){1}\\w+");//传入正则表达式
            Matcher matcher = pattern.matcher(url); //匹配url
            while(matcher.find()){//找到匹配的话生成新的url
                String newUrl = matcher.group();
                return newUrl;
            }
            return null;


        }

        @Override
        protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, FlowBean>.Context context)
                throws IOException, InterruptedException {
            try {

                String[] split = value.toString().split("\t")[1].split(" ");
                long up = Long.parseLong(split[1]);
                long down = Long.parseLong(split[2]);
                String url = reg(split[0]);
                FlowBean fb = new FlowBean();
                fb.set(up, down);
                context.write(new Text(url), fb);//将每一行的url和计算好的流量传给reduce

            } catch (Exception e) {

            }
            // TODO: handle exception
        }
    }

    public static class ReduceTask extends Reducer<Text, FlowBean, Text, FlowBean> {

        @Override
        protected void reduce(Text key, Iterable<FlowBean> values,
                Reducer<Text, FlowBean, Text, FlowBean>.Context context) throws IOException, InterruptedException {
            long up = 0;
            long down = 0;
            FlowBean fb = new FlowBean();
            for (FlowBean flowBean : values) {
                up += flowBean.getUp();
                down += flowBean.getDown();//计算总的上行和下行流量
            }
            fb.set(up, down);
            context.write(key, fb);
        }
    }

    public static void main(String[] args) {
        try {
            //System.setProperty("HADOOP_USER_NAME", "SIMPLE");
            Configuration conf = new Configuration();

            Job job = Job.getInstance(conf);

            // 设置map和reduce，以及提交的jar
            job.setMapperClass(MapTask.class);
            job.setReducerClass(ReduceTask.class);
            job.setJarByClass(FlowMR.class);

            // 设置输入输出类型
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(FlowBean.class);

            jo b.setOutputKeyClass(Text.class);
            job.setOutputValueClass(FlowBean.class);
            // 判断文件是否存在
            File file = new File("d:\\data\\out\\http");
            if (file.exists()) {
                FileUtils.deleteDirectory(file);
            }
            // 输入和输出目录
            FileInputFormat.addInputPath(job, new Path("E:/data/DATA.txt"));
            FileOutputFormat.setOutputPath(job, new Path("d:\\data\\out\\http"));

            // 提交任务
            boolean completion = job.waitForCompletion(true);
            System.out.println(completion ? "你很优秀！！！" : "滚去调bug！！");

        } catch (Exception e) {
            e.printStackTrace();
            // TODO: handle exception
        }

    }
}

4.实现，每个关键词后面，显示所有包含关键词的文件的集合（获取每个词的文件名称）资料是index里面
初始数据：hello hello java c vb c#
hi xiaoming
hello honghong
结果数据：第一个MapReduce: am-b.txt 1
c#-a.txt 1
第二个MapReduce：c a.txt 1， b.txt 1
c# a.txt 1, b.txt 1
思路：首先将每一个文件中的词统计出来，以及在每个文件中的个数
第二个MapReduce将相同词的文件合并起来

（1）

public class CreateUndexOne {
    //  hello  hello hadoop  --------> hello-a.txt  1
    public static class MapTask extends Mapper<LongWritable, Text, Text, IntWritable>{
        @Override
        protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context)
                throws IOException, InterruptedException {
            **FileSplit fileSplit = (FileSplit)context.getInputSplit();
            String name = fileSplit.getPath().getName();**//可以获取关键词所在文件的名称
            String[] split = value.toString().split(" ");
            for (String string : split) {
                context.write(new Text(string + "-" +name), new IntWritable(1));//将每个文件的名称和其个数传给Reduce
            }
        }
    }

    public static class ReduceTask extends Reducer<Text, IntWritable, Text, IntWritable>{
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values,
                Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
            int count = 0;
            for (IntWritable intWritable : values) {  //统计每个关键词的个数
                count++;
            }
            context.write(key, new IntWritable(count));
        }
    }

    public static void main(String[] args) {
        try {
            //System.setProperty("HADOOP_USER_NAME", "SIMPLE");
            Configuration conf = new Configuration();

            Job job = Job.getInstance(conf);

            // 设置map和reduce，以及提交的jar
            job.setMapperClass(MapTask.class);
            job.setReducerClass(ReduceTask.class);
            job.setJarByClass(CreateUndexOne.class);

            // 设置输入输出类型
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(IntWritable.class);

            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
            // 判断文件是否存在
            File file = new File("d:\\data\\out\\indexOne");
            if (file.exists()) {
                FileUtils.deleteDirectory(file);
            }
            // 输入和输出目录
            FileInputFormat.addInputPath(job, new Path("D:\\data\\in\\index"));
            FileOutputFormat.setOutputPath(job, new Path("d:\\data\\out\\indexOne"));

            // 提交任务
            boolean completion = job.waitForCompletion(true);
            System.out.println(completion ? "你很优秀！！！" : "滚去调bug！！");

        } catch (Exception e) {
            e.printStackTrace();
            // TODO: handle exception
        }

    }


}

（2）

public class CreateUndexTwo {
  public static class MapTask extends Mapper<LongWritable, Text, Text, Text>{
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
        throws IOException, InterruptedException {
    String[] split = value.toString().split("-");
    context.write(new Text(split[0]), new Text(split[1])); //将关键词和所属文件分开方便后边的文件合并
}
  }

  public static class ReduceTask extends Reducer<Text, Text, Text, Text>{
      @Override
    protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, Text>.Context context)
            throws IOException, InterruptedException {
          StringBuilder sb =new  StringBuilder();
          boolean flag=true;
        for (Text text : values) {//实现最后一个单词后面没有逗号
            if(flag) {
                sb.append(text.toString());
                flag=false;
            }
            else {
                sb.append(",");
                sb.append(text.toString());
            }
        }
        context.write(key, new Text(sb.toString()));  //实现文件的多个合并
    }
  }



  public static void main(String[] args) {
        try {
            //System.setProperty("HADOOP_USER_NAME", "SIMPLE");
            Configuration conf = new Configuration();

            Job job = Job.getInstance(conf);

            // 设置map和reduce，以及提交的jar
            job.setMapperClass(MapTask.class);
            job.setReducerClass(ReduceTask.class);
            job.setJarByClass(CreateUndexTwo.class);

            // 设置输入输出类型
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(Text.class);

            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(Text.class);
            // 判断文件是否存在
            File file = new File("d:\\data\\out\\indexTwo\\");
            if (file.exists()) {
                FileUtils.deleteDirectory(file);
            }
            // 输入和输出目录
            FileInputFormat.addInputPath(job, new Path("d:\\data\\out\\indexOne"));
            FileOutputFormat.setOutputPath(job, new Path("d:\\data\\out\\indexTwo\\"));

            // 提交任务
            boolean completion = job.waitForCompletion(true);
            System.out.println(completion ? "你很优秀！！！" : "滚去调bug！！");

        } catch (Exception e) {
            e.printStackTrace();
            // TODO: handle exception
        }

    }
}
`

链接：https://pan.baidu.com/s/1nYNfl8dHTEmP3Pq56Lkd9A 密码：9jum

longG_It
关注
专栏目录
MapReduce开发案例
03-07
我的第一个MapReduce程序，对基础代码进行了，些许的优化，如果是才开始学的可以参考一下，老手emmm，帮忙看错，嘻嘻(最后要加上fs.close(); 作者打包的时候忘了加了)
mapreduce的一个实例
yaoyaostep的专栏
10-12 1034
1、MapReduce理论简介   1.1 MapReduce编程模型 MapReduce采用"分而治之"的思想，把对大规模数据集的操作，分发给一个主节点管理下的各个分节点共同完成，然后通过整合各个节点的中间结果，得到最终结果。简单地说，MapReduce就是"任务的分解与结果的汇总"。 在Hadoop中，用于执行MapReduce任务的机器角色有两个：一个是JobTrac
Hadoop(九)MapReduce 案例2
最新发布
技术博客
08-17 804
mapreduce java 案例
大数据mapreduce案例
08-25
大数据mapreduce案例介绍，包括代码解释，详解MRS工作流程
MapReduce运用-案例讲解
CDHong.it的技术分享博客
10-29 3430
MapReduce 是 Google 公司开源的一项重要技术，它是一个编程模型，用以进行大数据量的计算。MapReduce 是一种简化的并行计算编程模型，它使那些没有多少并行计算经验的开发人员也可以开发并行应用程序。 模型非常方便使用，即使是对于完全没有分布式程序的程序员也是如此。它隐藏了并行计算的细节。MapReduce运行开发人员使用自己熟悉的语言进行开发。 通过MapReduce，应用程序可以在超过1000个节点的大型集群上运行，并且提供经过优化的错误容灾。
MapReduce实例浅析
weixin_34005042的博客
12-18 157
在文章《MapReduce原理与设计思想》中，详细剖析了MapReduce的原理，这篇文章则通过实例重点剖析MapReduce 本文地址：http://www.cnblogs.com/archimedes/p/mapreduce-example-analysis.html，转载请注明源地址。 欢迎关注我的个人博客：www.wuyudong.com, 更多云计算与大数据的精彩文章 1.MapR...
基于MPP-Hadoop混合架构高校数据集成系统研究
05-22
Hadoop是一个开源的分布式存储与计算框架，它由HDFS（Hadoop Distributed File System，Hadoop分布式文件系统）和MapReduce编程模型组成。HDFS能够存储和管理海量数据集，并保证数据在多个存储节点之间的高可靠性。...
大数据分析与决策(2016-1).ppt
05-12
- **分布式计算框架**：如Hadoop MapReduce、Spark等，用于处理大规模数据集。 - **数据仓库**：如Hive、Impala等，提供数据查询和分析服务。 - **流式处理**：如Storm、Flink等，处理实时数据流。 #### 三、...
大数据开发教程-介绍大数据开发的基本概念、技术架构、工具和案例，并提供一些总结和建议
04-12
### 大数据开发教程知识点详解 #### 一、大数据开发基本概念 1. **大数据定义**： - **规模巨大**：数据集的大小远远超出传统数据处理软件所能有效处理的范围。 - **类型多样**：数据不仅包括结构化数据（如关系...
Hadoop MapReduce v2 Cookbook, 2nd Edition-Packt Publishing(2015) 高清完整版PDF下载
02-27
#### 五、案例研究：利用Hadoop MapReduce V2 进行大数据分析 本书通过一系列实用案例展示了如何利用Hadoop MapReduce V2解决实际问题。例如： - **日志分析**：通过MapReduce对大量日志数据进行分析，提取有价值...
mailman-MapReduce:我正在整理的面向 Hadoop 的演示
07-04
在本案例中，我们可能创建一个外部表，指向MapReduce处理后的数据，通过HQL（Hive Query Language）进行复杂的分析和报表生成。 六、结论 Mailman-MapReduce的整合展示了如何利用Hadoop的分布式计算能力处理大量...
MapReduce综合案例（4个）
06-16
1.社交网络综合评分案例 2.微博精准营销案例 3.物品推荐案例 4.QQ好友推荐案例
MapReduce的两个简单例子
08-12
对应的博客地址：http://blog.csdn.net/huhui_cs/article/details/9907951
走向云计算之MapReduce应用案例详解
想作会飞的鱼的博客
06-14 4768
一、概述前面关于MapReduce的wordcount程序已经做了比较详细的分析，这里再给出MapReduce应用的几个小案例，来更加深入的理解MapReduce的设计理念和应用方法。部分内容参考了书籍《hadoop实战》中的内容。二、MapReduce应用之数据去重在统计大数据集上的数据种类个数、从网站日志中计算访问地等这些看似庞杂的任务都会涉及数据去重这个操作。1、情境要求假设有如下两个数据样本
MapReduce实战小案例（自定义排序、二次排序、分组、分区）
fengxiandada的博客
06-26 7038
MapReduce实战小案例
MapReduce几个典型的例子
Athenaer的专栏
02-29 7498
在Google的《MapReduce: Simpli ed Data Processing on Large Clusters》论文中，作者向世界阐述了什么是MapReduce。其中的几个关于MapReduce的例子很简单，但是很有代表性。拿来分享一下。        分布式Grep：map函数检查输入行，如果匹配给定的模板（类似于正则表达式的匹配），就把该行输出。reduce函数是一个标识函数
【Hadoop笔记_3】MapReduce、案例分析、实例分析代码
REDANDBLUE_OvO的博客
04-26 7926
由于文章太长，其余部分在我的其他几篇博客中！ 第一部分 第二部分 5、MapReduce 5.1_简介 MapReduce是一个分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。 MapReduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上。 5.2_MapReduce的优缺点 优点 MapReduce易编程 它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量.
MapReduce应用实例
wtq1993的博客
05-17 5914
1.各个部门的总工资如何进行问题分析的? 2.各个部门的总工资处理流程是怎样的？ 3.个部门的人数和平均工资又是如何得到的？ 4.个部门的人数和平均工资代码如何实现？ 案例所用包全部下载：链接: http://pan.baidu.com/s/1sjNyDIX 密码: 游客，如果您要查看本帖隐藏内容请回复 1、环境说明 部署节点操作系统为CentOS，防
MapReduce案例（五）
weixin_37901366的博客
04-21 1956
/分区规则,根据订单ID实现分区/**** @param text v2(一行的文本数据)* @param i ReduceTask个数* @return 分区编号*/@Override//根据订单id进行分区。
《Hadoop应用开发技术详解》- 大数据技术深度解析
1. **Hadoop生态系统**：Hadoop是Apache软件基金会的一个开源项目，它构建了一个分布式文件系统（HDFS）和一个计算框架（MapReduce），支持大规模数据处理。Hadoop生态系统还包括许多其他组件，如YARN（用于资源调度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值