Hadoop日记Day18---MapReduce排序分组

本节所用到的数据下载地址为：http://pan.baidu.com/s/1bnfELmZ

MapReduce的排序分组任务与要求

　　我们知道排序分组是MapReduce中Mapper端的第四步，其中分组排序都是基于Key的，我们可以通过下面这几个例子来体现出来。其中的数据和任务如下图1.1，1.2所示。

#首先按照第一列升序排列，当第一列相同时，第二列升序排列

3    3

3    2

3    1

2    2

2    1

1    1

-------------------

#结果

1    1

2    1

2    2

3    1

3    2

3    3

图 1.1 排序

#当第一列相同时，求出第二列的最小值

3    3

3    2

3    1

2    2

2    1

1    1

-------------------

#结果

3    1

2    1

1    1

图 1.2 分组

一、 排序算法

1.1 MapReduce默认排序算法

　　使用MapReduce默认排序算法代码如下1.1所示，在代码中我将第一列作为键，第二列作为值。

 package sort;

 import java.io.IOException;

 import java.net.URI;

 import org.apache.hadoop.conf.Configuration;

 import org.apache.hadoop.fs.FileStatus;

 import org.apache.hadoop.fs.FileSystem;

 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.input.TextInputFormat;

 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

 import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

 import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;

 public class SortApp {

     private static final String INPUT_PATH = "hdfs://hadoop:9000/newinput";

     private static final String OUT_PATH = "hdfs://hadoop:9000/newoutput";

     public static void main(String[] args) throws Exception {

         Configuration conf=new Configuration();

         final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);

         final Path outpath = new Path(OUT_PATH);

         if(fileSystem.exists(outpath)){

             fileSystem.delete(outpath,true);

         }

         final Job job = new Job(conf,SortApp.class.getSimpleName());

         //1.1 指定输入文件路径

         FileInputFormat.setInputPaths(job, INPUT_PATH);

         job.setInputFormatClass(TextInputFormat.class);//指定哪个类用来格式化输入文件

         //1.2指定自定义的Mapper类

         job.setMapperClass(MyMapper.class);

         job.setMapOutputKeyClass(LongWritable.class);//指定输出<k2,v2>的类型

         job.setMapOutputValueClass(LongWritable.class);

         //1.3 指定分区类

         job.setPartitionerClass(HashPartitioner.class);

         job.setNumReduceTasks(1);

         //1.4 TODO 排序、分区

         //1.5  TODO （可选）合并

         //2.2 指定自定义的reduce类

         job.setReducerClass(MyReducer.class);

         job.setOutputKeyClass(LongWritable.class);//指定输出<k3,v3>的类型

         job.setOutputValueClass(LongWritable.class);

         //2.3 指定输出到哪里

         FileOutputFormat.setOutputPath(job, outpath);

         job.setOutputFormatClass(TextOutputFormat.class);//设定输出文件的格式化类

         job.waitForCompletion(true);//把代码提交给JobTracker执行

     }

     static class MyMapper extends Mapper<LongWritable, Text,LongWritable,LongWritable>{

         @Override

         protected void map(

                 LongWritable key,

                 Text value,

                 Mapper<LongWritable, Text, LongWritable, LongWritable>.Context context)

                 throws IOException, InterruptedException {

             final String[] splited = value.toString().split("\t");

             final long k2 = Long.parseLong(splited[0]);

             final long v2 = Long.parseLong(splited[1]);

             context.write(new LongWritable(k2),new LongWritable(v2));

         }

     }

     static class MyReducer extends Reducer<LongWritable,LongWritable,LongWritable,LongWritable>{

         @Override

         protected void reduce(

                 LongWritable k2,

                 Iterable<LongWritable> v2s,

                 Reducer<LongWritable, LongWritable, LongWritable, LongWritable>.Context context)

                 throws IOException, InterruptedException {

             for(LongWritable v2:v2s){

                 context.write(k2, v2);

             }

         }

     }

 }

代码 1.1

　　运行结果如下图1.3所示

1    1

2    2

2    1

3    3

3    2

3    1

图 1.3

　　从上面图中运行结果可以看出，MapReduce默认排序算法只对Key进行了排序，并没有对value进行排序，没有达到我们的要求，所以要实现我们的要求，还要我们自定义一个排序算法

1.2 自定义排序算法

　　从上面图中运行结果可以知道，MapReduce默认排序算法只对Key进行了排序，并没有对value进行排序，没有达到我们的要求，所以要实现我们的要求，还要我们自定义一个排序算法。在map和reduce阶段进行排序时，比较的是k2。v2是不参与排序比较的。如果要想让v2也进行排序，需要把k2和v2组装成新的类作为k 2 ，才能参与比较。所以在这里我们新建一个新的类型NewK2类型来封装原来的k2和v2。代码如1.2所示。

 package sort;

 import java.io.DataInput;

 import java.io.DataOutput;

 import java.io.IOException;

 import java.net.URI;

 import org.apache.hadoop.conf.Configuration;

 import org.apache.hadoop.fs.FileSystem;

 import org.apache.hadoop.fs.Path;

 import org.apache.hadoop.io.LongWritable;

 import org.apache.hadoop.io.Text;

 import org.apache.hadoop.io.WritableComparable;

 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.input.TextInputFormat;

 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

 import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

 import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;

 public class SortApp {

     static final String INPUT_PATH = "hdfs://hadoop:9000/newinput";

     static final String OUT_PATH = "hdfs://hadoop:9000/newoutput";

     public static void main(String[] args) throws Exception{

         final Configuration configuration = new Configuration();

         final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), configuration);

         if(fileSystem.exists(new Path(OUT_PATH))){

             fileSystem.delete(new Path(OUT_PATH), true);

         }

         final Job job = new Job(configuration, SortApp.class.getSimpleName());

         //1.1 指定输入文件路径

         FileInputFormat.setInputPaths(job, INPUT_PATH);

         job.setInputFormatClass(TextInputFormat.class);//指定哪个类用来格式化输入文件

         //1.2指定自定义的Mapper类

         job.setMapperClass(MyMapper.class);

         job.setMapOutputKeyClass(NewK2.class);//指定输出<k2,v2>的类型

         job.setMapOutputValueClass(LongWritable.class);

         //1.3 指定分区类

         job.setPartitionerClass(HashPartitioner.class);

         job.setNumReduceTasks(1);

         //2.2 指定自定义的reduce类

         job.setReducerClass(MyReducer.class);

         job.setOutputKeyClass(LongWritable.class);//指定输出<k3,v3>的类型

         job.setOutputValueClass(LongWritable.class);

         //2.3 指定输出到哪里

         FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));

         job.setOutputFormatClass(TextOutputFormat.class);//设定输出文件的格式化类

         job.waitForCompletion(true);//把代码提交给JobTracker执行

     }

     static class MyMapper extends Mapper<LongWritable, Text, NewK2, LongWritable>{

         protected void map(LongWritable key, Text value, org.apache.hadoop.mapreduce.Mapper<LongWritable,Text,NewK2,LongWritable>.Context context) throws java.io.IOException ,InterruptedException {

             final String[] splited = value.toString().split("\t");

             final NewK2 k2 = new NewK2(Long.parseLong(splited[0]), Long.parseLong(splited[1]));

             final LongWritable v2 = new LongWritable(Long.parseLong(splited[1]));

             context.write(k2, v2);

         };

     }

     static class MyReducer extends Reducer<NewK2, LongWritable, LongWritable, LongWritable>{

         protected void reduce(NewK2 k2, java.lang.Iterable<LongWritable> v2s, org.apache.hadoop.mapreduce.Reducer<NewK2,LongWritable,LongWritable,LongWritable>.Context context) throws java.io.IOException ,InterruptedException {

             context.write(new LongWritable(k2.first), new LongWritable(k2.second));

         };

     }

     /**

      * 问：为什么实现该类？

      * 答：因为原来的v2不能参与排序，把原来的k2和v2封装到一个类中，作为新的k2

      *

      */

     static class  NewK2 implements WritableComparable<NewK2>{

         Long first;

         Long second;

         public NewK2(){}

         public NewK2(long first, long second){

             this.first = first;

             this.second = second;

         }

         @Override

         public void readFields(DataInput in) throws IOException {

             this.first = in.readLong();

             this.second = in.readLong();

         }

         @Override

         public void write(DataOutput out) throws IOException {

             out.writeLong(first);

             out.writeLong(second);

         }

         /**

          * 当k2进行排序时，会调用该方法.

          * 当第一列不同时，升序；当第一列相同时，第二列升序

          */

         @Override

         public int compareTo(NewK2 o) {

             final long minus = this.first - o.first;

             if(minus !=0){

                 return (int)minus;

             }

             return (int)(this.second - o.second);

         }

         @Override

         public int hashCode() {

             return this.first.hashCode()+this.second.hashCode();

         }

         @Override

         public boolean equals(Object obj) {

             if(!(obj instanceof NewK2)){

                 return false;

             }

             NewK2 oK2 = (NewK2)obj;

             return (this.first==oK2.first)&&(this.second==oK2.second);

         }

     }

 }

代码 1.2

　　从上面的代码中我们可以发现，我们的新类型NewK2实现了WritableComparable接口，其中该接口中有一个compareTo()方法，当对关键字进行比较会调用该方法，而我们就在该方法中实现了我们想要做的事。

　　运行结果如下图1.4所示。

1    1

2    1

2    2

3    1

3    2

3    3

图 1.4

二、分组算法

2.1 MapReduce默认分组

　　分组是在MapReduce中Mapper端的第四步，分组也是基于Key进行的，将相同key的value放到一个集合中去。还以上面排序代码为例，业务逻辑如下图2.1所示。在代码中以NewK2为关键字，每个键都不相同，所以会将数据分为六组，这样就不能实现我们的业务要求，但利用自定义类型NewK2，可以自定义排序算法的同时我们也可以自定义分组算法。

#当第一列相同时，求出第二列的最小值

3    3

3    2

3    1

2    2

2    1

1    1

-------------------

#结果

3    1

2    1

1    1

图 2.1

2.2 自定义分组比较器

　　由于业务要求分组是按照第一列分组，但是NewK2的比较规则决定了不能按照第一列分，只能自定义分组比较器，代码如下2.1所示。

 package group;

 import java.io.DataInput;

 import java.io.DataOutput;

 import java.io.IOException;

 import java.net.URI;

 import org.apache.hadoop.conf.Configuration;

 import org.apache.hadoop.fs.FileSystem;

 import org.apache.hadoop.fs.Path;

 import org.apache.hadoop.io.LongWritable;

 import org.apache.hadoop.io.RawComparator;

 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.input.TextInputFormat;

 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

 import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

 import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;

 public class GroupApp {

     static final String INPUT_PATH = "hdfs://hadoop:9000/newinput";

     static final String OUT_PATH = "hdfs://hadoop:9000/newoutput";

     public static void main(String[] args) throws Exception{

         final Configuration configuration = new Configuration();

         final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), configuration);

         if(fileSystem.exists(new Path(OUT_PATH))){

             fileSystem.delete(new Path(OUT_PATH), true);

         }

         final Job job = new Job(configuration, GroupApp.class.getSimpleName());

         //1.1 指定输入文件路径

         FileInputFormat.setInputPaths(job, INPUT_PATH);

         job.setInputFormatClass(TextInputFormat.class);//指定哪个类用来格式化输入文件

         //1.2指定自定义的Mapper类

         job.setMapperClass(MyMapper.class);

         job.setMapOutputKeyClass(NewK2.class);//指定输出<k2,v2>的类型

         job.setMapOutputValueClass(LongWritable.class);

         //1.3 指定分区类

         job.setPartitionerClass(HashPartitioner.class);

         job.setNumReduceTasks(1);

         //1.4 TODO 排序、分区

         job.setGroupingComparatorClass(MyGroupingComparator.class);

         //1.5  TODO （可选）合并

         //2.2 指定自定义的reduce类

         job.setReducerClass(MyReducer.class);

         job.setOutputKeyClass(LongWritable.class);//指定输出<k3,v3>的类型

         job.setOutputValueClass(LongWritable.class);

         //2.3 指定输出到哪里

         FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));

         job.setOutputFormatClass(TextOutputFormat.class);//设定输出文件的格式化类

         job.waitForCompletion(true);//把代码提交给JobTracker执行

     }

     static class MyMapper extends Mapper<LongWritable, Text, NewK2, LongWritable>{

         protected void map(LongWritable key, Text value, org.apache.hadoop.mapreduce.Mapper<LongWritable,Text,NewK2,LongWritable>.Context context) throws java.io.IOException ,InterruptedException {

             final String[] splited = value.toString().split("\t");

             final NewK2 k2 = new NewK2(Long.parseLong(splited[0]), Long.parseLong(splited[1]));

             final LongWritable v2 = new LongWritable(Long.parseLong(splited[1]));

             context.write(k2, v2);

         };

     }

     static class MyReducer extends Reducer<NewK2, LongWritable, LongWritable, LongWritable>{

         protected void reduce(NewK2 k2, java.lang.Iterable<LongWritable> v2s, org.apache.hadoop.mapreduce.Reducer<NewK2,LongWritable,LongWritable,LongWritable>.Context context) throws java.io.IOException ,InterruptedException {

             long min = Long.MAX_VALUE;

             for (LongWritable v2 : v2s) {

                 if(v2.get()<min){

                     min = v2.get();

                 }

             }

             context.write(new LongWritable(k2.first), new LongWritable(min));

         };

     }

     /**

      * 问：为什么实现该类？

      * 答：因为原来的v2不能参与排序，把原来的k2和v2封装到一个类中，作为新的k2

      *

      */

     static class  NewK2 implements WritableComparable<NewK2>{

         Long first;

         Long second;

         public NewK2(){}

         public NewK2(long first, long second){

             this.first = first;

             this.second = second;

         }

         @Override

         public void readFields(DataInput in) throws IOException {

             this.first = in.readLong();

             this.second = in.readLong();

         }

         @Override

         public void write(DataOutput out) throws IOException {

             out.writeLong(first);

             out.writeLong(second);

         }

         /**

          * 当k2进行排序时，会调用该方法.

          * 当第一列不同时，升序；当第一列相同时，第二列升序

          */

         @Override

         public int compareTo(NewK2 o) {

             final long minus = this.first - o.first;

             if(minus !=0){

                 return (int)minus;

             }

             return (int)(this.second - o.second);

         }

         @Override

         public int hashCode() {

             return this.first.hashCode()+this.second.hashCode();

         }

         @Override

         public boolean equals(Object obj) {

             if(!(obj instanceof NewK2)){

                 return false;

             }

             NewK2 oK2 = (NewK2)obj;

             return (this.first==oK2.first)&&(this.second==oK2.second);

         }

     }

     static class MyGroupingComparator implements RawComparator<NewK2>{

         @Override

         public int compare(NewK2 o1, NewK2 o2) {

             return (int)(o1.first - o2.first);

         }

         @Override

         public int compare(byte[] arg0, int arg1, int arg2, byte[] arg3,

                 int arg4, int arg5) {

             return WritableComparator.compareBytes(arg0, arg1, 8, arg3, arg4, 8);

         }

     }

 }

代码2.1

　　从上面的代码中我们可以知道，我们自定义了一个分组比较器MyGroupingComparator，该类实现了RawComparator接口，RawComparator又继承了Comparator接口，这两个接口的代码如下：

public interface RawComparator<T> extends Comparator<T> {

  public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2);

}

public interface Comparator<T> {

    int compare(T o1, T o2);

    boolean equals(Object obj);

}

　　在类MyGroupingComparator中分别对着两个接口中的方法进行了实现，RawComparator中的compare()方法是基于字节的比较，Comparator中的compare()方法是基于对象的比较。在该方法一共有六个参数，如下：
         * @param arg0 表示第一个参与比较的字节数组
         * @param arg1 表示第一个参与比较的字节数组的起始位置
         * @param arg2 表示第一个参与比较的字节数组的偏移量
         *
         * @param arg3 表示第二个参与比较的字节数组
         * @param arg4 表示第二个参与比较的字节数组的起始位置
         * @param arg5 表示第二个参与比较的字节数组的偏移量

　　在于NewK2中存储着两个long类型，每个long类型为8字节，.compareBytes()方法的参数如下：.compareBytes(arg0, arg1, , arg3, arg4, );因为比较的是第一列，所以读取的偏移量为8字节。由于我们要求出每一分组的最小值，所以还重写Reduce方法，求出每一分租的最小值。最后的运行结果如下图2.1所示

1    1

2    1

3    1

图 2.1

三、MapReduce的一些算法

3.1 MapReduce中Shuffle过程

　　Shuffle是MapReduce过程的核心，了解Shuffle非常有助于理解MapReduce的工作原理。huffle的正常意思是洗牌或弄乱，可能大家更熟悉的是Java API里的Collections.shuffle(List)方法，它会随机地打乱参数list里的元素顺序。如果你不知道MapReduce里Shuffle是什么，那么请看这张图：

　　在该图中分为Map任务和Reduce任务两个部分，从map端到reduce端的红色和绿色的线表示数据流的一个过程，也就是从<K1,V1>到<K2,V2>到<K3,V3>的一个过程。

Map端

　　<1>在map端首先接触的是InputSplit,在InputSplit中含有DataNode中的数据,每一个InputSplit都会分配一个Mapper任务,Mapper任务结束后产生<K2,V 2>的输出，这些输出显存放在缓存中，每个map有一个环形内存缓冲区，用于存储任务的输出。默认大小100MB（io.sort.mb属性），一旦达到阀值0.8(io.sort.spil l.percent),一个后台线程就把内容写到(spill)Linux本地磁盘中的指定目录（mapred.local.dir）下的新建的一个溢出写文件。

　　<2>写磁盘前，要partition,sort。通过分区，将不同类型的数据分开处理，之后对不同分区的数据进行排序，如果有Combiner，还要对排序后的数据进行co mbine。等最后记录写完，将全部溢出文件合并为一个分区且排序的文件。

　　<3>最后将磁盘中的数据送到Reduce中，从图中可以看出Map输出有三个分区，有一个分区数据被送到图示的Reduce任务中，剩下的两个分区被送到其他Reducer任务中。而图示的Reducer任务的其他的三个输入来自其他的Map输出。

Reduce端

　　<1>Reducer通过Http方式得到输出文件的分区。
　　<2>TaskTracker为分区文件运行Reduce任务。复制阶段把Map输出复制到Reducer的内存或磁盘。一个Map任务完成，Reduce就开始复制输出。
　　<3>排序阶段合并map输出。然后走Reduce阶段。

3.2 Hadoop压缩算法

3.2.1 算法介绍

　　Hadoop的压缩过程并不是一个必须的过程，但为什么还要使用呢？在哪些阶段可以使用，有什么好处呢？
      <1>在Map输出到Reduce时可以使用，因为map端输出的数据要通过网络输出到Reduce端，为了减少传输的数据量我们可以采用压缩的方式来减少延迟。
      <2>在整个作业的输出也可以使用
　　Codec为是压缩，解压缩的算法的实现，在Hadoop中，codec由CompressionCode的实现来表示。下面是一些实现，如下图3.1所示。

图 3.1

3.2.2  MapReduce的输出进行压缩

　　输出的压缩属性，和使用方式：如下图3.2,3.3所示。

aaarticlea/png;base64,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" alt="" width="505" height="89" />

图 3.2

aaarticlea/png;base64,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" alt="" width="468" height="117" />

图3.3

3.3 常见算法

3.3.1 MapReduce常见算介绍

<1>单词计数(已介绍)
<2>数据去重(去掉重复数据不难理解吧)
<3>排序(在上节已介绍)
<4>Top K(是求最值问题，下面会介绍)

下面算法，跟我们数据库中的方法比较类似，
<5>选择---行

　　　　数据库中：该操作的结果应该是一行一行的显示，相当于where。

　　　　MapReduce的实现：以求最值为例，从100万数据中选出一行最小值。
<6>投影---列

　　　　数据库中：该操作的结果应该是一列一列的显示，相当于select。　　　　

　　　　MapReduce的实现：以求处理手机上网日志为例，从其11个字段选出了五个字段来显示我们的手机上网流量。
<7>分组

　　　　数据库中：相当于group by。　　　　　　　　

　　　　MapReduce的实现：相当于分区，以求处理手机上网日志为例，喊手机号和非手机号分为两组。
<9>多表连接

　　　　MapReduce中：在MapReduce中可以同时进入多个文件进行操作，其中两个文件有关系就相当于表连接。那么如何知道文件之间的关系呢？我可以通过map函数的context参数来获得文件路径代码如下

　　final FileSplit inputSplit = (FileSplit) context.getInputSplit();

　　final String path = inputSplit.getPath().toString();

<10>单表关联　　

3.3.2 Top K 最值案例

　　求最值的方法，在我们的生活中应用非常的广，比如找出高考中的最高分，也就是状元，就非常类似分布式计算，要选出全国的最高分就首先选出各省份的，要选出各省份就得选出各市级的等等，而这些数据量非常大，无法直接全部加载到内存中，面对如此大的数据量我就可以考虑使用分布式计算的方式。我们以从100万的数据中求出其中的最大值为例，介绍该方法。

　　求最值最简单的办法就是对该文件进行一次遍历得出最值，但是现实中数据比量比较大，这种方法不能实现。在传统的MapReduce思想中，将文件的数据经过map迭代出来送到reduce中，在Reduce中求出最大值。但这个方法显然不够优化，我们可采用“分而治之”的思想，不需要map的所有数据全部送到reduce中，我们可以在map中先求出最大值，将该map任务的最大值送reduce中，这样就减少了数据的传输量。那么什么时候该把这个数据写出去呢？我们知道，每一个键值对都会调用一次map()，由于数据量大调用map()的次数也就多了，显然在map()函数中将该数据写出去是不明智的，所以最好的办法该Mapper任务结束后将该数据写出去。我们又知道，当Mapper/Reducer任务结束后会调用cleanup函数，所以我们可以在该函数中将该数据写出去。了解了这些我们可以看一下程序的代码如3.1所示。

 package suanfa;

 import java.net.URI;

 import mapreduce.WordCountApp;

 import org.apache.hadoop.conf.Configuration;

 import org.apache.hadoop.fs.FileSystem;

 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.input.FileSplit;

 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

 public class TopKApp {

     static final String INPUT_PATH = "hdfs://hadoop:9000/input2";

     static final String OUT_PATH = "hdfs://hadoop:9000/out2";

     public static void main(String[] args) throws Exception {

         Configuration conf = new Configuration();

         final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);

         final Path outPath = new Path(OUT_PATH);

         if(fileSystem.exists(outPath)){

             fileSystem.delete(outPath, true);

         }

         final Job job = new Job(conf , WordCountApp.class.getSimpleName());

         FileInputFormat.setInputPaths(job, INPUT_PATH);

         job.setMapperClass(MyMapper.class);

         job.setReducerClass(MyReducer.class);

         job.setOutputKeyClass(LongWritable.class);

         job.setOutputValueClass(NullWritable.class);

         FileOutputFormat.setOutputPath(job, outPath);

         job.waitForCompletion(true);

     }

     static class MyMapper extends Mapper<LongWritable, Text, LongWritable, NullWritable>{

         long max = Long.MIN_VALUE;

         protected void map(LongWritable k1, Text v1, Context context) throws java.io.IOException ,InterruptedException {

             final long temp = Long.parseLong(v1.toString());

             if(temp>max){

                 max = temp;

             }

         };

         protected void cleanup(org.apache.hadoop.mapreduce.Mapper<LongWritable,Text,LongWritable, NullWritable>.Context context) throws java.io.IOException ,InterruptedException {

             context.write(new LongWritable(max), NullWritable.get());

         };

     }

     static class MyReducer extends Reducer<LongWritable, NullWritable, LongWritable, NullWritable>{

         long max = Long.MIN_VALUE;

         protected void reduce(LongWritable k2, java.lang.Iterable<NullWritable> arg1, org.apache.hadoop.mapreduce.Reducer<LongWritable,NullWritable,LongWritable,NullWritable>.Context arg2) throws java.io.IOException ,InterruptedException {

             final long temp = k2.get();

             if(temp>max){

                 max = temp;

             }

         };

         protected void cleanup(org.apache.hadoop.mapreduce.Reducer<LongWritable,NullWritable,LongWritable,NullWritable>.Context context) throws java.io.IOException ,InterruptedException {

             context.write(new LongWritable(max), NullWritable.get());

         };

     }

 }

代码3.1

运行结果为：32767，也就是我们数据中的最大值