hadoop MapReduce编程初级实践

最新推荐文章于 2024-06-11 15:54:09 发布
最新推荐文章于 2024-06-11 15:54:09 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： hadoop 文章标签： hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43924621/article/details/118094739
版权

各种坑

没有导入包

Caused by: java.lang.ClassNotFoundException: org.apache.hadoop.yarn.exceptions.YarnException org.apache.hadoop.conf.Configuration

把yarn的包都导入了

连不上IP

Failed to connect to /127.0.0.1:9866 for block BP-1097528271-127.0.1.1-1619346840026:blk_1073741829_1005, add to deadNodes and continue.

伪分布式安装没装好，修改配置/usr/local/hadoop/etc/hadoop/core-site.xml
将

<name>fs.defaultFS</name>
<value>hdfs://localhost:9000</value>

中的localhost改成虚拟机的IP

End of File Exception between local host is: “Nick/192.168.137.1”; destination host is: “192.168.2.128”:9200; :

修改后连接的IP要修改
在这里插入图片描述

目录不存在

Exception in thread “main” org.apache.hadoop.mapreduce.lib.input.InvalidInputException: Input path does not exist: hdfs://192.168.2.128:9000/user/hadoop/input

实验内容

先将文件上传
hdfs dfs -mkdir -p /user/hadoop/input
hdfs dfs -put A.txt /user/hadoop/input

删除output目录
hdfs dfs -rm -r /user/hadoop/output

一 编程实现文件合并和去重操作

代码


import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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.util.GenericOptionsParser;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class Merge {

    /**
     * @param args
     * 对A,B两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C
     */
    //在这重载map函数，直接将输入中的value复制到输出数据的key上 注意在map方法中要抛出异常：throws IOException,InterruptedException
    public static class Map extends Mapper<Object, Text, Text, Text> {
        private static Text text = new Text();
        public void map(Object key, Text value, Context content) throws IOException, InterruptedException {

            text = value;
            content.write(text, new Text(""));
        }
    }
    //在这重载reduce函数，直接将输入中的key复制到输出数据的key上  注意在reduce方法上要抛出异常：throws IOException,InterruptedException
    public static class Reduce extends Reducer<Text, Text, Text, Text> {
        public void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
            context.write(key, new Text(""));
        }
    }

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

        // TODO Auto-generated method stub
        Configuration conf = new Configuration();
        conf.set("fs.defaultFS","hdfs://192.168.2.182:9000");
        String[] otherArgs = new String[]{"input","output"}; /* 直接设置输入参数 */
        if (otherArgs.length != 2) {
            System.err.println("Usage: wordcount <in> <out>");
            System.exit(2);
        }
        Job job = Job.getInstance(conf,"Merge and duplicate removal");
        job.setJarByClass(Merge.class);
        job.setMapperClass(Map.class);
        job.setCombinerClass(Reduce.class);
        job.setReducerClass(Reduce.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

运行结果在这里插入图片描述在这里插入图片描述
hdfs dfs -cat /user/hadoop/output/part-r-00000

在这里插入图片描述

二 编程实现对输入文件的排序

代码



import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;


public class MergeSort {

    /**
     * @param args
     * 输入多个文件，每个文件中的每行内容均为一个整数
     * 输出到一个新的文件中，输出的数据格式为每行两个整数，第一个数字为第二个整数的排序位次，第二个整数为原待排列的整数
     */
    //map函数读取输入中的value，将其转化成IntWritable类型，最后作为输出key
    public static class Map extends Mapper<Object, Text, IntWritable, IntWritable>{

        private static IntWritable data = new IntWritable();
        public void map(Object key, Text value, Context context) throws IOException,InterruptedException{
            /********** Begin **********/
            String line = value.toString();
            data.set(Integer.parseInt(line));
            context.write(data, new IntWritable(1));
            /********** End **********/

        }
    }

    //reduce函数将map输入的key复制到输出的value上，然后根据输入的value-list中元素的个数决定key的输出次数,定义一个全局变量line_num来代表key的位次
    public static class Reduce extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable>{
        private static IntWritable line_num = new IntWritable(1);

        public void reduce(IntWritable key, Iterable<IntWritable> values, Context context) throws IOException,InterruptedException{
            /********** Begin **********/
            for(IntWritable num : values) {
                context.write(line_num, key);
                line_num = new IntWritable(line_num.get() + 1);
            }
            /********** End **********/
        }
    }

    //自定义Partition函数，此函数根据输入数据的最大值和MapReduce框架中Partition的数量获取将输入数据按照大小分块的边界，然后根据输入数值和边界的关系返回对应的Partiton ID
    public static class Partition extends Partitioner<IntWritable, IntWritable>{
        public int getPartition(IntWritable key, IntWritable value, int num_Partition){
            /********** Begin **********/
            int Maxnumber = 65223;//int型的最大数值
            int bound = Maxnumber / num_Partition + 1;
            int Keynumber = key.get();
            for(int i = 0; i < num_Partition; i++){
                if(Keynumber < bound * i && Keynumber >= bound * (i - 1)) {
                    return i - 1;
                }
            }
            return -1 ;
            /********** End **********/

        }
    }

    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        Configuration conf = new Configuration();
        conf.set("fs.defaultFS","hdfs://192.168.2.128:9000");
        String[] otherArgs = new String[]{"input2","output2"}; /* 直接设置输入参数 */
        if (otherArgs.length != 2) {
            System.err.println("Usage: wordcount <in> <out>");
            System.exit(2);
        }
        Job job = Job.getInstance(conf,"Merge and Sort");
        job.setJarByClass(MergeSort.class);
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        job.setPartitionerClass(Partition.class);
        job.setOutputKeyClass(IntWritable.class);
        job.setOutputValueClass(IntWritable.class);
        System.out.println(new Path(otherArgs[0]));
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);

    }
}

在这里插入图片描述

三 对给定的表格进行信息挖掘

child parent
Steven Lucy
Steven Jack
Jone Lucy
Jone Jack
Lucy Mary
Lucy Frank
Jack Alice
Jack Jesse
David Alice
David Jesse
Philip David
Philip Alma
Mark David
Mark Alma

hdfs dfs -put /home/hadoop/child-parent.txt /user/hadoop/input3

import java.io.IOException;
import java.util.*;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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 org.apache.hadoop.util.GenericOptionsParser;

public class child_parent {
    public static int time = 0;

    /**
     * @param args
     * 输入一个child-parent的表格
     * 输出一个体现grandchild-grandparent关系的表格
     */
    //Map将输入文件按照空格分割成child和parent，然后正序输出一次作为右表，反序输出一次作为左表，需要注意的是在输出的value中必须加上左右表区别标志
    public static class Map extends Mapper<Object, Text, Text, Text>{
        public void map(Object key, Text value, Context context) throws IOException,InterruptedException{
            String child_name = new String();
            String parent_name = new String();
            String relation_type = new String();
            String line = value.toString();
            int i = 0;
            while(line.charAt(i) != ' '){
                i++;
            }
            String[] values = {line.substring(0,i),line.substring(i+1)};
            if(values[0].compareTo("child") != 0){
                child_name = values[0];
                parent_name = values[1];
                relation_type = "1";//左右表区分标志
                context.write(new Text(values[1]), new Text(relation_type+"+"+child_name+"+"+parent_name));
                //左表
                relation_type = "2";
                context.write(new Text(values[0]), new Text(relation_type+"+"+child_name+"+"+parent_name));
                //右表
            }
        }
    }

    public static class Reduce extends Reducer<Text, Text, Text, Text>{
        public void reduce(Text key, Iterable<Text> values,Context context) throws IOException,InterruptedException{
            if(time == 0){   //输出表头
                context.write(new Text("grand_child"), new Text("grand_parent"));
                time++;
            }
            int grand_child_num = 0;
            String grand_child[] = new String[10];
            int grand_parent_num = 0;
            String grand_parent[]= new String[10];
            Iterator ite = values.iterator();
            while(ite.hasNext()){
                String record = ite.next().toString();
                int len = record.length();
                int i = 2;
                if(len == 0) continue;
                char relation_type = record.charAt(0);
                String child_name = new String();
                String parent_name = new String();
                //获取value-list中value的child

                while(record.charAt(i) != '+'){
                    child_name = child_name + record.charAt(i);
                    i++;
                }
                i=i+1;
                //获取value-list中value的parent
                while(i<len){
                    parent_name = parent_name+record.charAt(i);
                    i++;
                }
                //左表，取出child放入grand_child
                if(relation_type == '1'){
                    grand_child[grand_child_num] = child_name;
                    grand_child_num++;
                }
                else{//右表，取出parent放入grand_parent
                    grand_parent[grand_parent_num] = parent_name;
                    grand_parent_num++;
                }
            }

            if(grand_parent_num != 0 && grand_child_num != 0 ){
                for(int m = 0;m<grand_child_num;m++){
                    for(int n=0;n<grand_parent_num;n++){
                        context.write(new Text(grand_child[m]), new Text(grand_parent[n]));
                        //输出结果
                    }
                }
            }
        }
    }
    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        Configuration conf = new Configuration();
        conf.set("fs.default.name","hdfs://192.168.2.128:9000");
        String[] otherArgs = new String[]{"input3","output3"}; /* 直接设置输入参数 */
        if (otherArgs.length != 2) {
            System.err.println("Usage: wordcount <in><out>");
            System.exit(2);
        }
        Job job = Job.getInstance(conf,"Single table join");
        job.setJarByClass(child_parent.class);
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);

    }
}

在这里插入图片描述

代码参考： 林子雨编著《大数据基础编程、实验和案例教程（第2版）》教材附录A的代码
http://dblab.xmu.edu.cn/blog/2808-2/

合并文件

one.txt

yongpeng weidong weinan
sanfeng luozong xiaoming

two.txt

longlong fanfan
mazong kailun yuhang yixin
longlong fanfan
mazong kailun yuhang yixin

three.txt

shuaige changmo zhenqiang 
dongli lingu xuanxuan

代码：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.*;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.SequenceFileOutputFormat;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import java.io.IOException;

/**
 * @program: test2_java1
 * @ClassName ：Combine
 * @Description：
 * @Author ：Nick
 * @Date ：2021-06-21 22:48
 **/
public class Combine {

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

        // 输入输出路径需要根据自己电脑上实际的输入输出路径设置
        String inputDir = "/inputdata";
        String outputDir = "/output";
        process(inputDir, outputDir);
    }


    /**
     * 执行hdfs
     * @param inputDir 输入文件夹地址
     * @param outputDir 输出文件夹地址
     * @throws IOException
     * @throws InterruptedException
     * @throws ClassNotFoundException
     */
    private static void process(String inputDir, String outputDir) throws IOException, InterruptedException, ClassNotFoundException {

        // 1 获取job对象
        Configuration conf = new Configuration();
        // 设置可以读子目录
        conf.set("mapreduce.input.fileinputformat.input.dir.recursive", "true");
        conf.set("fs.default.name","hdfs://192.168.2.128:9000");
        Job job = Job.getInstance(conf);

        // 2 设置jar包存储位置、关联自定义的mapper和reducer
        job.setJarByClass(Combine.class);
        job.setMapperClass(CombineFileMapper.class);
        job.setReducerClass(CombineFileReducer.class);

        // 7设置输入的inputFormat
        job.setInputFormatClass(CombineFileInputformat.class);

        // 8设置输出的outputFormat
        job.setOutputFormatClass(SequenceFileOutputFormat.class);

        // 3 设置map输出端的kv类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(BytesWritable.class);

        // 4 设置最终输出端的kv类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(BytesWritable.class);

        // 5 设置输入输出路径
        FileInputFormat.setInputPaths(job, new Path(inputDir));
        FileOutputFormat.setOutputPath(job, new Path(outputDir));

        // 6 提交job
        boolean result = job.waitForCompletion(true);
        System.exit(result ? 0 : 1);
    }
}

// 定义类继承FileInputFormat
class CombineFileInputformat extends FileInputFormat<Text, BytesWritable> {

    @Override
    protected boolean isSplitable(JobContext context, Path filename) {
        return false;
    }

    @Override
    public RecordReader<Text, BytesWritable> createRecordReader(InputSplit split, TaskAttemptContext context) throws IOException, InterruptedException {

        CombineFileRecordReader recordReader = new CombineFileRecordReader();
        recordReader.initialize(split, context);

        return recordReader;
    }
}

/**
 * <b>合并小文件 Mapper<br>
 * </b>
 * Text, BytesWritable, Text, BytesWritable
 * 输入Key类型，输入Value类型，输出Key类型，输出Value类型
 */
class CombineFileMapper extends Mapper<Text, BytesWritable, Text, BytesWritable> {

    @Override
    protected void map(Text key, BytesWritable value, Context context) throws IOException, InterruptedException {
        context.write(key, value);
    }
}

class CombineFileRecordReader extends RecordReader<Text, BytesWritable> {

    private Configuration configuration;
    private FileSplit split;

    private boolean isProgress = true;
    private BytesWritable value = new BytesWritable();
    private Text k = new Text();

    @Override
    public void initialize(InputSplit split, TaskAttemptContext context) throws IOException, InterruptedException {

        this.split = (FileSplit) split;
        configuration = context.getConfiguration();
    }

    @Override
    public boolean nextKeyValue() throws IOException, InterruptedException {

        if (isProgress) {

            // 1 定义缓存区
            byte[] contents = new byte[(int) split.getLength()];

            FileSystem fs = null;
            FSDataInputStream fis = null;

            try {
                // 2 获取文件系统
                Path path = split.getPath();
                fs = path.getFileSystem(configuration);

                // 3 读取数据
                fis = fs.open(path);

                // 4 读取文件内容
                IOUtils.readFully(fis, contents, 0, contents.length);

                // 5 输出文件内容
                value.set(contents, 0, contents.length);

                // 6 获取文件路径及名称
                String name = split.getPath().toString();

                // 7 设置输出的key值
                k.set(name);

            } catch (Exception e) {

            } finally {
                IOUtils.closeStream(fis);
            }

            isProgress = false;

            return true;
        }

        return false;
    }

    @Override
    public Text getCurrentKey() throws IOException, InterruptedException {
        return k;
    }

    @Override
    public BytesWritable getCurrentValue() throws IOException, InterruptedException {
        return value;
    }

    @Override
    public float getProgress() throws IOException, InterruptedException {
        return 0;
    }

    @Override
    public void close() throws IOException {
    }
}

/**
 * <b>合并小文件 Reducer<br>
 * </b>
 * Text, BytesWritable, Text, BytesWritable
 * 输入Key类型，输入Value类型，输出Key类型，输出Value类型
 */
class CombineFileReducer extends Reducer<Text, BytesWritable, Text, BytesWritable> {

    @Override
    protected void reduce(Text key, Iterable<BytesWritable> values, Context context) throws IOException, InterruptedException {
        context.write(key, values.iterator().next());
    }
}

在这里插入图片描述

nickdlk
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【大数据实验五】 MapReduce初级编程实践
m0_51011320的博客
05-31 2758
大数据实验五 MapReduce初级编程实践 1实验目的 1.通过实验掌握基本的MapReduce编程方法； 2.掌握用MapReduce解决一些常见的数据处理问题，包括数据去重、数据排序和数据挖掘等。 2实验平台 已经配置完成的Hadoop伪分布式环境。 （1）操作系统：Linux（Ubuntu18.04） （2）Hadoop版本：3.1.3 3实验内容和要求 1.编程实现文件合并和去重操作
MapReduce初级编程实践
wr456wr的博客
06-03 3194
实验内容 使用Java编程一个WordCount程序，并将该程序打包成Jar包在虚拟机内执行 编程实现文件合并和去重操作 编程实现对输入文件的排序 对给定的表格进行信息挖掘 参考资料
大数据实验5实验报告：MapReduce 初级编程实践
06-20
林子雨大数据原理与技术第三版实验5实验报告 大数据技术与原理实验报告 MapReduce 初级编程实践 姓名: 实验环境：  操作系统：Linux（建议Ubuntu16.04）；  Hadoop版本：3.2.2； 实验内容与完成情况： （一）编程实现文件合并和去重操作 对于两个输入文件，即文件 A 和文件 B，请编写 MapReduce 程序，对两个文件进行合并， 并剔除其中重复的内容，得到一个新的输出文件 C。下面是输入文件和输出文件的一个样例 供参考。 输入文件 A 的样例如下：
MapReduce编程初级实践
Why_w的博客
04-28 3434
MapReduce编程初级实践MapReduce编程初级实践1.编程实现文件合并和去重操作2. 编写程序实现对输入文件的排序功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 MapReduce编程初级实践 1.通过实验掌握基本的Ma
MapReduce基础编程项目实践
weixin_66158110的博客
06-11 590
在accounts.txt文件中存储如下，第一列为金额大小，第二列表示收入、支出（0表示收入，1表示支出），第三列表示金额出入的月份。我们要通过MapReduce计算每个月过去后的结余，并根据月份大小进行分区，1-3月为1分区，4-6月为2分区，7-9月为3分区，10-12月为4分区。江科大大数据实践项目
MapReduce初级例程
08-24
一些MapReduce的入门程序 来自《hadoop权威指南》《hadoop in action》
实验3MapReduce编程初级实践
10-27
MapReduce编程初级实践 MapReduce是一种编程模型，由Google提出，用于处理大量数据。它主要用于分布式计算，通过map和reduce两个阶段，对大规模数据进行处理和分析。 实验目的 通过这个实验，学生可以掌握基本的...
大数据实验四-MapReduce编程实践
04-03
### 大数据实验四-MapReduce编程实践 #### 一、实验内容与目的 ##### 实验内容概述 本次实验的主要内容是使用MapReduce框架来实现WordCount词频统计功能，即统计HDFS（Hadoop Distributed File System）系统中多个...
实验3-MapReduce编程初级实践.docx
最新发布
07-19
### MapReduce编程初级实践知识点详解 #### 一、实验目的 本实验旨在让学习者掌握基本的MapReduce编程技巧，并能够运用这些技能解决常见的数据处理问题。具体目标如下： 1. **掌握MapReduce编程基础**：理解...
Hadoop原理与技术MapReduce实验
05-24
（1）熟悉Hadoop开发包 （2）编写MepReduce程序 （3）调试和运行MepReduce程序 （4）完成上课老师演示的内容 二、实验环境 Windows 10 VMware Workstation Pro虚拟机 Hadoop环境 Jdk1.8 二、实验内容 1.单词计数实验...
实验5 MapReduce初级编程实践（1）——编程实现文件合并和去重操作
热门推荐
程序必须为人类阅读而编写，并且仅仅碰巧可以让机器执行
11-22 3万+
一、实验目的 通过实验掌握基本的MapReduce编程方法； 掌握用MapReduce解决一些常见的数据处理问题，包括数据去重、数据排序和数据挖掘等。 二、实验平台 操作系统：Linux（建议Ubuntu16.04或Ubuntu18.04） Hadoop版本：3.1.3 三、实验内容 编程实现文件合并和去重操作 对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。下面是输入文件和输出文件的一个样例供参考。 输入文件A的样
大数据技术基础实验报告-MapReduce编程.doc
08-21
大数据技术基础实验报告-MapReduce编程
hadoop mapreduce编程实战
09-12
此文档用于指导在hadoop完全分布式环境上做mapreduce开发，包括了11个mapreduce实例，讲解详细，适合初步接触mapreduce开发的同学，希望对大家有帮助
Mapreduce-实践
04-16
（实践一）数值概要中combiner的作用 在前述数值概要的运用中，加入不同的combiner，测试不同环境下系统的性能，并给出分析、说明。 检查在内存优化模式下系统性能的区别。 （实践二）计算器计数 模式描述、计数器结构及性能分析。 示例：计算每个州的用户数 （实践三）MapReduce 布隆过滤器 过滤器训练、过滤器应用、结果验证及分析 （实践四）MapReduce Top 10模式示例 在ctrip数据集上进行Top 10排序。 （实践五）去重的用户—针对ctrip数据集去重 对ctrip数据集中的product-id进行去重操作
实验5：MapReduce 初级编程实践
qq_36428822的博客
06-20 7767
由于CSDN上传md文件总是会使图片失效 完整的实验文档地址如下： https://download.csdn.net/download/qq_36428822/85709497实验内容与完成情况： （一）编程实现文件合并和去重操作 对于两个输入文件，即文件 A 和文件 B，请编写 MapReduce 程序，对两个文件进行合并， 并剔除其中重复的内容，得到一个新的输出文件 C。下面是输入文件和输出文件的一个样例 供参考。 输入文件 A 的样例如下： 20170101 x 20170102 y 2
大数据技术原理与应用实验4——MapReduce初级编程实践
m0_52435951的博客
05-30 8257
（1）通过实验掌握基本的MapReduce编程方法； （2）掌握用MapReduce解决一些常见的数据处理问题，包括数据去重、数据排序和数据挖掘等。
大数据技术原理及应用课实验5 :MapReduce初级编程实践
weixin_60530224的博客
01-20 4038
1. 通过实验掌握基本的MapReduce编程方法； 2. 掌握用MapReduce解决一些常见的数据处理问题，包括数据去重、数据排序和数据挖掘等。 二、实验平台 1. 操作系统：Linux（建议Ubuntu16.04或Ubuntu18.04） 2. Hadoop版本：3.1.3 三、实验步骤（每个步骤下均需有运行截图） （一）编程实现文件合并和去重操作 对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。下面是输入文件
Hadoop之MapReduce（实践篇）
penggougoude的博客
09-11 7328
1、MapReduce编程模型概述 MapReduce应用广泛的原因之一在于它的易用性。它提供了一个因高度抽象化而变得异常简单的编程模型。MapReduce是在总结大量应用的共同特点的基础上抽象出来的分布式计算框架，它适用的应用场景往往具有一个共同的特点：任务可被分解成相互独立的子问题。基于该特点，MapReduce编程模型给出了其分布式编程方法，共分5个步骤： 迭代（iteration）：...
MapReduce编程实践报告
Wxjla_n29的博客
05-11 899
在“Project name”后面输入工程名称“WordCount”，选中“Use default location”，让这个Java工程的所有文件都保存到“/home/hadoop/workspace/WordCount”目录下。然后，点击界面底部的“Next>”按钮，进入下一步的设置。在该界面中，只需要在“Name”后面输入新建的Java类文件的名称，这里采用名称“WordCount”，其他都可以采用默认设置，然后，点击界面右下角“Finish”按钮，出现如下图所示界面。
Mapreduce初级编程实践
05-22
MapReduce是一种分布式计算模型，可以在大规模数据集上并行处理数据。在编程实践方面，MapReduce的编程模型需要将数据处理任务分解为两个...可以通过练习一些实际的MapReduce编程案例来深入理解和掌握MapReduce编程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

nickdlk

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值