Hadoop continues to be relevant in certain use cases, particularly in big data processing and analytics. However, the landscape of big data technologies has evolved, and new frameworks like Apache Spark have gained popularity for their performance improvements and ease of use.

Hadoop’s core components, Hadoop Distributed File System (HDFS) and MapReduce, are still used in some scenarios, but organizations are increasingly adopting more modern and versatile tools. Apache Spark, for example, is often preferred for its in-memory processing capabilities, making it faster than MapReduce for certain workloads.

That being said, let me provide a basic example of Hadoop usage:

Example: Word Count with Hadoop MapReduce

Suppose you have a large text document, and you want to count the frequency of each word using Hadoop MapReduce.

1. Input Data: Let’s say you have a text file named input.txt with the following content:

Hello World
This is a sample document
Hello Hadoop

2. MapReduce Job: You can create a MapReduce program to count the words. The Mapper will tokenize the input text into words and emit key-value pairs, and the Reducer will aggregate the counts for each word.

  • Mapper:
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
    private final static IntWritable one = new IntWritable(1);
    private Text word = new Text();

    public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        StringTokenizer tokenizer = new StringTokenizer(value.toString());
        while (tokenizer.hasMoreTokens()) {
            context.write(word, one);
  • Reducer:
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
    private IntWritable result = new IntWritable();

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

3. Run the Job: You compile and package your code into a JAR file and then run it on your Hadoop cluster.

hadoop jar WordCount.jar WordCountDriver input.txt output

The output would show the word frequencies:

Hello    2
World    1
This     1
is       1
a        1
sample   1
document 1
Hadoop   1

While this example demonstrates a basic Hadoop MapReduce job, it’s important to note that for many use cases, other frameworks like Apache Spark or Apache Flink are preferred due to their improved performance and higher-level abstractions. Always consider the specific requirements of your data processing tasks when choosing a technology stack.


Leave a Reply

Avatar placeholder

Your email address will not be published. Required fields are marked *