MapReduce解决乘用车辆和商用车辆的销售数据分析

最新推荐文章于 2022-12-25 22:56:43 发布
原创 最新推荐文章于 2022-12-25 22:56:43 发布 · 4.8k 阅读 · 91 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了使用Hadoop MapReduce进行数据清洗和汽车销售数据分析的多个实例，包括车辆用途分布、山西省2013年汽车销售比例、各市、区县销售数量、男女购车比例、所有权、车辆类型和品牌分布、品牌每月销售量以及发动机型号和燃油种类统计。通过这些实例展示了MapReduce在大数据处理中的应用。

首先还是看下我们的需求 在这里插入图片描述 然后拿到我们的数据 在这里插入图片描述 可以看到我们的数据里面还有很多空值,是还没清洗的脏数据,一会我们处理的时候需要将其处理掉.

一.统计车辆不同用途的数量分布

    package hadoop.MapReduce.car.Use;
    
    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.output.FileOutputFormat;
    
    import java.io.IOException;
    
    public class usecount {
    
    public static class UseMapper extends Mapper<LongWritable, Text,Text, IntWritable> {
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] lines = value.toString().split("\t");
            if (null != lines && lines.length > 10 && !lines[10].isEmpty()) {
                    context.write(new Text(lines[10]), new IntWritable(1));
                }
            }
        }
    
    
    public static class UseReduce extends Reducer<Text,IntWritable,Text,IntWritable>{
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws
                IOException, InterruptedException {
            int count = 0;
            for (IntWritable value:values){
                count += value.get();
            }
            context.write(key,new IntWritable(count));
        }
    }
    
    public static class UseDriver{
        public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
            Configuration conf = new Configuration();
            Job job = new Job(conf);
            job.setJarByClass(UseDriver.class);
    
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(IntWritable.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
    
            job.setMapperClass(UseMapper.class);
            job.setReducerClass(UseReduce.class);
    
            FileInputFormat.addInputPath(job,new Path("D:\\a\\cars.txt"));
            FileOutputFormat.setOutputPath(job,new Path("D:\\a\\a1\\1"));
    
            job.waitForCompletion(true);
        }
    }
    }

可以看到我们这边用lines[10].isEmpty()去清洗了空格,若不想用这种方法还可以用try/catch将其抛出异常, 一开始我们用的line[10] != null,后来发现不行,还是会将空格输出出来.

二.统计山西省2013年每个月的汽车销售数量的比例

    package hadoop.MapReduce.car.BiLi;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.DoubleWritable;
    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.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class bilicount {
    //    static int all = 0;
    public static class BiliMapper extends Mapper<LongWritable, Text,Text,LongWritable>{
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] lines = value.toString().split("\t");
                if (null != lines && lines.length > 1&& !lines[0].isEmpty()) {
                    if (lines[0].equals("山西省") && lines[4].equals("2013")) {
                        context.write(new Text(lines[1]), new LongWritable(1));
    //                        all++;
                    }
                }
        }
    }
    
    public static class BiliReduce extends Reducer<Text,LongWritable,Text, DoubleWritable> {
        double all = 0;
        Map<String,Long> maps = new HashMap<String,Long>();
        @Override
        protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws
                IOException, InterruptedException {
            long count = (long)0;
            for (LongWritable value : values) {
                count += value.get();
            }
            all += count;
            maps.put(key.toString(),count);
    //            bili = count/all;
    //            context.write(key,new DoubleWritable(bili));
        }
    
        protected void cleanup(
                org.apache.hadoop.mapreduce.Reducer<Text,LongWritable,Text, DoubleWritable>.Context context
        ) throws IOException, InterruptedException {
            Set<String> keySet = maps.keySet();
            for (String str : keySet) {
                long value = maps.get(str);
                double bili = value/all;
                context.write(new Text(str),new DoubleWritable(bili));
            }
        }
    }
    
    
    
    public static class BiliDriver {
        public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
            Configuration conf = new Configuration();
            Job job = new Job(conf);
            job.setJarByClass(BiliDriver.class);
    
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(LongWritable.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(DoubleWritable.class);
    
            job.setMapperClass(BiliMapper.class);
            job.setReducerClass(BiliReduce.class);
    
            FileInputFormat.addInputPath(job,new Path("D:\\a\\cars.txt"));
            FileOutputFormat.setOutputPath(job,new Path("D:\\a\\a2\\1"));
    
            job.waitForCompletion(true);
        }
    }
    }

可以看到统计总数,我们这边用了cleanup来释放,其实在map端加入一个静态全局变量来计算也是一个好办法,比起这个更加简单.

三.统计山西省2013年各市、区县的汽车销售的数量分布

    package hadoop.MapReduce.car.FenBu;
    
    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.output.FileOutputFormat;
    
    import java.io.IOException;
    
    public class fenbu {
    public static class FenbuMapper extends Mapper<LongWritable, Text,Text,IntWritable> {
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] lines = value.toString().split("\t");
            if (null != lines && lines.length > 4 && lines[2] != null && lines[3] != null) {
                if (lines[0].equals("山西省") && lines[4].equals("2013")) {
                    context.write(new Text(lines[2]+"\t"+lines[3]),new IntWritable(1));
                }
            }
        }
    }
    
    public static class FenbuReduce extends Reducer<Text,IntWritable,Text,IntWritable> {
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
            int count = 0;
            for (IntWritable value:values){
                count += value.get();
            }
            context.write(key,new IntWritable(count));
        }
    }
    
    public static class FenbuDriver{
        public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
            Configuration conf = new Configuration();
            Job job = new Job(conf);
            job.setJarByClass(FenbuDriver.class);
    
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(IntWritable.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
    
            job.setMapperClass(FenbuMapper.class);
            job.setReducerClass(FenbuReduce.class);
    
            FileInputFormat.addInputPath(job,new Path("D:\\a\\cars.txt"));
            FileOutputFormat.setOutputPath(job,new Path("D:\\a\\a3"));
    
            job.waitForCompletion(true);
        }
    }
    }

可以看到这里用的lines[3] != null做得判断,这里还会输出空格,记得改为 !lines[3].isEmpty()

四.统计买车的男女比例

    package hadoop.MapReduce.car.ManAndWoman;
    
    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.output.FileOutputFormat;
    
    import java.io.IOException;
    
    public class manwoman {
    //    static double people = 0;
    public static class MWMapper extends Mapper<LongWritable, Text,Text, IntWritable> {
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] lines = value.toString().split("\t");
            if (null != lines && lines.length > 38 && !lines[38].isEmpty()) {
                context.write(new Text(lines[38]),new IntWritable(1));
    //                people++;
            }
        }
    }
    
    public static class MWReduce extends Reducer<Text,IntWritable,Text, IntWritable> {
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
    //            double bili;
            int count = 0;
            for (IntWritable value:values){
                count += value.get();
            }
    //            bili = count/people;
            context.write(key,new IntWritable(count));
        }
    }
    
    public static class MWDriver{
        public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
            Configuration conf = new Configuration();
            Job job = new Job(conf);
            job.setJarByClass(MWDriver.class);
    
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(IntWritable.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
    
            job.setMapperClass(MWMapper.class);
            job.setReducerClass(MWReduce.class);
    
            FileInputFormat.addInputPath(job,new Path("D:\\a\\cars.txt"));
            FileOutputFormat.setOutputPath(job,new Path("D:\\a\\a4\\3"));
    
            job.waitForCompletion(true);
        }
    }
    }

这边我是求的人数,题目求的比例,只要把注释的解开就行

五.统计车的所有权、车辆类型和品牌的数量分布

    package hadoop.MapReduce.car.SuoYou;
    
    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.output.FileOutputFormat;
    
    import java.io.IOException;
    
    public class All {
    public static class AMapper extends Mapper<LongWritable, Text,Text, IntWritable> {
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] lines = value.toString().split("\t");
            if (null != lines && lines.length > 9 && lines[9] != null) {
                context.write(new Text(lines[9]),new IntWritable(1));
            }
        }
    }
    
    public static class AReduce extends Reducer<Text,IntWritable,Text,IntWritable> {
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
            int count = 0;
            for (IntWritable value:values){
                count += value.get();
            }
            context.write(key,new IntWritable(count));
        }
    }
    
    public static class ADriver{
        public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
            Configuration conf = new Configuration();
            Job job = new Job(conf);
            job.setJarByClass(ADriver.class);
    
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(IntWritable.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
    
            job.setMapperClass(AMapper.class);
            job.setReducerClass(AReduce.class);
    
            FileInputFormat.addInputPath(job,new Path("D:\\a\\cars.txt"));
            FileOutputFormat.setOutputPath(job,new Path("D:\\a\\a5\\4"));
    
            job.waitForCompletion(true);
        }
    }
    }

六.统计不同品牌的车在每个月的销售量分布

    package hadoop.MapReduce.car.PinPai;
    
    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.output.FileOutputFormat;
    
    import java.io.IOException;
    
    public class PP {
    public static class PPMapper extends Mapper<LongWritable, Text,Text, IntWritable> {
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] lines = value.toString().split("\t");
            if (null != lines && lines.length > 7 && lines[1] != null && lines[7] != null) {
                context.write(new Text(lines[1]+"\t"+lines[7]),new IntWritable(1));
            }
        }
    }
    
    public static class PPReduce extends Reducer<Text,IntWritable,Text,IntWritable> {
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
            int count = 0;
            for (IntWritable value:values){
                count += value.get();
            }
            context.write(key,new IntWritable(count));
        }
    }
    
    public static class PPDriver{
        public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
            Configuration conf = new Configuration();
            Job job = new Job(conf);
            job.setJarByClass(PPDriver.class);
    
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(IntWritable.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
    
            job.setMapperClass(PPMapper.class);
            job.setReducerClass(PPReduce.class);
    
            FileInputFormat.addInputPath(job,new Path("D:\\a\\cars.txt"));
            FileOutputFormat.setOutputPath(job,new Path("D:\\a\\a6"));
    
            job.waitForCompletion(true);
        }
    }
    }

七.通过不同种类（品牌）车辆销售情况，来统计发动机 型号和燃油种类

    package hadoop.MapReduce.car.FaDong;
    
    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.output.FileOutputFormat;
    
    import java.io.IOException;
    
    public class FA {
    public static class FAMapper extends Mapper<LongWritable, Text,Text, IntWritable> {
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] lines = value.toString().split("\t");
                if (null != lines && lines.length > 15 && !lines[8].isEmpty() && !lines[12].isEmpty() && !lines[15].isEmpty()) {
                    context.write(new Text(lines[8] + "\t" + lines[12] + "\t" + lines[15]), new IntWritable(1));
                }
            }
    }
    
    public static class FAReduce extends Reducer<Text,IntWritable,Text,IntWritable> {
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
            int count = 0;
            for (IntWritable value:values){
                count += value.get();
            }
            context.write(key,new IntWritable(count));
        }
    }
    
    public static class FADriver{
        public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
            Configuration conf = new Configuration();
            Job job = new Job(conf);
            job.setJarByClass(FADriver.class);
    
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(IntWritable.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
    
            job.setMapperClass(FAMapper.class);
            job.setReducerClass(FAReduce.class);
    
            FileInputFormat.addInputPath(job,new Path("D:\\a\\cars.txt"));
            FileOutputFormat.setOutputPath(job,new Path("D:\\a\\a8"));
    
            job.waitForCompletion(true);
        }
    }
    }

MapReduce项目案例4——乘用车辆和商用车辆销售数据分析
weixin_51699336的博客
06-27 6471
需求分析👇👇
Hadoop MapReduce 统计汽车销售信息
wux_labs的博客
12-25 3641
本文将讨论如何使用Hadoop MapReduce来统计汽车销售信息。
mapreduce和hive 对山西省汽车销售数据分析
weixin_45067832的博客
10-26 6861
数据样本，只截取了部分，有需要可私信谢谢： 该篇内容只完成了以下两个要求： 1.统计山西省2013年每个月的汽车销售数量的比例，结果例如： 2.统计不同品牌的车在每个月的销售量分布，结果例如： 具体实现方法，使用mapreduce实现，或使用HiveQL实现 一：mapreduce实现： 1.统计山西省2013年每个月的汽车销售数量的比例 package com.cxy.car; import org.apache.hadoop.conf.Configuration; import org.apac
统计乘用车辆，商用车辆的数量销售和销售额分布
big_data_study的博客
08-16 2150
统计乘用车辆，商用车辆的数量销售和销售额分布 /** * 根据汽车所属（个人，商用）来进行划分 * 计算乘用车辆，商用车辆各自的数量，以及各自所占的比重 */ public static class CountMap extends Mapper<LongWritable, Text, Text, LongWritable>{ @Override public void map(L...
Hadoop(4-1)-MapReduce程序案例-统计销售商品数量
知行合一，止于至善
08-09 8911
1.问题陈述： 找出销往各个国家商品数量。 输入: 我们的畋输入数据集合是一个 CSV 文件, Sales2014.csv 输出：国家名 销往次国家的商品数量 商品信息如图所示 2.前提条件： • 本教程是在Linux上开发 • 已经安装了Hadoop(本教程使用版本2.6.5) • 系统上已安装了Java(本教程使用 JDK1.8.0)。 3.步骤
Hadoop数据分析_大数据_hadoop_数据分析_
10-01
Hadoop和其生态系统为大数据分析提供了强大的基础架构，使得企业能够处理前所未有的数据量，发现潜在的业务洞察，并优化运营策略。随着技术的不断发展，Hadoop将继续在大数据领域扮演着至关重要的角色。
精选资源
大数据综合实验二 汽车销售数据统计分析项目.pdf
10-29
大数据综合实验二汽车销售...通过三个实验任务，分别统计乘用车输和商用车辆的数量和销售额分布、统计某年每个月的汽车销售数量的比例、统计某个月份各市区县的汽车销售的数量，达到对汽车销售数据的深入分析和理解。
java 计算输入数据的商_Hadoop(4-1)-MapReduce程序案例-统计销售商品数量
weixin_36035585的博客
02-25 1016
1.问题陈述：找出销往各个国家商品数量。输入: 我们的畋输入数据集合是一个 CSV 文件, Sales2014.csv输出：国家名 销往次国家的商品数量商品信息如图所示 2.前提条件：• 本教程是在Linux上开发• 已经安装了Hadoop(本教程使用版本2.6.5)• 系统上已安装了Java(本教程使用 JDK1.8.0)。3.步骤:(先运行成功再看4的解释)3.1.创建一个新的目录名称是：M...
MapReduce求各年销售笔数、销售总额实验（流程+代码）
浩然然然的博客
06-25 3365
Map阶段： 读取数据，k1 为偏移量、v1 为一行数据，将销售笔数和销售额封装为java bean对象，作为 v2，k2为年份（有1998, 1999, 2000, 2001）；Shuffle阶段： 有 4个年份，因此设置 4个分区，排序、规约、分组采取系统默认；Reduce阶段： 对 shuffle 过来的新的 v2，即每个集合的 bean 对象中的销售笔数和销售额分别进行相加，得到 v3，即每个年份的销售笔数和销售总额，k3是 k2，保持不变。
汽车销量分析系统.zip
04-26
记一次基于python和Hadoop集群的项目实战报告，压缩包包括实验报告书和txt源数据
乘用车辆和商用车辆销售数据分析
weixin_43020359的博客
11-23 2588
数据样本 1 临汾市 尧都区 SY6370C1SBW 金杯 小型普通客车 个人 非营运 1 DL465Q5 汽油 男性 //建表 create table carsdata(month int,city string,area string,car_model string,brand string,car_type string,owner string,useage string,number...
hadoop MapReduce计算总销售量，每个月的销售量，每个怕品牌的总销售量
不言尘世
12-09 3621
今天来练习一下mapreduce的入门小知识点 准备数据如下截图 有IP xiaomi 华为三个手机品牌，在2019年中每个月每天都有销量 1 求三个品牌一年一共销售多少部手机 package com.sheng.hdfs; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import or...
利用MapReduce对HBase数据进行统计分析
GoFastX的博客
10-27 8960
1、HBase作为一种kv数据库，能够很好的面对高吞吐率的在线数据读写服务，尤其是写操作，但是在非rowkey多条件查询、数据分析、统计等场景下，HBase表现的就不是很好了，这些场景下就比较适合来用MapReduce来计算。 2、应用场景 假设有一张HBase表article,它有一列是数据来源source，现在需要统计不同来源的文章数量(数据行数)，对于这样的简单统计需求，可以利用MapR
基于mapreduce的汽车销售需求分析
qinrunhao的博客
10-27 2588
基于mapreduce的汽车需求分析
【hadoop】汽车销售数据统计分析项目（部分）
_
05-23 7937
来源：《hadoop大数据开发实战》 实验一：统计乘用车辆和商用车辆的数量和销售额分布 设计思路： 首先，写一个Mapper来映射输出所有乘用车辆（feiyingyun）和商用车辆（yingyun）的记录。 然后，写一个reduce统计出乘用车辆和商用车辆各自的数量,写一个map的映射集合中，其中key是车辆类型，value为车辆类型的数量。 同时，定义一个成员变量，统计乘用车辆和商用车辆的总和。 最后，重写reduce中的cleanup方法，在其中计算出乘用车辆和商用车辆各自的销售额分布 然
Hadoop：MapReduce编程之统计二手房数目
Xiao Miao的博客
04-27 1503
要求：统计出上海各个地区二手房的数目，其中将浦东的二手房单独由一个Reduce计算
MapReduce程序分析数据流程
weixin_45484707的博客
08-17 751
分为两步（mapper和reducer）：（1）Mapper端；（2）Reducer端。（(3)启动类） 核心思想：根据业务场景确定K，V。 K的作用：分区、排序、分组、聚合维度； K、V都要实现Hadoop的序列化； Hadoop的序列化实现方式：read、write方法 流程： 1、任务切片划分：计算逻辑–>根据文件大小等 2、根据逻辑启动maptask，maptask的个数决定map执行时的并行度 3、原始数据处理：切片，task负责自己的数据，readline读取一行，得到KV，交给Mappe
交通运输Mapreduce
jws123123123的博客
10-31 276
map： package com.traffic; import java.io.IOException; import org.apache.hadoop.io.LongWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Mapper; import org.apache.hadoop....
MapReduce数据分析教程详解
MapReduce之所以适用于大数据分析，是因为它能够并行处理大量数据，提高数据处理效率，特别是在需要进行大规模批量处理的场景中，MapReduce显示出其巨大的优势。通过MapReduce，可以实现对海量数据的统计分析、日志...
评论 9
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值