使用java的方式实现Mapreduce单词计数

Mikuc

已于 2024-04-07 14:56:36 修改

阅读量610

点赞数 17

文章标签： java mapreduce 大数据

于 2024-03-30 17:54:23 首次发布

本文链接：https://blog.csdn.net/m0_68467925/article/details/137178072

版权

文章目录

一、初识
二、WordCount.java代码资源
三、主要步骤

一、初识

数据处理阶段：主要涉及数据的清洗、转换和过滤。这个阶段的目标是确保数据的质量和准确性，以便在后续的Map和Reduce阶段能够产生正确的结果。

Map阶段：对输入的数据进行转换和处理，生成一系列的键值对。例如，在WordCount程序中，Map函数接收一个文本行，然后将其切分成单词，为每个单词生成一个键值对，其中键是单词，值是1。

Reduce阶段：接收Map阶段输出的键值对，然后对具有相同键的值进行聚合。在WordCount程序中，Reduce函数接收一个单词和一个值的迭代器（包含该单词的所有出现次数），然后计算总的出现次数。

迭代处理：MapReduce框架允许迭代处理数据，Map和Reduce阶段可以多次运行，直到满足停止条件。

结果输出阶段：一旦完成Map和Reduce阶段，结果将被写入到输出文件中。在WordCount程序中，每个单词及其出现次数将被写入到一个单独的文件中。

二、WordCount.java代码资源

import java.io.IOException;
import java.util.StringTokenizer;

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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
import org.apache.hadoop.mapreduce.Reducer.Context;

public class WordCount {

    
    public static class Map extends Mapper<LongWritable, Text, Text, IntWritable> {

        private final static IntWritable one = new IntWritable(1); // output value
        private Text word = new Text(); // output key

        @Override
        public void map(LongWritable key, Text value, Context context)
                throws IOException, InterruptedException {

            String line = value.toString();
            StringTokenizer tokenizer = new StringTokenizer(line);

            while (tokenizer.hasMoreTokens()) {
                word.set(tokenizer.nextToken());
                context.write(word, one);
            }

        }
    }


    public static class Reduce extends Reducer<Text, IntWritable, Text, IntWritable> {

        @Override
        public void reduce(Text key, Iterable<IntWritable> values,
                Context context) throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            context.write(key, new IntWritable(sum));
        }
    }

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

        if (args.length != 2) {
            System.err
                    .println("Usage: MaxTemperature <input path> <output path>");
            System.exit(-1);
        }

        Job job = new Job(); 
        job.setJarByClass(WordCount.class); 
        job.setJobName("WordCount");

        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        System.exit(job.waitForCompletion(true) ? 0 : 1);

    }

}