编程实现MapReduce操作

已于 2022-11-10 10:17:22 修改
阅读量2.1k 收藏 9
点赞数 1
文章标签： mapreduce hadoop 大数据
于 2022-10-18 10:14:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46406308/article/details/127381125
版权

文章目录

提示：以下是本篇文章正文内容，下面案例可供参考

一、MapReduce的WordCount应用

1.创建maven工程

在这里插入图片描述
⒉.配置工件坐标
在这里插入图片描述
3. 配置pom依赖文件
在这里插入图片描述
4.导入Hadoop配置文件
在这里插入图片描述
5.导入所需要的包
在这里插入图片描述

6.编写map函数方法；

 public static class MyMapper extends Mapper<Object,Text,Text, IntWritable> {
        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();
        public void map(Object key,Text value,Context context)
                throws IOException, InterruptedException {
            StringTokenizer itr = new StringTokenizer(value.toString());
            while (itr.hasMoreTokens()){
                word.set(itr.nextToken());
                context.write(word, one);
            }
        }
    }

7. 编写reduce函数的方法

public static class MyReducer extends Reducer<Text, IntWritable, Text, IntWritable>{
        private IntWritable result = new IntWritable();
        protected void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            result.set(sum);
            context.write(key, result);
        }
    }

8. main函数的调用创建job类

public static void main(String[] args) throws Exception {
        String INPUT_PATH = "hdfs://192.168.10.111:9000/zhangguoqiang";
        String OUTPUT_PATH = "hdfs://192.168.10.111:9000/outputzhangguoqiang";
        Configuration conf = new Configuration();
        final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);
        if (fileSystem.exists(new Path(OUTPUT_PATH))) {
            fileSystem.delete(new Path(OUTPUT_PATH), true);
        }
        Job job = Job.getInstance(conf, "WordCountApp");
        job.setJarByClass(WordCountApp.class);
        job.setMapperClass(MyMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        job.setInputFormatClass(TextInputFormat.class);
        Path inputPath = new Path(INPUT_PATH);
        FileInputFormat.addInputPath(job, inputPath);
        job.setOutputFormatClass(TextOutputFormat.class);
        Path outputPath = new Path(OUTPUT_PATH);
        FileOutputFormat.setOutputPath(job, outputPath);
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

wordcount代码总和

package mapreduce;
import mapreduce.PartitionerApp;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.Partitioner;
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 java.io.IOException;
import java.net.URI;
import java.util.StringTokenizer;
public class WordCountApp {
    public static class MyMapper extends Mapper<Object,Text,Text, IntWritable> {
        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();
        public void map(Object key,Text value,Context context)
                throws IOException, InterruptedException {
            StringTokenizer itr = new StringTokenizer(value.toString());
            while (itr.hasMoreTokens()){
                word.set(itr.nextToken());
                context.write(word, one);
            }
        }
    }
    public static class MyReducer extends Reducer<Text, IntWritable, Text, IntWritable>{
        private IntWritable result = new IntWritable();
        protected void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            result.set(sum);
            context.write(key, result);
        }
    }
    public static void main(String[] args) throws Exception {
        String INPUT_PATH = "hdfs://192.168.10.111:9000/zhangguoqiang";
        String OUTPUT_PATH = "hdfs://192.168.10.111:9000/outputzhangguoqiang";
        Configuration conf = new Configuration();
        final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);
        if (fileSystem.exists(new Path(OUTPUT_PATH))) {
            fileSystem.delete(new Path(OUTPUT_PATH), true);
        }
        Job job = Job.getInstance(conf, "WordCountApp");
        job.setJarByClass(WordCountApp.class);
        job.setMapperClass(MyMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        job.setInputFormatClass(TextInputFormat.class);
        Path inputPath = new Path(INPUT_PATH);
        FileInputFormat.addInputPath(job, inputPath);
        job.setOutputFormatClass(TextOutputFormat.class);
        Path outputPath = new Path(OUTPUT_PATH);
        FileOutputFormat.setOutputPath(job, outputPath);
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

二、Partitioner 操作

1.自定义Partitoner在 MapReduce 中的应用

  private static class MyMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
        @Override
        protected void map(LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
            String[] s = value.toString().split("\t");
            context.write(new Text(s[0]),new IntWritable(Integer.parseInt(s[1])));
        }
    }
    private static class MyReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
        @Override
        protected void reduce(Text key, Iterable<IntWritable> value, Context context)
                throws IOException, InterruptedException {
            int sum= 0;
            for (IntWritable val : value){
                sum += val.get();
            }
            context.write(key,new IntWritable(sum));
        }
    }

2.编写MyPartitioner方法

public static class MyPartitioner extends Partitioner<Text, IntWritable>{
        @Override
        public int getPartition(Text key, IntWritable value, int numPartitons){
            if (key.toString().equals("xiaomi"))
                return 0;
            if (key.toString().equals("huawei"))
                return 1;
            if (key.toString().equals("iphone7"))
                return 2;
            return 3;
        }
    }

3.编写main函数

public static void main(String[] args) throws Exception {
        String INPUT_PATH = "hdfs://192.168.10.111:9000/partitionerzhangguoqiang";
        String OUTPUT_PATH = "hdfs://192.168.10.111:9000/outputpartitionerzhangguoqiang";
        Configuration conf = new Configuration();
        final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);
        if (fileSystem.exists(new Path(OUTPUT_PATH))) {
            fileSystem.delete(new Path(OUTPUT_PATH), true);
        }
        Job job = Job.getInstance(conf, "PartitionerApp");
        job.setJarByClass(PartitionerApp.class);
        job.setMapperClass(MyMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        job.setPartitionerClass(MyPartitioner.class);
        job.setNumReduceTasks(4);
        job.setInputFormatClass(TextInputFormat.class);
        Path inputPath = new Path(INPUT_PATH);
        FileInputFormat.addInputPath(job, inputPath);
        job.setOutputFormatClass(TextOutputFormat.class);
        Path outputPath = new Path(OUTPUT_PATH);
        FileOutputFormat.setOutputPath(job, outputPath);
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

Partitioner完整代码

package mapreduce;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.Partitioner;
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 java.io.IOException;
import java.net.URI;
public class PartitionerApp {
    private static class MyMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
        @Override
        protected void map(LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
            String[] s = value.toString().split("\t");
            context.write(new Text(s[0]),new IntWritable(Integer.parseInt(s[1])));
        }
    }
    private static class MyReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
        @Override
        protected void reduce(Text key, Iterable<IntWritable> value, Context context)
                throws IOException, InterruptedException {
            int sum= 0;
            for (IntWritable val : value){
                sum += val.get();
            }
            context.write(key,new IntWritable(sum));
        }
    }
    public static class MyPartitioner extends Partitioner<Text, IntWritable>{
        @Override
        public int getPartition(Text key, IntWritable value, int numPartitons){
            if (key.toString().equals("xiaomi"))
                return 0;
            if (key.toString().equals("huawei"))
                return 1;
            if (key.toString().equals("iphone7"))
                return 2;
            return 3;
        }
    }
    public static void main(String[] args) throws Exception {
        String INPUT_PATH = "hdfs://192.168.10.111:9000/partitionerzhangguoqiang";
        String OUTPUT_PATH = "hdfs://192.168.10.111:9000/outputpartitionerzhangguoqiang";
        Configuration conf = new Configuration();
        final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);
        if (fileSystem.exists(new Path(OUTPUT_PATH))) {
            fileSystem.delete(new Path(OUTPUT_PATH), true);
        }
        Job job = Job.getInstance(conf, "PartitionerApp");
        job.setJarByClass(PartitionerApp.class);
        job.setMapperClass(MyMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        job.setPartitionerClass(MyPartitioner.class);
        job.setNumReduceTasks(4);
        job.setInputFormatClass(TextInputFormat.class);
        Path inputPath = new Path(INPUT_PATH);
        FileInputFormat.addInputPath(job, inputPath);
        job.setOutputFormatClass(TextOutputFormat.class);
        Path outputPath = new Path(OUTPUT_PATH);
        FileOutputFormat.setOutputPath(job, outputPath);
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

三．排序实现

1.使用MapReduce API实现排序

public static class MyMapper extends Mapper<LongWritable,Text,IntWritable,IntWritable> {
        private static IntWritable data = new IntWritable();

        public void map(LongWritable key, Text value, Context context)
                throws IOException, InterruptedException {
            String line = value.toString();
            data.set(Integer.parseInt(line));
            context.write(data, new IntWritable(1));
        }
    }
        public static class MyReducer extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable> {
             private static IntWritable data = new IntWritable(1);
             public void reduce(IntWritable key,Iterable<IntWritable> values, Context context)
                     throws IOException, InterruptedException {
                     for (IntWritable val : values){
                         context.write(data, key);
                         data = new IntWritable(data.get()+ 1);
                     }
        }
    }

2.编写main函数

public static void main(String[] args) throws Exception {
        String INPUT_PATH = "hdfs://192.168.10.111:9000/sortzhangguoqiang";
        String OUTPUT_PATH = "hdfs://192.168.10.111:9000/outputsortzhangguoqiang";
        Configuration conf = new Configuration();
        final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);
        if (fileSystem.exists(new Path(OUTPUT_PATH))) {
            fileSystem.delete(new Path(OUTPUT_PATH), true);
        }
        Job job = Job.getInstance(conf, "SortApp");
        job.setJarByClass(SortApp.class);
        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(IntWritable.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputFormat.addInputPath(job, new Path(INPUT_PATH));
        FileOutputFormat.setOutputPath(job, new Path(OUTPUT_PATH));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

sort总体代码

package mapreduce;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.output.FileOutputFormat;
import java.io.IOException;
import java.net.URI;
public class SortApp {
    public static class MyMapper extends Mapper<LongWritable,Text,IntWritable,IntWritable> {
        private static IntWritable data = new IntWritable();

        public void map(LongWritable key, Text value, Context context)
                throws IOException, InterruptedException {
            String line = value.toString();
            data.set(Integer.parseInt(line));
            context.write(data, new IntWritable(1));
        }
    }
        public static class MyReducer extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable> {
             private static IntWritable data = new IntWritable(1);
             public void reduce(IntWritable key,Iterable<IntWritable> values, Context context)
                     throws IOException, InterruptedException {
                     for (IntWritable val : values){
                         context.write(data, key);
                         data = new IntWritable(data.get()+ 1);
                     }
        }
    }
    public static void main(String[] args) throws Exception {
        String INPUT_PATH = "hdfs://192.168.10.111:9000/sortzhangguoqiang";
        String OUTPUT_PATH = "hdfs://192.168.10.111:9000/outputsortzhangguoqiang";
        Configuration conf = new Configuration();
        final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);
        if (fileSystem.exists(new Path(OUTPUT_PATH))) {
            fileSystem.delete(new Path(OUTPUT_PATH), true);
        }
        Job job = Job.getInstance(conf, "SortApp");
        job.setJarByClass(SortApp.class);
        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(IntWritable.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputFormat.addInputPath(job, new Path(INPUT_PATH));
        FileOutputFormat.setOutputPath(job, new Path(OUTPUT_PATH));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

四．二次排序实现

1.编写IntPair方法

public static class IntPair implements WritableComparable<IntPair> {
        private int first = 0;
        private int second = 0;
        public void set(int left, int right) {
            first = left;
            second = right;
        }
        public int getFirst() {
            return first;
        }
        public int getSecond() {
            return second;
        }
        @Override
        public void readFields(DataInput in) throws IOException{
            first = in.readInt();
            second = in.readInt();
        }
        @Override
        public void write(DataOutput out) throws IOException {
            out.writeInt(first);
            out.writeInt(second);
        }
        @Override
        public int hashCode() {
            return first+"".hashCode() + second+"".hashCode();
        }
        @Override
        public boolean equals(Object right){
            if (right instanceof IntPair){
                IntPair r = (IntPair) right;
                return r.first == first && r.second == second;
            }else {
                return  false;
            }
        }
        @Override
        public int compareTo(IntPair o){
            if (first != o.first){
                return first - o.first;
            } else if (second != o.second){
                return second - o.second;
            }else {
                return 0;
            }
        }
    }

2.编写secondsort

public static class MyMapper extends Mapper<LongWritable, Text, IntPair, IntWritable>{
        private final IntPair key = new IntPair();
        private final IntWritable value = new IntWritable();
        @Override
        public void map(LongWritable inKey, Text inValue,Context context)
                throws IOException, InterruptedException{
            StringTokenizer itr = new StringTokenizer(inValue.toString());
            int left = 0;
            int right = 0;
            if (itr.hasMoreTokens()){
                left = Integer.parseInt(itr.nextToken());
                if (itr.hasMoreTokens()) {
                    right = Integer.parseInt(itr.nextToken());
                }
                key.set(left, right);
                value.set(right);
                context.write(key, value);
            }
        }
    }
    public static class GroupingComparator implements RawComparator<IntPair> {
        @Override
        public int compare(byte[] b1,int s1,int l1,byte[] b2,int s2, int l2){
            return WritableComparator.compareBytes(b1, s1, Integer.SIZE/8,b2,s2, Integer.SIZE/8);
        }
        @Override
        public int compare(IntPair o1, IntPair o2) {
            int first1 = o1.getFirst();
            int first2 = o2.getFirst();
            return first1 - first2;
        }
    }
    public static class MyReducer extends Reducer<IntPair, IntWritable, Text, IntWritable>{
        private static final Text SEPARATOR=new Text("-------------");
        private final Text first = new Text();
        @Override
        public void reduce(IntPair key, Iterable<IntWritable> values, Context context)
                throws IOException,InterruptedException {
            context.write(SEPARATOR, null);
            first.set(Integer.toString(key.getFirst()));
            for(IntWritable value: values){
                context.write(first, value);
            }
        }
    }

3.编写main函数

public static void main(String[] args) throws Exception {
        String INPUT_PATH = "hdfs://192.168.10.111:9000/secondsortzhangguoqiang";
        String OUTPUT_PATH = "hdfs://192.168.10.111:9000/outputsecondsortzhangguoqiang";
        Configuration conf = new Configuration();
        final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);
        if (fileSystem.exists(new Path(OUTPUT_PATH))) {
            fileSystem.delete(new Path(OUTPUT_PATH), true);
        }
        Job job =Job.getInstance(conf, "SecondarySortApp");
        job.setJarByClass(SecondarySortApp.class);
        FileInputFormat.setInputPaths(job, new Path(INPUT_PATH));
        FileOutputFormat.setOutputPath(job, new Path(OUTPUT_PATH));
        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReducer.class);
        job.setGroupingComparatorClass(GroupingComparator.class);
        job.setMapOutputKeyClass(IntPair.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        job.setInputFormatClass(TextInputFormat.class);
        job.setOutputFormatClass(TextOutputFormat.class);
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

二次排序完整代码

package mapreduce;
import org.apache.hadoop.io. WritableComparable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.net.URI;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Partitioner;
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;
public class SecondarySortApp {
    public static class IntPair implements WritableComparable<IntPair> {
        private int first = 0;
        private int second = 0;
        public void set(int left, int right) {
            first = left;
            second = right;
        }
        public int getFirst() {
            return first;
        }
        public int getSecond() {
            return second;
        }
        @Override
        public void readFields(DataInput in) throws IOException{
            first = in.readInt();
            second = in.readInt();
        }
        @Override
        public void write(DataOutput out) throws IOException {
            out.writeInt(first);
            out.writeInt(second);
        }
        @Override
        public int hashCode() {
            return first+"".hashCode() + second+"".hashCode();
        }
        @Override
        public boolean equals(Object right){
            if (right instanceof IntPair){
                IntPair r = (IntPair) right;
                return r.first == first && r.second == second;
            }else {
                return  false;
            }
        }
        @Override
        public int compareTo(IntPair o){
            if (first != o.first){
                return first - o.first;
            } else if (second != o.second){
                return second - o.second;
            }else {
                return 0;
            }
        }
    }
    public static class MyMapper extends Mapper<LongWritable, Text, IntPair, IntWritable>{
        private final IntPair key = new IntPair();
        private final IntWritable value = new IntWritable();
        @Override
        public void map(LongWritable inKey, Text inValue,Context context)
                throws IOException, InterruptedException{
            StringTokenizer itr = new StringTokenizer(inValue.toString());
            int left = 0;
            int right = 0;
            if (itr.hasMoreTokens()){
                left = Integer.parseInt(itr.nextToken());
                if (itr.hasMoreTokens()) {
                    right = Integer.parseInt(itr.nextToken());
                }
                key.set(left, right);
                value.set(right);
                context.write(key, value);
            }
        }
    }
    public static class GroupingComparator implements RawComparator<IntPair> {
        @Override
        public int compare(byte[] b1,int s1,int l1,byte[] b2,int s2, int l2){
            return WritableComparator.compareBytes(b1, s1, Integer.SIZE/8,b2,s2, Integer.SIZE/8);
        }
        @Override
        public int compare(IntPair o1, IntPair o2) {
            int first1 = o1.getFirst();
            int first2 = o2.getFirst();
            return first1 - first2;
        }
    }
    public static class MyReducer extends Reducer<IntPair, IntWritable, Text, IntWritable>{
        private static final Text SEPARATOR=new Text("-------------");
        private final Text first = new Text();
        @Override
        public void reduce(IntPair key, Iterable<IntWritable> values, Context context)
                throws IOException,InterruptedException {
            context.write(SEPARATOR, null);
            first.set(Integer.toString(key.getFirst()));
            for(IntWritable value: values){
                context.write(first, value);
            }
        }
    }
    public static void main(String[] args) throws Exception {
        String INPUT_PATH = "hdfs://192.168.10.111:9000/secondsortzhangguoqiang";
        String OUTPUT_PATH = "hdfs://192.168.10.111:9000/outputsecondsortzhangguoqiang";
        Configuration conf = new Configuration();
        final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);
        if (fileSystem.exists(new Path(OUTPUT_PATH))) {
            fileSystem.delete(new Path(OUTPUT_PATH), true);
        }
        Job job =Job.getInstance(conf, "SecondarySortApp");
        job.setJarByClass(SecondarySortApp.class);
        FileInputFormat.setInputPaths(job, new Path(INPUT_PATH));
        FileOutputFormat.setOutputPath(job, new Path(OUTPUT_PATH));
        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReducer.class);
        job.setGroupingComparatorClass(GroupingComparator.class);
        job.setMapOutputKeyClass(IntPair.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        job.setInputFormatClass(TextInputFormat.class);
        job.setOutputFormatClass(TextOutputFormat.class);
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

五、hadoop实现

1.生成可执行的jar包
在这里插入图片描述
2.将jar包上传 到/home/admin/file/mapreduce
在这里插入图片描述

3.上传hello.txt,par_1.txt和part_2.txt,sort.txt,second.txt文件到hadoop HDFS
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
3.运行jar包
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

六、出现的问题与解决方案

问题1：在eclipse或idea中终端打开失败无法导出WordCountjar包
解决：在cmd中进入该项目文件夹，输入命令，导出的jar包在target目录下
问题2：partitionerjar包运行时报错java.lang.ArrayIndexOutOfBoundsException: 1
解决：这是因为在txt文件中使用了空格隔开数据，代码中使用的是tab分隔，将txt中的空格换为tab即可(数据之间只能用一个tab隔开)

林图
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MapReduce优缺点
weixin_38023225的博客
09-18 3363
优点 1．MapReduce易于编程 它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的PC机器上运行。也就是说你写一个分布式程序，跟写一个简单的串行程序是一模一样的。就是因为这个特点使得MapReduce编程变得非常流行。 2．良好的扩展性 当你的计算资源不能得到满足的时候，你可以通过简单的增加机器来扩展它的计算能力。 3．高容错性 MapReduc...
Mapreduce（Java程序编写）
weixin_53788274的博客
03-23 1941
Mapreduce：Map阶段Reduce阶段
MapReduce代码
最新发布
Saniana的博客
05-14 715
wordcount 流量统计
云计算 - 3 - 使用MapReduce处理数据
SYSU_Zhiyuan
11-12 1607
1．使用 MapReduce 实现对多个文本文件单词总数的统计（WordCount）。 2．使用 MapReduce 实现社交网站好友的推荐。
【Hadoop-MapReduce】MapReduce编程步骤及工作原理
weixin_53543905的博客
12-25 1658
思想分而治之map：负责分的过程reduce：负责合的过程。【Hadoop-MapReduce】MapReduce编程步骤及工作原理
一文学会MapReduce编程
pengpengsays
01-04 229
MapReduce编程模型，相对于初学者来说，会有一些门槛，没关系，这一篇让你学会使用MapReduce进行分布式处理。 基础知识 MapReduce 框架只对 <key, value> 形式的键值对进行处理。MapReduce会将任务的输入当成一组 <key, value> 键值对，最后也会生成一组 <key, value> 键值对作为结果。常见的输入为文件，此时读取的行偏移量会作为Key，文件内容作为Value。 key 和 value 的类必须由框架来完成序列化，所
大数据实验四-MapReduce编程实践
04-03
使用MapReduce实现多个文本文件中WordCount词频统计功能，实验编写Map处理逻辑、编写Reduce处理逻辑、编写main方法。 二．实验目的 1、通过实验掌握基本的MapReduce编程方法。 2、实现统计HDFS系统中多个文本文件中...
MapReduce之Join操作
03-03
不同于传统的单机模式，在分布式存储的下采用MapReduce编程模型，也有相应的处理措施和优化方法。本文对Hadoop中最基本的join方法进行简单介绍，这也是其它许多方法和优化措施的基础。文中所采用的例子来自于...
实验3MapReduce编程初级实践
10-27
实验的主要目标是编程实现文件合并和去重操作。具体来说，对于两个输入文件，即文件A和文件B，学生需要编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。 MapReduce编程 ...
大数据技术原理及应用课实验5 :MapReduce初级编程实践
01-16
（一）编程实现文件合并和去重操作 对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。下面是输入文件和输出文件的一个样例供参考。 ——...
大数据实验5实验报告：MapReduce 初级编程实践
06-20
（一）编程实现文件合并和去重操作 对于两个输入文件，即文件 A 和文件 B，请编写 MapReduce 程序，对两个文件进行合并， 并剔除其中重复的内容，得到一个新的输出文件 C。下面是输入文件和输出文件的一个样例 供...
MapReduce简单程序示例
12-05
MapReduce简单程序示例
【大数据之Hadoop】十、MapReduce中job提交流程源码分析
阿宁的博客
04-07 310
源码中：job提交三个信息（jar包，xml，切片信息），在本地不需要提交jar包，只有在集群上才需要提交。
MapReduce详解
幽雨雨幽
08-08 646
MapReduce模型简介：     •MapReduce将复杂的、运行于大规模集群上的并行计算过程高度地抽象到了两个函数：Map和Reduce   •编程容易，不需要掌握分布式并行编程细节，也可以很容易把自己的程序运行在分布式系统上，完成海量数据的计算   •MapReduce采用“分而治之”策略，一个存储在分布式文件系统中的大规模数据集，会被切分成许多独立的分片（split），这些分片...
MapReduce之分区案例的代码实现
QYHuiiQ
05-29 478
在此案例中，我们使用学生成绩实现分区功能（第三列为成绩）： 将原始数据上传至HDFS [root@hadoop01 test_data]# hdfs dfs -mkdir /test_partition_input [root@hadoop01 test_data]# hdfs dfs -put test_partiton.csv /test_partition_input 新建project： 引入pom依赖 <?xml version="1.0" encoding="UTF-.
Mapreduce编程
weixin_44216665的博客
08-13 895
1）分布式的运算程序往往需要分成只少2个阶段（2）第一个阶段的MapTask并发实例。完全并行运行，互补相干（3）第二个阶段的ReduceTask并发实例互不相干，但是他们的数据依赖于上一个阶段的所有MapTask并发实例的输出。（4）MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段，如果用户的业务逻辑非常复杂，只能多个MapReduce程序，串行运行。...
MapReduce基础编程之按日期统计及按日期排序
邵奈一的博客
05-17 1871
大家好，我是邵奈一，一个不务正业的程序猿、正儿八经的斜杠青年。 1、世人称我为：被代码耽误的诗人、没天赋的书法家、五音不全的歌手、专业跑龙套演员、不合格的运动员… 2、这几年，我整理了很多IT技术相关的教程给大家，爱生活、爱分享。 3、如果您觉得文章有用，请收藏，转发，评论，并关注我，谢谢！ 博客导航跳转（请收藏）：邵奈一的技术博客导航 | 公众号 | 微信 | CSDN | 掘金 | 51CTO | 简书 | 微博 | 教程目录0x00 教程内容0x01 项目准备1. 新建Maven项目2. 需求.
MapReduce分区-代码实现
Leon_Jinhai_Sun的博客
02-27 583
自定义 Partitioner 主要的逻辑就在这里, 这也是这个案例的意义, 通过 Partitioner 将数据分发给不同的Reducer /** * 这里的输入类型与我们map阶段的输出类型相同 */ public class MyPartitioner extends Partitioner<Text,NullWritable>{ /** * 返回值表示我们的数据要去...
MapReduce基础编程简介
EMILY_077的博客
03-08 385
MapReduce基础编程简介
mapreduce编程实现文件合并和去重操作
06-28
MapReduce编程可以实现文件合并和去重操作。具体步骤如下： 1. 首先，将需要合并和去重的文件上传到Hadoop分布式文件系统（HDFS）中。 2. 接着，编写MapReduce程序，其中Mapper阶段的任务是将输入文件中的每一行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值