MapReduce自定义排序编程

最新推荐文章于 2024-05-07 09:25:05 发布
最新推荐文章于 2024-05-07 09:25:05 发布
阅读量50 收藏
点赞数
文章标签： mapreduce 大数据 hadoop hive spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013603364/article/details/124207779
版权

排序和分组
  • 在map和reduce阶段进行排序时，比较的是k2。v2是不参与排序比较的。如果要想让v2也进行排序，需要把k2和v2组装成新的类，作为k2，才能参与比较。
  • 分组时也是按照k2进行比较的。

案例说明

数据：



zhangsan@163.com600002014-02-20
lisi@163.com200002014-02-20
lisi@163.com01002014-02-20
zhangsan@163.com300002014-02-20
wangwu@126.com900002014-02-20
wangwu@126.com02002014-02-20
6
1 
zhangsan@163.com600002014-02-20
2 
lisi@163.com200002014-02-20
3 
lisi@163.com01002014-02-20
4 
zhangsan@163.com300002014-02-20
5 
wangwu@126.com900002014-02-20
6 
wangwu@126.com02002014-02-20

数据分析

  • SumStep
    用户收入支出结余
    lisi@163.com20001001900
    wangwu@126.com90002008800
    zhangsan@163.com900009000
  • SortStep
    用户收入支出结余
    zhangsan@163.com900009000
    wangwu@126.com90002008800
    lisi@163.com20001001900

InfoBean类

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

  import org.apache.hadoop.io.WritableComparable;

  public class InfoBean implements WritableComparable<InfoBean>{

    private String accout;
    private double incom;
    private double zhichu;
    private double jieyu;

    @Override
    public void write(DataOutput out) throws IOException {
      // TODO Auto-generated method stub
      out.writeUTF(accout);
      out.writeDouble(incom);
      out.writeDouble(zhichu);
      out.writeDouble(jieyu);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
      // TODO Auto-generated method stub
      this.accout=in.readUTF();
      this.incom=in.readDouble();
      this.zhichu=in.readDouble();
      this.jieyu=in.readDouble();
    }

    @Override
    public int compareTo(InfoBean infoBean) {
      if(this.incom == infoBean.getIncom()){
        return this.zhichu > infoBean.getZhichu() ? 1 : -1;
      }else{
        return this.incom > infoBean.getIncom() ? -1 : 1;
      }
    }

    public String getAccout() {
      return accout;
    }

    public void setAccout(String accout) {
      this.accout = accout;
    }

    public double getIncom() {
      return incom;
    }

    public void setIncom(double incom) {
      this.incom = incom;
    }

    public double getZhichu() {
      return zhichu;
    }

    public void setZhichu(double zhichu) {
      this.zhichu = zhichu;
    }

    public double getJieyu() {
      return jieyu;
    }

    public void setJieyu(double jieyu) {
      this.jieyu = jieyu;
    }

    @Override
    public String toString() {
      return incom +"\t" + zhichu +"\t" + jieyu;
    }

    public void set(String accout,double incom,double zhichu){
      this.accout=accout;
      this.incom=incom;
      this.zhichu=zhichu;
      this.jieyu=incom - zhichu;
    }
  }
84
1 
  import java.io.DataInput;
2 
  import java.io.DataOutput;
3 
  import java.io.IOException;
4
5 
  import org.apache.hadoop.io.WritableComparable;
6
7 
  public class InfoBean implements WritableComparable<InfoBean>{
8
9 
    private String accout;
10 
    private double incom;
11 
    private double zhichu;
12 
    private double jieyu;
13
14 
    @Override
15 
    public void write(DataOutput out) throws IOException {
16 
      // TODO Auto-generated method stub
17 
      out.writeUTF(accout);
18 
      out.writeDouble(incom);
19 
      out.writeDouble(zhichu);
20 
      out.writeDouble(jieyu);
21 
    }
22
23 
    @Override
24 
    public void readFields(DataInput in) throws IOException {
25 
      // TODO Auto-generated method stub
26 
      this.accout=in.readUTF();
27 
      this.incom=in.readDouble();
28 
      this.zhichu=in.readDouble();
29 
      this.jieyu=in.readDouble();
30 
    }
31
32 
    @Override
33 
    public int compareTo(InfoBean infoBean) {
34 
      if(this.incom == infoBean.getIncom()){
35 
        return this.zhichu > infoBean.getZhichu() ? 1 : -1;
36 
      }else{
37 
        return this.incom > infoBean.getIncom() ? -1 : 1;
38 
      }
39 
    }
40
41 
    public String getAccout() {
42 
      return accout;
43 
    }
44
45 
    public void setAccout(String accout) {
46 
      this.accout = accout;
47 
    }
48
49 
    public double getIncom() {
50 
      return incom;
51 
    }
52
53 
    public void setIncom(double incom) {
54 
      this.incom = incom;
55 
    }
56
57 
    public double getZhichu() {
58 
      return zhichu;
59 
    }
60
61 
    public void setZhichu(double zhichu) {
62 
      this.zhichu = zhichu;
63 
    }
64
65 
    public double getJieyu() {
66 
      return jieyu;
67 
    }
68
69 
    public void setJieyu(double jieyu) {
70 
      this.jieyu = jieyu;
71 
    }
72
73 
    @Override
74 
    public String toString() {
75 
      return incom +"\t" + zhichu +"\t" + jieyu;
76 
    }
77
78 
    public void set(String accout,double incom,double zhichu){
79 
      this.accout=accout;
80 
      this.incom=incom;
81 
      this.zhichu=zhichu;
82 
      this.jieyu=incom - zhichu;
83 
    }
84 
  }

SumStep类

 

import java.io.IOException;
  import org.apache.hadoop.conf.Configuration;
  import org.apache.hadoop.fs.Path;
  import org.apache.hadoop.io.LongWritable;
  import org.apache.hadoop.io.Text;
  import org.apache.hadoop.mapreduce.Job;
  import org.apache.hadoop.mapreduce.Mapper;
  import org.apache.hadoop.mapreduce.Reducer;
  import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
  import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

  public class SumStep {

    public static void main(String[] args) throws Exception {
      // TODO Auto-generated method stub
      Job job=Job.getInstance(new Configuration());

      job.setJarByClass(SumStep.class);

      job.setMapperClass(SumMapper.class);
      job.setMapOutputKeyClass(Text.class);
      job.setMapOutputValueClass(InfoBean.class);
      FileInputFormat.setInputPaths(job, args[0]);

      job.setReducerClass(sumReducer.class);
      job.setOutputKeyClass(Text.class);
      job.setOutputValueClass(InfoBean.class);
      FileOutputFormat.setOutputPath(job, new Path(args[1]));

      job.waitForCompletion(true);
    }
       public static class SumMapper extends Mapper<LongWritable, Text, Text, InfoBean>{

      private Text k2 = new Text();
      private InfoBean v2 = new InfoBean();
           
      @Override
      protected void map(LongWritable key, Text value, 
      Mapper<LongWritable, Text, Text, InfoBean>.Context context)
          throws IOException, InterruptedException {
        String line=value.toString();
        String[] hang=line.split("\t");
        String accout=hang[0];
        double incom=Double.parseDouble(hang[1]);
        double zhichu=Double.parseDouble(hang[2]);

        k2.set(accout);
        v2.set(accout, incom, zhichu);
        context.write(k2, v2);
      }

    }
     public static class sumReducer extends Reducer<Text, InfoBean, Text, InfoBean>{
        private InfoBean v3 = new InfoBean();
         
      @Override
      protected void reduce(Text k2, Iterable<InfoBean> v2, 
      Reducer<Text, InfoBean, Text, InfoBean>.Context context)
          throws IOException, InterruptedException {
        double sumIncom = 0;
        double sumZhichu = 0;
        for(InfoBean infoBean : v2){
          sumIncom += infoBean.getIncom();
          sumZhichu += infoBean.getZhichu();
        }
        v3.set("", sumIncom, sumZhichu);
        context.write(k2, v3);
      }
    }
  }
x
1 
  import java.io.IOException;
2 
  import org.apache.hadoop.conf.Configuration;
3 
  import org.apache.hadoop.fs.Path;
4 
  import org.apache.hadoop.io.LongWritable;
5 
  import org.apache.hadoop.io.Text;
6 
  import org.apache.hadoop.mapreduce.Job;
7 
  import org.apache.hadoop.mapreduce.Mapper;
8 
  import org.apache.hadoop.mapreduce.Reducer;
9 
  import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
10 
  import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
11
12 
  public class SumStep {
13
14 
    public static void main(String[] args) throws Exception {
15 
      // TODO Auto-generated method stub
16 
      Job job=Job.getInstance(new Configuration());
17
18 
      job.setJarByClass(SumStep.class);
19
20 
      job.setMapperClass(SumMapper.class);
21 
      job.setMapOutputKeyClass(Text.class);
22 
      job.setMapOutputValueClass(InfoBean.class);
23 
      FileInputFormat.setInputPaths(job, args[0]);
24
25 
      job.setReducerClass(sumReducer.class);
26 
      job.setOutputKeyClass(Text.class);
27 
      job.setOutputValueClass(InfoBean.class);
28 
      FileOutputFormat.setOutputPath(job, new Path(args[1]));
29
30 
      job.waitForCompletion(true);
31 
    }
32 
       public static class SumMapper extends Mapper<LongWritable, Text, Text, InfoBean>{
33
34 
      private Text k2 = new Text();
35 
      private InfoBean v2 = new InfoBean();
36 
          
37 
      @Override
38 
      protected void map(LongWritable key, Text value,
39 
      Mapper<LongWritable, Text, Text, InfoBean>.Context context)
40 
          throws IOException, InterruptedException {
41 
        String line=value.toString();
42 
        String[] hang=line.split("\t");
43 
        String accout=hang[0];
44 
        double incom=Double.parseDouble(hang[1]);
45 
        double zhichu=Double.parseDouble(hang[2]);
46
47 
        k2.set(accout);
48 
        v2.set(accout, incom, zhichu);
49 
        context.write(k2, v2);
50 
      }
51
52 
    }
53 
     public static class sumReducer extends Reducer<Text, InfoBean, Text, InfoBean>{
54 
        private InfoBean v3 = new InfoBean();
55 
        
56 
      @Override
57 
      protected void reduce(Text k2, Iterable<InfoBean> v2,
58 
      Reducer<Text, InfoBean, Text, InfoBean>.Context context)
59 
          throws IOException, InterruptedException {
60 
        double sumIncom = 0;
61 
        double sumZhichu = 0;
62 
        for(InfoBean infoBean : v2){
63 
          sumIncom += infoBean.getIncom();
64 
          sumZhichu += infoBean.getZhichu();
65 
        }
66 
        v3.set("", sumIncom, sumZhichu);
67 
        context.write(k2, v3);
68 
      }
69 
    }
70 
  }

SortStep类

import java.io.IOException;
  import org.apache.hadoop.conf.Configuration;
  import org.apache.hadoop.fs.Path;
  import org.apache.hadoop.io.LongWritable;
  import org.apache.hadoop.io.NullWritable;
  import org.apache.hadoop.io.Text;
  import org.apache.hadoop.mapreduce.Job;
  import org.apache.hadoop.mapreduce.Mapper;
  import org.apache.hadoop.mapreduce.Reducer;
  import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
  import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
  public class SortStep {

    public static void main(String[] args) throws Exception {
      // TODO Auto-generated method stub
      Job job=Job.getInstance(new Configuration());

      job.setJarByClass(SortStep.class);

      job.setMapperClass(SortMapper.class);
      job.setMapOutputKeyClass(InfoBean.class);
      job.setMapOutputValueClass(NullWritable.class);
      FileInputFormat.setInputPaths(job, new Path(args[0]));

      job.setReducerClass(SortReducer.class);
      job.setOutputKeyClass(Text.class);
      job.setOutputValueClass(InfoBean.class);
      FileOutputFormat.setOutputPath(job, new Path(args[1]));

      job.waitForCompletion(true);
    }

    public static class SortMapper extends 
    Mapper<LongWritable, Text, InfoBean, NullWritable>{

      private InfoBean k2 = new InfoBean();

      @Override
      protected void map(LongWritable key, Text value,
          Mapper<LongWritable, Text, InfoBean, NullWritable>.Context context)
              throws IOException, InterruptedException {
        String line = value.toString();
        String[] hang=line.split("\t");
        String accout = hang[0];
        double incom = Double.parseDouble(hang[1]);
        double zhichu = Double.parseDouble(hang[2]);

        k2.set(accout, incom, zhichu);

        context.write(k2,NullWritable.get());
      }

    }
    public static class SortReducer extends Reducer<InfoBean, NullWritable, Text, InfoBean>{

      private Text k3=new Text();
      @Override
      protected void reduce(InfoBean k2, Iterable<NullWritable> v2,
          Reducer<InfoBean, NullWritable, Text, InfoBean>.Context context) 
          throws IOException, InterruptedException {
        k3.set(k2.getAccout());
        context.write(k3, k2);
      }

    }
  }
1 
  import java.io.IOException;
2 
  import org.apache.hadoop.conf.Configuration;
3 
  import org.apache.hadoop.fs.Path;
4 
  import org.apache.hadoop.io.LongWritable;
5 
  import org.apache.hadoop.io.NullWritable;
6 
  import org.apache.hadoop.io.Text;
7 
  import org.apache.hadoop.mapreduce.Job;
8 
  import org.apache.hadoop.mapreduce.Mapper;
9 
  import org.apache.hadoop.mapreduce.Reducer;
10 
  import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
11 
  import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
12 
  public class SortStep {
13
14 
    public static void main(String[] args) throws Exception {
15 
      // TODO Auto-generated method stub
16 
      Job job=Job.getInstance(new Configuration());
17
18 
      job.setJarByClass(SortStep.class);
19
20 
      job.setMapperClass(SortMapper.class);
21 
      job.setMapOutputKeyClass(InfoBean.class);
22 
      job.setMapOutputValueClass(NullWritable.class);
23 
      FileInputFormat.setInputPaths(job, new Path(args[0]));
24
25 
      job.setReducerClass(SortReducer.class);
26 
      job.setOutputKeyClass(Text.class);
27 
      job.setOutputValueClass(InfoBean.class);
28 
      FileOutputFormat.setOutputPath(job, new Path(args[1]));
29
30 
      job.waitForCompletion(true);
31 
    }
32
33 
    public static class SortMapper extends
34 
    Mapper<LongWritable, Text, InfoBean, NullWritable>{
35
36 
      private InfoBean k2 = new InfoBean();
37
38 
      @Override
39 
      protected void map(LongWritable key, Text value,
40 
          Mapper<LongWritable, Text, InfoBean, NullWritable>.Context context)
41 
              throws IOException, InterruptedException {
42 
        String line = value.toString();
43 
        String[] hang=line.split("\t");
44 
        String accout = hang[0];
45 
        double incom = Double.parseDouble(hang[1]);
46 
        double zhichu = Double.parseDouble(hang[2]);
47
48 
        k2.set(accout, incom, zhichu);
49
50 
        context.write(k2,NullWritable.get());
51 
      }
52
53 
    }
54 
    public static class SortReducer extends Reducer<InfoBean, NullWritable, Text, InfoBean>{
55
56 
      private Text k3=new Text();
57 
      @Override
58 
      protected void reduce(InfoBean k2, Iterable<NullWritable> v2,
59 
          Reducer<InfoBean, NullWritable, Text, InfoBean>.Context context)
60 
          throws IOException, InterruptedException {
61 
        k3.set(k2.getAccout());
62 
        context.write(k3, k2);
63 
      }
64
65 
    }
66 
  }

老猫饿了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mapreduce高级特性及shuffle
10-22
1.shuffle机制详细讲解 2.MR案例多文件输出 3.MR案例partition使用 4.MR案例内容去重 5.MR案例敏感词汇过滤 6.MR案例自定义combiner的使用 7.MR案例倒排序索引 8.MR案例简单排序
MapReduce常见算法 与自定义排序及Hadoop序列化
chenyuanshengboke的博客
11-11 604
MapReduce常见算法 •单词计数 •数据去重 •排序 •Top K •选择　　以求最值为例，从100万数据中选出一行最小值 •投影　　以求处理手机上网日志为例，从其11个字段选出了五个字段(列)来显示我们的手机上网流量 •分组　　相当于分区，以求处理手机上网日志为例，喊手机号和非手机号分为两组 •多表连接 •单表关联 使用TopK算法找出文件中的最大数： 复制代码 1 package sua...
Hadoop编程——第五章：（6）MapReduce自定义排序案例
weixin_45348240的博客
07-14 765
将美国每个州state的确诊案例数进行倒序排序。如果你的需求中需要根据某个属性进行排序，不妨把这个属性作为key。因为MapReduce中key有默认排序行为的。可使用案例1的输出结果表作为本案例的输入表。1、如果你的需求是正序，并且数据类型是Hadoop封装好的类型。这种情况下不需要任何修改，直接使用lHadoop类型作为kcy即可。因为Hadoop封装好的类型已经实现了排序规则。2、如果你的需求是倒序，或者数据类型是自定义对象。需要重写排序规则。对象实现Comparable接口重写CompareTo方法
大数据知识专栏 - MapReduce 自定义排序技术
能力工场小马哥
01-20 241
大数据专栏系列文章: 今天告诉你如何通过 MapReduce 的排序技术, 来实现对数据的任意顺序输出.
mapreduce编程自定义排序
鲍礼彬的CSDN博客 ~_~
04-14 966
输入数据： [root@baolibin hadoop]# hadoop fs -text /input/haha Warning: $HADOOP_HOME is deprecated. 2 1 3 2 1 3 代码： package hadoop_2_6_0; import java.io.DataInput; import ja
7、MapReduce自定义排序实现
这里是Code猿学习的地方
12-13 454
MapReduce中，根据key进行分区、排序、分组 MapReduce会按照基本类型对应的key进行排序，如int类型的IntWritable，long类型的LongWritable,Text类型，默认升序排序 为什么要自定义排序规则？ 现有需求，需要自定义key类型，并自定义key的排序规则，如按照人的salary降序排序，若相同，则再按age升序排序 以Text类型为例： Text类...
MapReduce基础编程（自定义序列化、自定义分区、自定义排序、自定义分组）
qq_46439199的博客
11-18 1243
MapReduce基础编程（自定义序列化、自定义分区、自定义排序、自定义分组）
MapReduce编程实例之自定义排序
Thinkgamer博客
11-25 2638
任务描述： 给出一组数据，自定义排序的样式，第一列降序，相同时第二列升序 example Data： 2013 1 2013 5 2014 5 2014 8 2015 9 2015 4 Code: package mrTest; import java.io.DataInput; import java.io.DataOutput; import java.io.IOExcep...
Mapreduce介绍及自定义分区与排序
Imflash的博客
09-10 425
Hadoop-Mapreduce 1. MapReduce 介绍 MapReduce思想在生活中处处可见。或多或少都曾接触过这种思想。MapReduce的思想核心是“分而治之”，适用于大量复杂的任务处理场景（大规模数据处理场景）。 Map负责“分”，即把复杂的任务分解为若干个“简单的任务”来并行处理。可以进行拆分的前提是这些小任务可以并行计算，彼此间几乎没有依赖关系。 Reduce负责“合”，即...
Hadoop编程——第五章：(7) MapReduce自定义分区案例
weixin_45348240的博客
07-15 668
1、将美国疫情数据不同州的输出到不同文件中，属于同一个州的各个县输出到同一个结果文件中。输出到不同文件中–>reducetask有多个(>2)–>默认只有1个，如何有多个?—>可以设置， job. setNumReduceTasks(N)—>当有多个reducetask意味着数据分区---->默认分区规则是什么? hashPartitioner–→>默认分区规则符合你的业务需求么?---->符合，直接使用—>不符合，自定义分区。HashPartitioner默认规则.........
MapReduce实战小案例（自定义排序、二次排序、分组、分区）
fengxiandada的博客
06-26 6427
MapReduce实战小案例
mapreduce-programming:此示例程序将让您提取有用的统计数据，例如排名前 10 的平均评分电影、使用 Hadoop map-reduce 框架以及链接多个映射器和化简器对 200 万条记录进行基于流派的过滤
06-11
mapreduce 编程 此示例程序将让您提取有用的统计数据，例如排名前 10 的平均评分电影、使用 Hadoop map-reduce 框架以及链接多个映射器和化简器对 200 万条记录进行基于流派的过滤
Hadoop 培训课程(4)MapReduce_2
05-07
Hadoop 培训课程(4)MapReduce_2 标准和自定义计数器* Combiner和Partitioner编程** 自定义排序和分组编程** 常见的MapReduce算法** ---------------------------加深拓展---------------------- 常见大数据处理方法*
Hadoop实训求最高温度和最低温度的数据集
05-04
(2)MapReduce输出结果包含年份、最高气温、最低气温，并按最高气温降序排序。如果最高气温相同，则按最低气温升序排序。 (3)使用自定义数据类型。 (4)结合Combiner和自定义数据类型完成全球每年最高气温和最低气温的...
MapReduce概述
早拾碗吧的博客
04-30 1095
首先我们需要先了解一个概念：批处理模式批处理模式是一种最早进行大规模数据处理的模式。批处理非常适合需要访问整个数据集合才能完成的计算工作。批处理主要操作大规模静态数据集,并在整体数据处理完毕后返回结果。例如,在计算总数和平均数时,必须将数据集作为一个整体加以处理,而不能将其视作多条记录的集合。这些操作要求在计算进行过程中数据维持自己的状态。需要处理大量数据的任务通常最适合用批处理模式进行处理,批处理系统在设计过程中就充分考虑了数据的量,可提供充足的处理资源。
MapReduce
qq_14846625的博客
04-30 962
目的: 分析 MR (MapReduce) 作业的执行流程。流程维度: 从节点、状态节点、角色进程等角度进行分析。
ruoyi漏洞总结
qq_59468567的博客
05-03 725
baseurl 就有了，有的是全的 url，大多数是只给个 baseurl：prod-api，这类。js 下面有个 app.xxxxxx(一些个字母数字).js，直接里面搜。如果页面访问显示不正常，可添加默认访问路径尝试是否显示正常。若依有个特点，密码可能在前台直接显示，点击并能够成功登录。监控中存在大量接口路径，可通过未授权获取更多敏感信息在。图标和登录页面及验证码处的样式识别出若依。认证失败，无法访问系统资源。进行替换实现登录系统。数据库存在未授权访问。
docker部署elasticsearch7.7.0级拼音(pinyin)插件和分词(ik)插件
最新发布
debugcool的博客
05-07 225
进入容器并解压该文件到相应的目录。拉取并启动kabana。安装pinyin插件。
MapReduce自定义比较器
02-07
其中，自定义比较器是MapReduce的一种功能，允许用户定义自己的比较方法来排序输出结果。 使用自定义比较器可以实现复杂的排序逻辑，而不是仅仅使用基本的字典序排序。例如，可以使用自定义比较器来按照日期、数字...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值