Hadoop MapReduce：如何在Reducer中获取总字母数以计算字母频率

嘿，我明白你现在的困境——已经能统计每个字母的出现次数，但要算出频率（次数/总字母数）却卡在了怎么让Reducer拿到总字母数上。这里有两种实用的方案，帮你搞定这个问题：

方案一：分两次MapReduce Job执行 #

这是最直观的思路，先算出总字母数，再用这个总数去计算每个字母的频率：

1. 第一次Job：统计总字母数

   • Mapper：不管输入的字母是什么，都输出固定Key（比如"__TOTAL__"），值为1
   • Reducer：对所有1求和，得到整个句子的总字母数，把结果写入一个输出文件（比如total.txt）

2. 第二次Job：计算字母频率

   • 先把第一次Job得到的总字母数读取出来，放到Job的Configuration里（或者通过分布式缓存传递）
   • Mapper：和你现在的实现一样，每个字母作为Key，值为1
   • Reducer：在setup()方法里从Configuration中取出总字母数，然后对每个字母的次数求和，最后用次数 / 总字母数得到频率并输出

示例代码片段（Reducer部分）：

public class FrequencyReducer extends Reducer<Text, IntWritable, Text, DoubleWritable> {
    private int totalLetters;

    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        // 从Configuration中获取总字母数
        totalLetters = context.getConfiguration().getInt("total.letters", 0);
    }

    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int count = 0;
        for (IntWritable val : values) {
            count += val.get();
        }
        // 计算频率
        double frequency = (double) count / totalLetters;
        context.write(key, new DoubleWritable(frequency));
    }
}

方案二：单Job内完成（自定义排序+分区） #

如果不想跑两次Job，可以通过自定义Key和排序规则，让Reducer先拿到总字母数，再处理每个字母：

1. 自定义Writable Key
   创建一个包含type和letter的自定义Key，type用来区分是总计数请求还是普通字母（比如0代表总计数，1代表普通字母）：

public class CustomKey implements WritableComparable<CustomKey> {
    private int type; // 0: 总计数标记, 1: 普通字母
    private Text letter;

    // 实现Writable和Comparable的方法，排序时让type=0的Key先被处理
    @Override
    public int compareTo(CustomKey o) {
        if (this.type != o.type) {
            return Integer.compare(this.type, o.type); // 让总计数Key排在前面
        }
        return this.letter.compareTo(o.letter);
    }

    // 省略write()、readFields()、构造方法等
}

2. Mapper调整
   Mapper输出两种Key：

   • 对每个字母，输出type=1，letter为当前字母，值为1
   • 额外输出一个type=0，letter为固定值（比如"total"），值为1

3. Reducer处理
   Reducer先处理type=0的Key，计算出总字母数并保存，之后处理每个type=1的字母时，用总数值计算频率：

public class SingleJobFrequencyReducer extends Reducer<CustomKey, IntWritable, Text, DoubleWritable> {
    private int totalLetters;

    @Override
    protected void reduce(CustomKey key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int count = 0;
        for (IntWritable val : values) {
            count += val.get();
        }
        if (key.getType() == 0) {
            // 先处理总计数，保存下来
            totalLetters = count;
        } else {
            // 计算并输出频率
            double frequency = (double) count / totalLetters;
            context.write(key.getLetter(), new DoubleWritable(frequency));
        }
    }
}

这种方案需要注意自定义Partitioner，确保所有Key（包括总计数和普通字母）都进入同一个Reducer，不然总计数和字母可能分到不同Reducer，拿不到总数值。

两种方案各有优劣：方案一简单易维护，适合数据量不大的场景；方案二减少了Job次数，效率更高，适合大数据量场景。你可以根据自己的需求选择~

内容的提问来源于stack exchange，提问作者Oblivion