MapReduce 排序三种实现方式

已于 2024-11-05 16:27:36 修改
阅读量3.9w 收藏 10
点赞数
分类专栏： 数据分析 Hadoop 大数据 文章标签： mapreduce 大数据 hadoop
于 2023-11-09 21:48:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24330181/article/details/134320135
版权

MapReduce 排序两种实现方式

MapReduce 排序两种实现方式 都是借助重写 compareTo 方法 实现
方式一：借助 MapReduce 按照 Key 排序特性，在WritableComparable实现类中 重写 compareTo 方法
方式二：在 Reduce 阶段 cleanUp方法中将最终结果封装到实现JavaBean对象使用集合的排序方法
方式三：在 Reduce 阶段 cleanUp方法中将最终结果封装到实现Comparable的实现类使用集合的排序方法

方式一

该方式需要两次 MapReduce
第一次 MapReduce 做分类统计
第二次 MapReduce 实现排序

第一次 MapReduce 做分类统计

  1. 第一次 MapReduce 做分类统计 Mapper 类

    package cn.lhz.hadoop.mapreduce.wordcount03;

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 java.io.IOException;
import java.util.StringTokenizer;

/**
 * map 阶段
 * Mapper<LongWritable, Text, Text, IntWritable>
 * 前两个 LongWritable,Text 为 map 输入数据的类型，LongWritable 文本文件偏移量，Text 是读取一行的内容
 * 后两个 Text,IntWritable 为 map 输出数据的类型 ，map输出 是一个 key value 数据结构， Text 是 key 的数据类型，IntWritable 是 value 的数据类型
 *
 * @author 李昊哲
 * @version 1.0.0
 */
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
  // 定义map输出的value
  private final static IntWritable one = new IntWritable(1);

  // 定义map输出的key
  private final Text word = new Text();

  /**
   * @param key     map输入偏移量
   * @param value   map输入的内容
   * @param context Mapper.Context 可以利用该对象做 map 的输出操作
   * @throws IOException          IOException
   * @throws InterruptedException InterruptedException
   */
  @Override
  protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
    // 将输入的内容转为 java 字符串
    String line = value.toString();
    // 默认分隔为 空格 \t \n \r 可以利用构造方法传入自定义分隔符
    StringTokenizer itr = new StringTokenizer(line);
    while (itr.hasMoreTokens()) {
      // 获取每一行中的每一个单词
      String string = itr.nextToken();
      // 封装 map 阶段输出 key
      word.set(string);
      // 将读取内容安需求输（map阶段输出）
      context.write(word, one);
    }
  }
}

  2. 第一次 MapReduce 做分类统计 Reducer 类

    package cn.lhz.hadoop.mapreduce.wordcount03;

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

import java.io.IOException;

/**
 * reduce 阶段
 * Reduce<Text, IntWritable,Text,IntWritable> 中四个泛型 两个为一组
 * 前两个 LongWritable,Text 为 map 输出 reduce 输入 数据的类型，map 输出 reduce 输入 是一个 key value 数据结构， Text 是 key 的数据类型，IntWritable 是 value 的数据类型
 * 后两个 Text,IntWritable 为 reduce 输出数据的类型 ，reduce 输出 是一个 key value 数据结构， Text 是 key 的数据类型，IntWritable 是 value 的数据类型
 *
 * @author 李昊哲
 * @version 1.0.0
 */
public class WordCountReduce extends Reducer<Text, IntWritable, Text, IntWritable> {
  // 定义 reduce 输出 value
  private IntWritable result = new IntWritable();

  @Override
  protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
    // 单词数量累加的和
    int sum = 0;
    // 遍历迭代器
    for (IntWritable value : values) {
      // 单词标记累加得到单词数量
      sum += value.get();
    }
    // 封装 reduce 输出 value
    result.set(sum);
    // reduce 输出
    context.write(key, result);
  }
}
    1. 第一次 MapReduce 做分类统计 Job 类
    package cn.lhz.hadoop.mapreduce.wordcount03;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hdfs.DistributedFileSystem;
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;

import java.net.URI;


/**
 * 本地提交 mapreduce 任务到 集群
 * 1、打包项目
 * 2、重新编写代码 添加 本地 jar 文件路径 job.setJar(本地jar文件路径)
 * 3、本地提交
 * 服务器提交 mapreduce 任务到 集群
 * 1、打包项目 注意：代码中不允许出现 job.setJar(本地jar文件路径)
 * 2、上传 jar文件到集群
 * 3、提交 hadoop jar hadoop.jar cn.lhz.hadoop.mapreduce.wordcount03.WordCount
 *
 * @author 李昊哲
 * @version 1.0.0
 */
public class WordCount {

  public static void main(String[] args) throws Exception {
    // 设置环境变量 hadoop 用户名 为 root
    System.setProperty("HADOOP_USER_NAME", "root");

    // 参数配置对象
    Configuration conf = new Configuration();

    // 跨平台提交
    conf.set("mapreduce.app-submission.cross-platform", "true");

    // 本地运行
    // conf.set("mapreduce.framework.name", "local");

    // 设置默认文件系统为 本地文件系统
    // conf.set("fs.defaultFS", "file:///");

    // 声明Job对象 就是一个应用
    Job job = Job.getInstance(conf, "word count");

    // 本地提交启用该行
    // job.setJar("F:\\code\\bigdata2024\\bigdata\\hadoop\\target\\hadoop.jar");

    // 指定当前Job的驱动类
    job.setJarByClass(WordCount.class);

    // 指定当前Job的 Mapper
    job.setMapperClass(WordCountMapper.class);
    // 指定当前Job的 Combiner 注意：一定不能影响最终计算结果 否则 不使用
    job.setCombinerClass(WordCountReduce.class);
    // 指定当前Job的 Reducer
    job.setReducerClass(WordCountReduce.class);

    // 设置 map 输出 key 的数据类型
    job.setMapOutputValueClass(Text.class);
    // 设置 map 输出 value 的数据类型
    job.setMapOutputValueClass(IntWritable.class);
    // 设置 reduce 输出 key 的数据类型
    job.setOutputKeyClass(Text.class);
    // 设置 reduce 输出 value 的数据类型
    job.setOutputValueClass(IntWritable.class);
    // 定义 map 输入的路径 注意：该路径默认为hdfs路径
    FileInputFormat.addInputPath(job, new Path("/WordCount/input/wcdata.txt"));
    // 定义 reduce 输出数据持久化的路径 注意：该路径默认为hdfs路径
    Path path = new Path("/wordcount/sort/李昊哲");
    // 根据配置项获取 HDFS 文件系统
    FileSystem fs = path.getFileSystem(conf);
    if (fs.exists(path)) {
      // 如果 数据输出目录存在 则将数据输出目录删除
      fs.delete(path, true);
    }
    FileOutputFormat.setOutputPath(job, dst);
    // 提交 job
    System.exit(job.waitForCompletion(true) ? 0 : 1);
  }
}

第二次 MapReduce 实现排序

  1. 编写JavaBean实现 WritableComparable 重写 compareTo 方法

    package cn.lhz.hadoop.mapreduce.wordcount04;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.apache.hadoop.io.WritableComparable;

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


/**
 * mapreduce 排序
 *
 * @author 李昊哲
 * @version 1.0.0
 */
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class Word implements WritableComparable<Word> {
  /**
   * 单词
   */
  private String name;
  /**
   * 单词数量
   */
  private int count;

  @Override
  public String toString() {
    return this.name + "\t" + this.count;
  }

  @Override
  public int compareTo(Word word) {
    // 按照单词数量降序
    int x = word.getCount() - this.count;
    if (x != 0) {
      return x;
    } else {
      // 如果单词数量相同 按照单词 hash 值 升序
      return this.name.compareTo(word.getName());
    }
  }

  /**
   * 序列化
   *
   * @param dataOutput 输出的数据
   * @throws IOException IOException
   */
  @Override
  public void write(DataOutput dataOutput) throws IOException {
    dataOutput.writeUTF(this.name);
    dataOutput.writeInt(this.count);
  }

  /**
   * 反序列化
   * 读取输入属性顺序与输出属性顺序一直
   *
   * @param dataInput 输入的数据
   * @throws IOException IOException
   */
  @Override
  public void readFields(DataInput dataInput) throws IOException {
    this.name = dataInput.readUTF();
    this.count = dataInput.readInt();
  }
}

  2. 第二次 MapReduce Mapper 类 将实现 WritableComparable 接口的类对象，作为 map 阶段输出的 key 实现排序

    package cn.lhz.hadoop.mapreduce.wordcount04;

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

import java.io.IOException;

/**
 * 读取 单词计数 结果
 *
 * @author 李昊哲
 * @version 1.0.0
 */
public class WordCountMapper extends Mapper<LongWritable, Text, Word, NullWritable> {
  private final Word outKey = new Word();
  private final NullWritable outValue = NullWritable.get();

  @Override
  protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Word, NullWritable>.Context context) throws IOException, InterruptedException {
    String[] split = value.toString().split("\t");
    outKey.setName(split[0]);
    outKey.setCount(Integer.parseInt(split[1]));
    context.write(outKey, outValue);
  }
}

  3. 第二次 MapReduce Reducer 类 接收 map 阶段输出的 key 后，按需求格式输出

    package cn.lhz.hadoop.mapreduce.wordcount04;

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

import java.io.IOException;

/**
 * reduce 阶段
 *
 * @author 李昊哲
 * @version 1.0.0
 */
public class WordCountReduce extends Reducer<Word, NullWritable, Word, NullWritable> {
  private final NullWritable outValue = NullWritable.get();

  @Override
  protected void reduce(Word key, Iterable<NullWritable> values, Reducer<Word, NullWritable, Word, NullWritable>.Context context) throws IOException, InterruptedException {
    context.write(key, outValue);
  }
}

  4. 第二次 MapReduce job 类

    package cn.lhz.hadoop.mapreduce.wordcount04;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hdfs.DistributedFileSystem;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.net.URI;


/**
 * @author 李昊哲
 * @version 1.0.0
 */
public class WordCountDriver {

  public static void main(String[] args) throws Exception {
    // 设置环境变量 hadoop 用户名 为 root
    System.setProperty("HADOOP_USER_NAME", "root");

    // 参数配置对象
    Configuration conf = new Configuration();

    // 跨平台提交
    conf.set("mapreduce.app-submission.cross-platform", "true");

    // 本地运行
    // conf.set("mapreduce.framework.name", "local");

    // 设置默认文件系统为 本地文件系统
    // conf.set("fs.defaultFS", "file:///");

    // 声明Job对象 就是一个应用
    Job job = Job.getInstance(conf, "word count");

    // 本地提交启用该行
    // job.setJar("F:\\新疆大学\\code\\bigdata2024\\bigdata\\hadoop\\target\\hadoop.jar");

    // 指定当前Job的驱动类
    job.setJarByClass(WordCountDriver.class);

    // 指定当前Job的 Mapper
    job.setMapperClass(WordCountMapper.class);
    // 指定当前Job的 Combiner 注意：一定不能影响最终计算结果 否则 不使用
    // job.setCombinerClass(WordCountReduce.class);
    // 指定当前Job的 Reducer
    job.setReducerClass(WordCountReduce.class);

    // 设置 map 输出 key 的数据类型
    job.setMapOutputValueClass(Word.class);
    // 设置 map 输出 value 的数据类型
    job.setMapOutputValueClass(NullWritable.class);
    // 设置 reduce 输出 key 的数据类型
    job.setOutputKeyClass(Word.class);
    // 设置 reduce 输出 value 的数据类型
    job.setOutputValueClass(NullWritable.class);
    // 定义 map 输入的路径 注意：该路径默认为hdfs路径
    FileInputFormat.addInputPath(job, new Path("/WordCount/result/part-r-00000"));
    // 定义 reduce 输出数据持久化的路径 注意：该路径默认为hdfs路径
    Path path = new Path("/wordcount/sort/李昊哲");
    // 根据配置项获取 HDFS 文件系统
    FileSystem fs = path.getFileSystem(conf);
    if (fs.exists(path)) {
      // 如果 数据输出目录存在 则将数据输出目录删除
      fs.delete(path, true);
    }
    FileOutputFormat.setOutputPath(job, dst);
    // 提交 job
    System.exit(job.waitForCompletion(true) ? 0 : 1);
  }
}

方式二

lambada 表达式 重写 compareTo 方法 借助 List 的 sorted 方法排序

  1. 编写 JavaBean

    package cn.lhz.hadoop.mapreduce.wordcount05;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

/**
 * @author 李昊哲
 * @version 1.0.0
 */
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class Word {
  /**
   * 单词
   */
  private String name;
  /**
   * 单词数量
   */
  private int count;


  @Override
  public String toString() {
    return this.name + "\t" + this.count;
  }
}

  2. 编写 Mapper 类

    package cn.lhz.hadoop.mapreduce.wordcount05;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

/**
 * @author 李昊哲
 * @version 1.0.0
 */
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class Word {
  /**
   * 单词
   */
  private String name;
  /**
   * 单词数量
   */
  private int count;


  @Override
  public String toString() {
    return this.name + "\t" + this.count;
  }
}

  3. 编写 Reducer 类

    package cn.lhz.hadoop.mapreduce.wordcount05;

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

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * reduce 阶段
 * Reduce<Text, IntWritable,Text,IntWritable> 中四个泛型 两个为一组
 * 前两个 LongWritable,Text 为 map 输出 reduce 输入 数据的类型，map 输出 reduce 输入 是一个 key value 数据结构， Text 是 key 的数据类型，IntWritable 是 value 的数据类型
 * 后两个 Text,IntWritable 为 reduce 输出数据的类型 ，reduce 输出 是一个 key value 数据结构， Text 是 key 的数据类型，IntWritable 是 value 的数据类型
 *
 * @author 李昊哲
 * @version 1.0.0
 */
public class WordCountReduce extends Reducer<Text, IntWritable, Text, IntWritable> {
  private final List<Word> words = new ArrayList<Word>();
  private final Text text = new Text();
  private final IntWritable intWritable = new 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 value : values) {
      // 单词标记累加得到单词数量
      count += value.get();
    }
    words.add(new Word(key.toString(), count));
  }

  @Override
  protected void cleanup(Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
    // 排序
    List<Word> collect = words.stream().sorted((a, b) -> {
      // 降序
      int x = b.getCount() - a.getCount();
      if (x != 0) {
        return x;
      } else {
        return a.getName().compareTo(b.getName());
      }
    }).collect(Collectors.toList());
    // 遍历输出
    for (Word word : collect) {
      text.set(word.getName());
      intWritable.set(word.getCount());
      context.write(text, intWritable);
    }

  }
}

  4. 编写 Job 类

    package cn.lhz.hadoop.mapreduce.wordcount05;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hdfs.DistributedFileSystem;
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;

import java.net.URI;


/**
 * 借助 List中的 sorted 方法实训排序
 *
 * @author 李昊哲
 * @version 1.0.0
 */
public class WordCountDriver {

  public static void main(String[] args) throws Exception {
    // 设置环境变量 hadoop 用户名 为 root
    System.setProperty("HADOOP_USER_NAME", "root");

    // 参数配置对象
    Configuration conf = new Configuration();

    // 跨平台提交
    conf.set("mapreduce.app-submission.cross-platform", "true");

    // 本地运行
    // conf.set("mapreduce.framework.name", "local");

    // 设置默认文件系统为 本地文件系统
    // conf.set("fs.defaultFS", "file:///");

    // 声明Job对象 就是一个应用
    Job job = Job.getInstance(conf, "word count");

    // 本地提交启用该行
    // job.setJar("F:\\code\\bigdata2024\\bigdata\\hadoop\\target\\hadoop.jar");

    // 指定当前Job的驱动类
    job.setJarByClass(WordCountDriver.class);

    // 指定当前Job的 Mapper
    job.setMapperClass(WordCountMapper.class);
    // 指定当前Job的 Combiner 注意：一定不能影响最终计算结果 否则 不使用
    // job.setCombinerClass(WordCountReduce.class);
    // 指定当前Job的 Reducer
    job.setReducerClass(WordCountReduce.class);

    // 设置 map 输出 key 的数据类型
    job.setMapOutputValueClass(Text.class);
    // 设置 map 输出 value 的数据类型
    job.setMapOutputValueClass(IntWritable.class);
    // 设置 reduce 输出 key 的数据类型
    job.setOutputKeyClass(Text.class);
    // 设置 reduce 输出 value 的数据类型
    job.setOutputValueClass(IntWritable.class);
    // 定义 map 输入的路径 注意：该路径默认为hdfs路径
    FileInputFormat.addInputPath(job, new Path("/WordCount/input/wcdata.txt"));
    // 定义 reduce 输出数据持久化的路径 注意：该路径默认为hdfs路径
    Path path = new Path("/wordcount/sort/李昊哲");
    // 根据配置项获取 HDFS 文件系统
    FileSystem fs = path.getFileSystem(conf);
    if (fs.exists(path)) {
      // 如果 数据输出目录存在 则将数据输出目录删除
      fs.delete(path, true);
    }
    FileOutputFormat.setOutputPath(job, dst);
    // 提交 job
    System.exit(job.waitForCompletion(true) ? 0 : 1);
  }
}

方式三

JavaBean 实现 Comparable 重写 compareTo 方法 借助TreeSet排序

  1. 编写 JavaBean

    package cn.lhz.hadoop.mapreduce.wordcount06;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

/**
 * @author 李昊哲
 * @version 1.0.0
 */
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class Word implements Comparable<Word> {
  /**
   * 单词
   */
  private String name;
  /**
   * 单词数量
   */
  private int count;


  @Override
  public String toString() {
    return this.name + "\t" + this.count;
  }

  @Override
  public int compareTo(Word word) {
    // 按照单词数量降序
    int x = word.getCount() - this.count;
    if (x != 0) {
      return x;
    } else {
      // 如果单词数量相同 按照单词 hash 值 升序
      return this.name.compareTo(word.getName());
    }
  }
}

  2. 编写 Mapper 类

    package cn.lhz.hadoop.mapreduce.wordcount06;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

/**
 * @author 李昊哲
 * @version 1.0.0
 */
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class Word implements Comparable<Word> {
  /**
   * 单词
   */
  private String name;
  /**
   * 单词数量
   */
  private int count;


  @Override
  public String toString() {
    return this.name + "\t" + this.count;
  }

  @Override
  public int compareTo(Word word) {
    // 按照单词数量降序
    int x = word.getCount() - this.count;
    if (x != 0) {
      return x;
    } else {
      // 如果单词数量相同 按照单词 hash 值 升序
      return this.name.compareTo(word.getName());
    }
  }
}

  3. 编写 Reducer 类

    package cn.lhz.hadoop.mapreduce.wordcount06;

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

import java.io.IOException;
import java.util.Set;
import java.util.TreeSet;

/**
 * reduce 阶段
 * Reduce<Text, IntWritable,Text,IntWritable> 中四个泛型 两个为一组
 * 前两个 LongWritable,Text 为 map 输出 reduce 输入 数据的类型，map 输出 reduce 输入 是一个 key value 数据结构， Text 是 key 的数据类型，IntWritable 是 value 的数据类型
 * 后两个 Text,IntWritable 为 reduce 输出数据的类型 ，reduce 输出 是一个 key value 数据结构， Text 是 key 的数据类型，IntWritable 是 value 的数据类型
 *
 * @author 李昊哲
 * @version 1.0.0
 */
public class WordCountReduce extends Reducer<Text, IntWritable, Text, IntWritable> {
  private final Set<Word> words = new TreeSet<>();
  private final Text text = new Text();
  private final IntWritable intWritable = new 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 value : values) {
      // 单词标记累加得到单词数量
      count += value.get();
    }
    words.add(new Word(key.toString(), count));
  }

  @Override
  protected void cleanup(Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
    for (Word word : words) {
      text.set(word.toString());
      intWritable.set(word.getCount());
      context.write(text, intWritable);
    }
  }
}

  4. 编写 Job 类

    package cn.lhz.hadoop.mapreduce.wordcount06;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hdfs.DistributedFileSystem;
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;

import java.net.URI;


/**
 * 借助 TreeSet 实训排序
 *
 * @author 李昊哲
 * @version 1.0.0
 */
public class WordCountDriver {

  public static void main(String[] args) throws Exception {
    // 设置环境变量 hadoop 用户名 为 root
    System.setProperty("HADOOP_USER_NAME", "root");

    // 参数配置对象
    Configuration conf = new Configuration();

    // 跨平台提交
    conf.set("mapreduce.app-submission.cross-platform", "true");

    // 本地运行
    // conf.set("mapreduce.framework.name", "local");

    // 设置默认文件系统为 本地文件系统
    // conf.set("fs.defaultFS", "file:///");

    // 声明Job对象 就是一个应用
    Job job = Job.getInstance(conf, "word count");

    // 本地提交启用该行
    // job.setJar("F:\\新疆大学\\code\\bigdata2024\\bigdata\\hadoop\\target\\hadoop.jar");

    // 指定当前Job的驱动类
    job.setJarByClass(WordCountDriver.class);

    // 指定当前Job的 Mapper
    job.setMapperClass(WordCountMapper.class);
    // 指定当前Job的 Combiner 注意：一定不能影响最终计算结果 否则 不使用
    // job.setCombinerClass(WordCountReduce.class);
    // 指定当前Job的 Reducer
    job.setReducerClass(WordCountReduce.class);

    // 设置 map 输出 key 的数据类型
    job.setMapOutputValueClass(Text.class);
    // 设置 map 输出 value 的数据类型
    job.setMapOutputValueClass(IntWritable.class);
    // 设置 reduce 输出 key 的数据类型
    job.setOutputKeyClass(Text.class);
    // 设置 reduce 输出 value 的数据类型
    job.setOutputValueClass(IntWritable.class);
    // 定义 map 输入的路径 注意：该路径默认为hdfs路径
    FileInputFormat.addInputPath(job, new Path("/WordCount/input/wcdata.txt"));
    // 定义 reduce 输出数据持久化的路径 注意：该路径默认为hdfs路径
    Path path = new Path("/wordcount/sort/李昊哲");
    // 根据配置项获取 HDFS 文件系统
    FileSystem fs = path.getFileSystem(conf);
    if (fs.exists(path)) {
      // 如果 数据输出目录存在 则将数据输出目录删除
      fs.delete(path, true);
    }
    FileOutputFormat.setOutputPath(job, dst);
    // 提交 job
    System.exit(job.waitForCompletion(true) ? 0 : 1);
  }
}
MapReduce排序—分组排序
Junds0的博客
11-20 2553
任务描述本关任务：对天气数据按照一定排序规则进行排序。相关知识首先，我们回顾一下在 MapReduce 中，排序和分组在哪里被执行：,从上图中可以清楚地看出，在 Step1.4 也就是第四步中，需要对不同分区中的数据进行排序和分组，默认情况下，是按照 key 进行排序和分组。在一些特定的数据文件中，不一定都是类似于 WordCount 单次统计这种规范的数据，比如下面这类数据，它虽然只有两列，但是却有一定的实践意义。
java mapreduce实例_Mapreduce实例——排序
weixin_42465953的博客
02-26 953
原理Map、Reduce任务中Shuffle和排序的过程图如下：流程分析：1.Map端：(1)每个输入分片会让一个map任务来处理，默认情况下，以HDFS的一个块的大小(默认为64M)为一个分片，当然我们也可以设置块的大小。map输出的结果会暂且放在一个环形内存缓冲区中(该缓冲区的大小默认为100M，由io.sort.mb属性控制)，当该缓冲区快要溢出时(默认为缓冲区大小的80%，由io.sort...
整理一下Mapreduce的排序方法
StephenYou的自习室
08-23 4947
MR之排序概念排序分类部分排序全排序辅助排序二次排序自定义排序自定义排序案例需求分析数据准备思路分析代码编写FlowBean自定义序列化类 概念 排序是MapReduce框架中最重要的操作之一。MapTask和ReduceTask均会对数据（按照key）进行排序。该操作属于Hadoop的默认行为。任何应用程序中的数据均会被排序，而不管逻辑上是否需要。默认排序是按照字典顺序排序，且实现该排序的方法是...
Mapreduce的排序
L13763338360的博客
08-16 4729
1. Mapreduce排序 排序是MapReduce的灵魂，MapReduce在Map和Reduce的两个阶段当中，都在反复地执行排序。 1.1 全局排序 排序分为全局排序、部分排序、二次排序、辅助排序。全局排序，就是在一个MapReduce程序产生的输出文件中，所有的结果都是按照某个策略进行排序的，例如降序还是升序。MapReduce只能保证一个分区内的数据是key有序的，一个分区对应一个reduce，因此只有一个reduce就保证了数据全局有序，但是这样又不能用到Hadoop集群的优势。 1.
MapReduce排序
功不唐捐，玉汝于成
05-20 1626
MapReduce排序、全排序、二次排序、区内排序
三种方法实现Hadoop(MapReduce)全局排序(1)
kuajiejuneng的博客
08-12 1218
我们可能会有些需求要求MapReduce的输出全局有序，这里说的有序是指Key全局有序。但是我们知道，MapReduce默认只是保证同一个分区内的Key是有序的，但是不保证全局有序。基于此，本文提供三种方法来对MapReduce的输出进行全局排序。 文章目录 1.生成测试数据 2.使用一个Reduce进行排序 3.自定义分区函数实现全局有序 1.生成测...
MapReduce 实现员工信息按部门薪水排序
最新发布
10-01
本文介绍了如何通过 Hadoop 和 MapReduce 技术实现基于员工薪资信息进行排序的具体操作步骤。先配置 pom.xml，以便于用Maven 构建项目生成 JAR 文件，并设置应用程序的入口类为 EmployeeSortMain 主类。上传emp.csv ...
MapReduce实现单词计数并排序.zip_mapReduce_云计算_单词计数_统计单词_输出前三
09-24
在这个场景中，我们将使用MapReduce来实现一个特定的应用，即对文本文档中的单词进行计数，并按照频率进行排序，最后输出出现频率最高的前三个单词。 **Map阶段** 在Map阶段，输入的数据被分割成多个块，每个块由一...
利用MapReduce实现自定义排序
qq_44735442的博客
06-16 1373
利用MapReduce实现自定义排序 1.第一种实现的方式是：将数据封装到list中，使用集合的排序方法实现排序在cleanup方法中加入代码实现排序； 所以这里只适合把所有的数据都放在一个pojo中； 2.第二种是将pojo类作为key从Mapper传递到Reducer，然后值作为key，然后遍历进行传递。 3.共同点：两种方式都要实现WritableComparable接口，重写compareTo()方法，然后指定两个int类型的数据相减， 或者也可以指定多字段进行排序 1.Pojo类（用来实现排序的，
MapReduce排序之GroupingComparator
凉茶铺的博客
10-03 683
介绍了MapReduce排序中的GroupingComparator排序方式
Hadoop-MapReduce排序(超级详细)
互联网知识分享
05-09 3028
如果使用某一个字段进行辅助排序，那么这个字段"必须"在之前"有过排序"的处理，所有"辅助"顾名思义就是在前者排序好的基础上发挥的作用, 单独使用的辅助排序 很可能生成的结果顺序是乱的,最好不要使用。使用对象的某字段值分组，对象间的某字段的值相同，则这些对象就会组成一个"变化key,就是一个key"，而value会聚集成迭代器，而这个变化key是根据遍历迭代器产生value"对应的对象做为key"。阶段的排序，负责接接收shuffle处理好的数据，直接循环迭代( key,valus{..} )即可。
Hadoop基础教程-第7章 MapReduce进阶（7.1 MapReduce过程）（草稿）
程裕强的专栏
06-02 2170
第7章 MapReduce进阶7.1 MapReduce过程7.1.1 input一般而言，数据文件都会上传到HDFS上，也就是说HDFS上的文件作为MapReduce的输入。已知block块大小是128M（Hadoop 2.x默认的blockSize是128MB，Hadoop 1.x默认的blockSize是64MB）。MapReduce计算框架首先会用InputFormat的子类FileInpu
MapReduce 实现全排序的方式
wisgood的专栏
02-23 6753
MapReduce实现全排序的方式
MapReduce学习4-1：排序
qq_43967413的博客
01-01 2281
1 排序分类2 相关接口3 比较器的自定义与配置3.1 Text类的自定义比较器3.2 比较器获取与配置 在MapRedece的Shuffle过程中存在排序，例如溢出前的快速排序、磁盘上的归并排序，该过程是自动进行的。无论reduceTask还是mapTask默认是按字典顺序排序，并且默认是对key的字典顺序排序。Shuffle相关可以参考：MapReduce学习4：框架原理详解 排序的关键在于比较。以下详细介绍 1 排序分类 部分排序：MapReduce根据输入记录的键对数据集排序。保证输出的每个文件内.
mapreduce实现排序
绵绵的博客
09-19 865
近几次的分享都是关于mapreduce的，下面就排序进行讲解 package DemoSort; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.conf.Configured; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.NullWritable; import org.apache.hadoop.io.Text; import or
MapReduce程序中的三次排序
qq_43193797的博客
01-07 1870
在Map任务和Reduce任务的过程中，一共发生了3次排序 1）当map函数产生输出时，会首先写入内存的环形缓冲区，当达到设定的阀值，在刷写磁盘之前，后台线程会将缓冲区的数据划分成相应的分区。在每个分区中，后台线程按键进行内排序 2）在Map任务完成之前，磁盘上存在多个已经分好区，并排好序的，大小和缓冲区一样的溢写文件，这时溢写文件将被合并成一个已分区且已排序的输出文件。由于溢写文件已经经过第...
MapReduce三次排序
sunsiyuan521的博客
05-07 1065
题目： 20170308,小强,小牛斗地主,22,360手机助手,0.2版本,北京 20170308,小强,小牛斗地主,14,360手机助手,0.3版本,北京 20170308,小强,小牛斗地主,13,360手机助手,0.3版本,北京 20170308,小强,小牛斗地主,16,360手机助手,0.4版本,北京 20170308,小强,小牛斗地主,18,360手机助手,0.4版本,北京
MapReduce中的排序
weixin_45675924的博客
07-19 1130
一、排序概述 1、在MapReduce的shuffle过程中执行了三次排序，分别是： map的溢写阶段：根据分区以及key进行快速排序 map的合并溢写文件：将同一个分区的多个溢写文件进行归并排序，合成大的溢写文件 reduce输入阶段：将同一分区，来自不同map task的数据文件进行归并排序 2、在MapReduce整个过程中，默认是会对输出的KV对按照key进行排序的，而且是使用快速排序。 map输出的排序的，其实也就是上面的溢写过程中的排序。 reduce输出的排序，即reduce处理完数据后，
MapReduce二次排序详解与实现
总结起来，MapReduce的secondary sort是一种强大的工具，它允许开发者在MapReduce的流程中实现更复杂的数据排序逻辑，以满足特定的分析需求。通过自定义键的比较函数类和分区策略，我们可以实现更精细的数据处理和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

李昊哲小课

桃李不言下自成蹊

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值