大数据-MapReduce应用二

最新推荐文章于 2023-11-27 12:41:47 发布
最新推荐文章于 2023-11-27 12:41:47 发布
阅读量386 收藏
点赞数
分类专栏： 大数据 文章标签： 重写InputFormat类 重写OutputFormat类 MapReduce的应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JavaDestiny/article/details/88832040
版权

案例一

student A 06140412 05 08 102 110 106
student B 06140407 02 06 60 98 80
student C 06140404 10 07 98 31 63
student D 06140403 07 10 105 109 107
student E 06140406 03 03 57 87 92
student F 06140408 10 06 102 102 50

案例二

student G 06140402 03 07 54 61 64
student H 06140401 05 03 83 76 111
student I 06140409 05 10 70 56 91
student J 06140411 07 09 22 119 112
student K 06140410 02 01 45 65 80
student L 06140405 03 02 79 20 26

需求：将多个文件合并为SequenceFile（存储多个小文件）

存储方式：文件路径+文件内容

FileInput类

package com.FileInputFormat.util;

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.JobContext;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;

import java.io.IOException;
/*
 * @author Administrator
 * @version
 * @task 将多个文件合并为SequenceFile（存储多个小文件）  存储方式：文件路径+文件内容
 */
public class FileInput extends FileInputFormat<NullWritable, BytesWritable> {
    @Override
    public RecordReader<NullWritable, BytesWritable> createRecordReader(InputSplit inputSplit, TaskAttemptContext taskAttemptContext) throws IOException, InterruptedException {
        RecordReader<NullWritable, BytesWritable> fileRecordReader = new FileRecordReader();
        return fileRecordReader;
    }

    @Override
    protected boolean isSplitable(JobContext context, Path filename) {
        //不切原来的文件
        return false;
    }
}

FileRecordReader类

package com.FileInputFormat.util;

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.NullWritable;
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;
/*
 * @author Administrator
 * @version
 * @task 将多个文件合并为SequenceFile（存储多个小文件）  存储方式：文件路径+文件内容
 */
public class FileRecordReader extends RecordReader<NullWritable, BytesWritable> {
    private FileSplit fileSplit = null;
    private Configuration conf = null;
    private boolean flag = false;
    private FSDataInputStream fsDataInputStream = null;
    private FileSystem fileSystem = null;
    private BytesWritable value = new BytesWritable();
    @Override
    public void initialize(InputSplit inputSplit, TaskAttemptContext taskAttemptContext) throws IOException, InterruptedException {
        //初始化文件切片
        fileSplit = (FileSplit) inputSplit;
        //初始化配置
        conf = taskAttemptContext.getConfiguration();
    }

    @Override
    public boolean nextKeyValue() {
        if (!flag){
            //根据切片的长度创建缓冲区
            byte[] buf = new byte[(int) fileSplit.getLength()];
            //获取路径
            Path path = fileSplit.getPath();
            try {
                //根据路径获取文件系统
                fileSystem = path.getFileSystem(conf);
                //获取输入流
                fsDataInputStream = fileSystem.open(path);
                //数据拷贝
                IOUtils.readFully(fsDataInputStream,buf,0,buf.length);
                //拷贝缓冲到最终的输出
                value.set(buf,0,buf.length);
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                //关闭流
                IOUtils.closeStream(fsDataInputStream);
                IOUtils.closeStream(fileSystem);
            }
            flag = true;
            return true;
        }
        return false;
    }

    @Override
    public NullWritable getCurrentKey() throws IOException, InterruptedException {
        return null;
    }

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

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

    @Override
    public void close() throws IOException {

    }
}

FileInputMapper类

package com.FileInputFormat.util;

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;

import java.io.IOException;
/*
 * @author Administrator
 * @version
 * @task 将多个文件合并为SequenceFile（存储多个小文件）  存储方式：文件路径+文件内容
 */
public class FileInputMapper extends Mapper<NullWritable, BytesWritable, Text,BytesWritable> {
    private FileSplit fileSplit = null;
    private Path path = null;
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        //获取切片信息
        fileSplit = (FileSplit)context.getInputSplit();
        //获取路径
        path = fileSplit.getPath();
    }

    @Override
    protected void map(NullWritable key, BytesWritable value, Context context) throws IOException, InterruptedException {
        //输出到Reducer端
        context.write(new Text(path.toString()),value);
    }
}

FileInpueReducer类

package com.FileInputFormat.util;

import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;
/*
 * @author Administrator
 * @version
 * @task 将多个文件合并为SequenceFile（存储多个小文件）  存储方式：文件路径+文件内容
 */
public class FileInpueReducer extends Reducer<Text, BytesWritable,Text, BytesWritable> {
    @Override
    protected void reduce(Text key, Iterable<BytesWritable> values, Context context) throws IOException, InterruptedException {
        for (BytesWritable bytes: values){
            context.write(key,bytes);
        }
    }
}

FileInputDriver类

package com.FileInputFormat.util;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.SequenceFileOutputFormat;

import java.io.IOException;
/*
 * @author Administrator
 * @version
 * @task 将多个文件合并为SequenceFile（存储多个小文件）  存储方式：文件路径+文件内容
 */
public class FileInputDriver {
    public static void main(String[] args) {
        //实例化Configuration
        Configuration conf = new Configuration();
        try {
            //创建任务
            Job job = Job.getInstance(conf);
            //指定jar包的位置
            job.setJarByClass(FileInputDriver.class);
            //关联Mapper类
            job.setMapperClass(FileInputMapper.class);
            //关联Reducer类
            job.setReducerClass(FileInpueReducer.class);
            //设置Mapper输出的数据类型
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(BytesWritable.class);
            //设置Reducer输出的数据类型
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(BytesWritable.class);
            //设置自定义读取的方式
            job.setInputFormatClass(FileInput.class);
            job.setOutputFormatClass(SequenceFileOutputFormat.class);
            //设置输入路径
            FileInputFormat.setInputPaths(job,new Path(args[0]));
            //设置输出路径
            FileOutputFormat.setOutputPath(job,new Path(args[1]));
            //提交任务
            boolean b = job.waitForCompletion(true);
            System.exit(b?0:1);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

案例

student A 06140412 05 08 102 110 106
student B 06140407 02 06 60 98 80
student C 06140404 10 07 98 31 63
student D 06140403 07 10 105 109 107
student E 06140406 03 03 57 87 92
student F 06140408 10 06 102 102 50
student G 06140402 03 07 54 61 64
student H 06140401 05 03 83 76 111
student I 06140409 05 10 70 56 91
student J 06140411 07 09 22 119 112
student K 06140410 02 01 45 65 80
student L 06140405 03 02 79 20 26

需求：过滤数据，把5号考场的学生放到一个文件中，并计算每个学生的总成绩

FileOutput类

package com.FileOutputFormat.util;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;
/*
 * @author Administrator
 * @version
 * @task 过滤数据，把5号考场的学生放到一个文件中，并计算每个学生的总成绩
 */
public class FileOutput extends FileOutputFormat<StudentGrade, NullWritable> {

    @Override
    public RecordWriter<StudentGrade, NullWritable> getRecordWriter(TaskAttemptContext taskAttemptContext) throws IOException, InterruptedException {
        RecordWriter<StudentGrade, NullWritable> fileRecordWriter = new FileRecordWriter();
        return fileRecordWriter;
    }
}

FileRecordWriter类

package com.FileOutputFormat.util;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;

import java.io.IOException;
/*
 * @author Administrator
 * @version
 * @task 过滤数据，把5号考场的学生放到一个文件中，并计算每个学生的总成绩
 */
public class FileRecordWriter extends RecordWriter<StudentGrade, NullWritable> {
    private FSDataOutputStream fsDataOutputStream;
    public FileRecordWriter() {
        //实例化Configuration
        Configuration conf = new Configuration();
        try {
            //获取文件系统
            FileSystem fileSystem = FileSystem.get(conf);
            //获取输出流
            fsDataOutputStream = fileSystem.create(new Path("F:\\IdeaProjects\\out6\\out.log"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void write(StudentGrade studentGrade, NullWritable nullWritable) throws IOException, InterruptedException {
        //转换成String类型
        String str = studentGrade.toString();
        //分割数据
        String[] field = str.split("\t");
        //如果5号考场的学生，则输出
        if ("5".equals(field[2])) {
            fsDataOutputStream.write(str.getBytes());
            fsDataOutputStream.write("\n".getBytes());
        }
    }

    @Override
    public void close(TaskAttemptContext taskAttemptContext) throws IOException, InterruptedException {
        //关闭流
        if (fsDataOutputStream != null){
            fsDataOutputStream.close();
        }
    }
}

StudentGrade类

package com.FileOutputFormat.util;

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
/*
 * @author Administrator
 * @version
 * @task 过滤数据，把5号考场的学生放到一个文件中，并计算每个学生的总成绩
 */
public class StudentGrade implements WritableComparable<StudentGrade> {
    //学生姓名
    private String name;
    //学号
    private String id;
    //考场号
    private int roomID;
    //语文成绩
    private int chinese;
    //数学成绩
    private int math;
    //英语成绩
    private int english;
    //总成绩
    private int sum;

    //无参构造方法
    public StudentGrade(){}
    //有参构造方法
    public StudentGrade(String name, String id, int roomID, int chinese, int math, int english){
        this.name = name;
        this.id = id;
        this.roomID = roomID;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
        this.sum = chinese + math + english;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public int getRoomID() {
        return roomID;
    }

    public void setRoomID(int roomID) {
        this.roomID = roomID;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }

    public int getSum() {
        return sum;
    }

    public void setSum(int sum) {
        this.sum = sum;
    }

    @Override
    public int compareTo(StudentGrade object) {
        return Integer.parseInt(this.id) > Integer.parseInt(object.id)? 1:-1;
    }

    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeUTF(name);
        dataOutput.writeUTF(id);
        dataOutput.writeInt(roomID);
        dataOutput.writeInt(chinese);
        dataOutput.writeInt(math);
        dataOutput.writeInt(english);
        dataOutput.writeInt(sum);
    }

    @Override
    public void readFields(DataInput dataInput) throws IOException {
        name = dataInput.readUTF();
        id = dataInput.readUTF();
        roomID = dataInput.readInt();
        chinese = dataInput.readInt();
        math = dataInput.readInt();
        english = dataInput.readInt();
        sum = dataInput.readInt();
    }

    @Override
    public String toString() {
        return name + "\t" + id + "\t" + roomID + "\t" + chinese + "\t" + math + "\t" + english + "\t" + sum;
    }
}

FileOutputMapper类

package com.FileOutputFormat.util;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;
/*
 * @author Administrator
 * @version
 * @task 过滤数据，把5号考场的学生放到一个文件中，并计算每个学生的总成绩
 */
public class FileOutputMapper extends Mapper<LongWritable, Text,StudentGrade, NullWritable> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //获取行数据
        String line = value.toString();
        //分割数据
        String[] field = line.split("\t");
        //学生姓名
        String name = field[0];
        //学号
        String id = field[1];
        //考场号
        int roomID = Integer.valueOf(field[2]);
        //语文成绩
        int chinese = Integer.valueOf(field[4]);
        //数学成绩
        int math = Integer.valueOf(field[5]);
        //英语成绩
        int english = Integer.valueOf(field[6]);
        //写到Reducer端
        context.write(new StudentGrade(name,id,roomID,chinese,math,english),NullWritable.get());
    }
}

FileOutputReducer类

package com.FileOutputFormat.util;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;
/*
 * @author Administrator
 * @version
 * @task 过滤数据，把5号考场的学生放到一个文件中，并计算每个学生的总成绩
 */
public class FileOutputReducer extends Reducer<StudentGrade, NullWritable,StudentGrade,NullWritable> {
    @Override
    protected void reduce(StudentGrade key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        //写到Driver端
        context.write(key,values.iterator().next());
    }
}

FileOutputDriver类

package com.FileOutputFormat.util;


import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;
/*
 * @author Administrator
 * @version
 * @task 过滤数据，把5号考场的学生放到一个文件中，并计算每个学生的总成绩
 */
public class FileOutputDriver {
    public static void main(String[] args) {
        try {
            //实力化Configuration对象
            Configuration conf = new Configuration();
            Job job = Job.getInstance(conf);
            //指定jar包的位置
            job.setJarByClass(FileOutputDriver.class);
            //关联Mapper类
            job.setMapperClass(FileOutputMapper.class);
            //关联Reducer类
            job.setReducerClass(FileOutputReducer.class);
            //设置Mapper输出的数据类型
            job.setMapOutputKeyClass(StudentGrade.class);
            job.setMapOutputValueClass(NullWritable.class);
            //设置Reducer输出的数据类型
            job.setOutputKeyClass(StudentGrade.class);
            job.setOutputValueClass(NullWritable.class);
            //设置自定义输出的类型
            job.setOutputFormatClass(FileOutput.class);
            //设置输入的路径
            FileInputFormat.setInputPaths(job,new Path(args[0]));
            //设置输出的路径
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            //执行任务
            boolean b = job.waitForCompletion(true);
            System.exit(b?0:1);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
JP-Destiny
关注
专栏目录
实验二 MapReduce编程入门及实战
葫芦娃的博客
11-14 1438
实验二 MapReduce编程入门及实战前言第1节 项目概述1.1 项目介绍第2节 项目任务2.1 MapReduce开发环境搭建2.1.1实验准备2.1.2实验步骤2.2 MapReduce原理2.2.1实验准备2.2.2实验步骤2.3 校园社区网站访问次数统计《1》准备样例数据：《2》代码：《3》输出结果：2.4 校园社区网站访问次数排序《1》准备样例数据：《2》代码：《3》输出结果:第3节 拓展任务3.1 获取成绩表的最高分记录《1》准备样例数据：《2》代码：《3》输出结果：3.2 对两个文件中的数.
大数据课程——MapReduce编程综合应用（2）
weixin_43334251的博客
06-28 1560
大数据课程——MapReduce编程综合应用（2） 实验内容以及要求 现有一份汽车销售记录，销售记录包括时间、地点、邮政编码、车辆类型等信息，每条记录信息包含39项数据项。请利用MapReduce框架，编写程序实现如下功能： （1）统计不同车型销售的年龄段分布情况，并分别按照车型和年龄段进行汇总（不考虑排序）。 注意：年龄段每10岁为1个年龄段（010、1120、21~30…） 输出格式参考如下： 车型1,年龄段1,300 车型1,年龄段1,300 … 车型1,年龄段2,300 … 车型2,年龄段1,30
开发MapReduce程序 实验2
magina507的博客
05-30 2112
一、实验题目 开发MapReduce程序 二、实验要求 WeatherData应用程序是为分析文本文件、获得明确结果而编写的计算程序。 在文本分析过程中，程序分别对（数）值和温度做了分类和比较。 本次实验练习，我们将编写MapReduce程序，目的是找出weather.txt文本文件中保存的最高温度的记录。 三、操作步骤 1.打开Eclipse，创建一个Java Project，
Hadoop之MapReduce应用实例2（分组排序，二次排序）
weixin_43800761的博客
06-26 723
一、数据集及程序要求   数据集ramen-ratings.txt，包含全世界2580种方便面的品牌、国家/地区、包装类型、评分等内容，使用MapReduce计数并求平均值，输出：每个国家/地区最受欢迎的三大方便面品牌，按评分，去掉重复。 所有国家方便面的平均分（即哪国的方便面最好吃） 数据获取地址：https://github.com/ordinaryload/Hadoop-tools 二、源代码编写 2.1 打开IntelliJ IDEA创建Maven项目 2.2 pom.xml 文件如下： &lt
大数据-MapReduce应用三
Destiny的博客
03-27 165
案例一 student A 06140411 5 8 102 110 106 student B 06140407 2 6 60 98 80 student C 06140404 10 7 98 31 63 student D 06140403 7 10 105 109 107 student E 06140406 3 3 57 87 92 student F 06140408 10 6 102...
大数据-hadoop-mapreduce代码
11-28
总的来说，这个“大数据-hadoop-mapreduce代码”资源对于想要深入理解Hadoop MapReduce机制，或者需要开发和优化MapReduce应用程序的人来说，是一个宝贵的参考资料。通过研究这些代码，你可以学习到如何处理Hadoop...
3 大数据基础 - MapReduce
12-20
大数据基础 - MapReduce MapReduce 是大数据处理中的一种编程模型，由 Google 开发，后被 Apache 组织收录，成为 Hadoop 的一部分。MapReduce 的主要思想是将复杂的计算任务拆分成两个阶段：Map 阶段和 Reduce 阶段...
大数据实验四-MapReduce编程实践
最新发布
04-03
### 大数据实验四-MapReduce编程实践 #### 一、实验内容与目的 ##### 实验内容概述 本次实验的主要内容是使用MapReduce框架来实现WordCount词频统计功能，即统计HDFS（Hadoop Distributed File System）系统中多个...
大数据平台-MapReduce介绍.pdf
03-03
"大数据平台-MapReduce介绍.pdf" 大数据平台中的MapReduce是由Google公司的Jeffrey Dean和Sanjay Ghemawat开发的一个针对大规模群组中的海量数据处理的分布式编程模型。MapReduce实现了两个功能：Map函数应用于集合...
大数据--Hadoop MapReduce
08-09
#### 二、MapReduce的应用实例 通过具体实例来更好地理解MapReduce的工作原理： 1. **基因序列处理**： - 输入：大量的基因序列数据，每个序列长度约为35-75个字符。 - 分布式处理：将这些序列分配到多台计算机...
Hadoop原理与技术MapReduce实验
05-24
一、实验目的 （1）熟悉Hadoop开发包 （2）编写MepReduce程序 （3）调试和运行MepReduce程序 （4）完成上课老师演示的内容 二、实验环境 Windows 10 VMware Workstation Pro虚拟机 Hadoop环境 Jdk1.8 二、实验内容 1.单词计数实验(wordcount) （1）输入start-all.sh启动hadoop相应进程和相关的端口号 （2）打开网站localhost:8088和localhost:50070，查看MapReduce任务启动情况 （3）写wordcount代码并把代码生成jar包 （4）运行命令 （1）：把linus下的文件放到hdfs上 （2）：运行MapReduce （5）：查看运行结果 （6）网页上查看MapReduce任务 2.矩阵相乘实验(matrix) （1）写matrix代码并把代码生成jar包 （2）运行命令 （1）：把linus下的文件放到hdfs上 （2）：运行MapReduce （3）：查看运行结果 3.网页排名实验(pagerank) （1）：写pagerank代码并把代码生成jar包
初识MapReduce的应用场景（附JAVA和Python代码）
weixin_33860737的博客
02-27 389
从这篇文章开始，我会开始系统性地输出在大数据踩坑过程中的积累，后面会涉及到实战项目的具体操作，目前的规划是按照系列来更新，力争做到一个系列在5篇文章之内总结出最核心的干货，如果是涉及到理论方面的文章，会以画图的方式来讲解，如果是涉及到操作方面，会以实际的代码来演示。 这篇是MapReduce系列的第一篇，初识MapReduce的应用场景，在文章后面会有关于代码的演示。 前言 Hadoop作为Apa...
基于hadoop与MapReduce的分布式编程
weixin_45795947的博客
04-19 3737
基于hadoop与MapReduce的分布式编程 一、部署hadoop集群 在上一章中，我们使用docker构建了Hadoop的分布式环境镜像，并使用docker run命令从该镜像中部署了一主两从的三个分布式节点：master、worker01、worker02。 这里再次根据之前配置好的镜像部署三台新的容器，命令如下： /* 格式： sudo docker run -p <本机端口>:<容器要映射的端口> -v <本机目录路径>:<容器目录路径> -it
大数据平台/大数据技术与原理-实验报告--MapReduce编程
CSH__的博客
11-27 2794
MapReduce编程
MapReduce应用实例
wtq1993的博客
05-17 5914
1.各个部门的总工资如何进行问题分析的? 2.各个部门的总工资处理流程是怎样的？ 3.个部门的人数和平均工资又是如何得到的？ 4.个部门的人数和平均工资代码如何实现？ 案例所用包全部下载：链接: http://pan.baidu.com/s/1sjNyDIX 密码: 游客，如果您要查看本帖隐藏内容请回复 1、环境说明 部署节点操作系统为CentOS，防
大数据实训02--MapReduce原理与开发
weixin_41499217的博客
06-19 735
思考小问题 统计一个100G大小的文件进行词频的解决方法 方法一：如果小文件可以编写一个小程序 方法二： 方法三： 方法四： MapReduce 特点：易于编程（有两个接口ma--大任务分成小任务，任务分解，reduce---任务汇总），良好的扩展，高容错性，适合离线处理 是一个编程框架：只需要程序员去设计map，reduce函数 MapReduce原语：输入、输出 map处理生成key（中间结果） 先map处理结果作为reduce的输入（线性关系），map的输入的是大数据集的分片sp
MapReduce运用-案例讲解
CDHong.it的技术分享博客
10-29 3428
MapReduce 是 Google 公司开源的一项重要技术，它是一个编程模型，用以进行大数据量的计算。MapReduce 是一种简化的并行计算编程模型，它使那些没有多少并行计算经验的开发人员也可以开发并行应用程序。 模型非常方便使用，即使是对于完全没有分布式程序的程序员也是如此。它隐藏了并行计算的细节。MapReduce运行开发人员使用自己熟悉的语言进行开发。 通过MapReduce，应用程序可以在超过1000个节点的大型集群上运行，并且提供经过优化的错误容灾。
Mapreduce-实验、实践
weixin_43846708的博客
04-16 2480
Mapreduce-实验、实践实验实验（一）数值概要—中位数与标准差实验（二）：MapReduce计数器实验实验（三）：MapReduce布隆过滤器的舆情过滤实验（四）StackOverflow数据集的分层操作实验（五）： Reduce端连接实践（实践一）数值概要中combiner的作用（实践二）计算器计数（实践三）MapReduce 布隆过滤器（实践四）MapReduce Top 10模式示例（实践五）去重的用户—针对ctrip数据集去重 实验 实验（一）数值概要—中位数与标准差 检查实验环境、运行示例程
【大数据技术】实验2：熟悉常用的HDFS操作和基于MapReduce的词频统计
qq_45614178的博客
07-27 2849
【大数据技术】实验2：熟悉常用的HDFS操作和基于MapReduce的词频统计
"深入理解大数据技术-MapReduce框架与应用
第四章《大数据技术教程-MapReduce.pdf》详细介绍了分布式计算框架MapReduce的基本概念和应用。在Hadoop流行之前，分布式框架虽然存在，但实现较为复杂，大公司专利化，小公司无法承担开发分布式系统的成本和人力。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值