MapReduce项目案例4——乘用车辆和商用车辆销售数据分析

最新推荐文章于 2022-12-23 18:45:55 发布
最新推荐文章于 2022-12-23 18:45:55 发布
阅读量5.3k 收藏 83
点赞数 6
分类专栏： Hadoop 文章标签： mapreduce 数据分析 hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51699336/article/details/125486616
版权
该博客介绍了使用Hadoop MapReduce进行汽车行业市场分析的多个任务。首先，统计了乘用车辆和商用车辆的数量和销售额分布。接着，计算了山西省2013年每个月汽车销售数量的比例。然后，分析了2014年4月份安徽省各市区县汽车销售比例。最后，涉及了买车人群的性别比例及其购车选择。通过MapReduce作业，实现了数据的聚合和比例计算，输出了详细的统计结果。
摘要由CSDN通过智能技术生成

项目介绍

1.数据概况

  • 本数据为上牌汽车的销售数据，分为乘用车辆和商用车辆
  • 数据包含销售相关数据与汽车具体参数

2.数据项包括

  • 省0，月1，市2，区县3，年4，车辆型号5，制造商6，品牌7，车辆类型8，所有权9，
  • 使用性质10，数量11，发动机型号12，排量13，功率14，燃料种类15，车长16，车宽17，车高18，车厢长19，
  • 车厢宽20，车厢高21，轴数22，轴距23，前轮距24，轮胎规格25，轮胎数26，总质量27，整备质量28，核定X质量29，
  • 核定载客30，准牵引质量31，底盘企业32，底盘品牌33，底盘型号34，发动机企业35，车辆名称36，年龄37，性别38

3.输入数据

  • 数据量太大，此处复制不方便，自行百度
    在这里插入图片描述

需求分析👇👇

汽车行业市场分析

1.通过统计乘用车辆(非营运)和商用车辆(营运)的数量和销售额分布

  • CountMap
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * 1.1通过统计乘用车辆(非营运)和商用车辆(其他)的数量和销售额分布
 */
public class CountMap extends Mapper<LongWritable, Text, IntWritable, LongWritable> {
    private IntWritable intWritable = new IntWritable();
    private LongWritable longWritable = new LongWritable();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] split = value.toString().trim().split(",");
        //月1 数量11
        if (split != null && split.length > 11 && split[11] != null && !"".equals(split[11].trim())) {
            try {
                intWritable.set(Integer.parseInt(split[1]));
                longWritable.set(Long.parseLong(split[11]));
                context.write(intWritable, longWritable);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
  • CountCombine
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;
import java.util.logging.Logger;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:28
 */
public class CountCombine extends Reducer<Text, LongWritable, Text, LongWritable> {
    private Logger logger = Logger.getLogger(CountCombine.class.getName());

    private LongWritable res = new LongWritable();

    public CountCombine() {
        logger.info("CountCombine的构造方法，是单例吗？");//是
    }

    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        logger.info("CountCombine的setup执行时机");//开始一次
    }

    @Override
    protected void cleanup(Context context) throws IOException, InterruptedException {
        logger.info("CountCombine的cleanup执行时机");//结束一次
    }

    @Override
    protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        Long sum = new Long(0);
        for (LongWritable val : values) {
            sum += val.get();
        }
        res.set(sum);
        logger.info("combine合并：" + key.toString() + ":" + res.get());
        context.write(key, res);
    }
}
  • CountReduce
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:34
 */
public class CountReduce extends Reducer<Text, LongWritable, Text, Text> {
    private Logger logger = Logger.getLogger(CountCombine.class.getName());

    Map<String, Long> map = new HashMap<>();
    double all = 0;

    public CountReduce() {
        logger.info("CountReduce的构造方法，是单例吗？");
    }

    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        logger.info("CountReduce的setup执行时机");
    }

    @Override
    protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        long sum = 0;
        for (LongWritable val : values) {
            sum += val.get();
        }
        all += sum;
        map.put(key.toString(), sum);
        logger.info("CountReduce的reduce：" + key.toString() + ":" + sum);
    }

    @Override
    protected void cleanup(Context context) throws IOException, InterruptedException {
        logger.info("CountReduce的cleanup执行时机");
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            long value = map.get(key);
            double percent = value / all;
            logger.info("CountReduce的cleanup：" + key.toString() + ":" + value + "\t" + percent);
            context.write(new Text(key), new Text(value + "\t" + percent));
        }
    }
}
  • App1
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
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 java.io.IOException;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:45
 */
public class App1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Path input = new Path("E:\\HadoopMRData\\input");
        Path output = new Path("E:\\HadoopMRData\\output");
        if (args != null && args.length == 2) {
            input = new Path(args[0]);
            output = new Path(args[1]);
        }
        Configuration conf = new Configuration();

        //conf.set("fs.defaultFS","hdfs://node1:8020");
        /*FileSystem fs = FileSystem.get(conf);
        if (fs.exists(output)) {
            fs.delete(output, true);
        }*/
        Job job = Job.getInstance(conf, "通过统计乘用车辆(非营运)和商用车辆(其他)的数量和销售额分布");
        job.setJarByClass(App1.class);

        job.setMapperClass(CountMap.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(LongWritable.class);

        job.setCombinerClass(CountCombine.class);
        job.setReducerClass(CountReduce.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        //job.setNumReduceTasks(2);

        FileInputFormat.addInputPath(job, input);
        FileOutputFormat.setOutputPath(job, output);

        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

2.统计山西省2013年每个月的汽车销售数量的比例,按月份排序

  • 输出格式：月份 数量 比例
  • CountMap
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class CountMap extends Mapper<LongWritable, Text, IntWritable, LongWritable> {
    private IntWritable intWritable = new IntWritable();
    private LongWritable longWritable = new LongWritable();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] split = value.toString().trim().split(",");
        //月1 数量11
        if (split != null && split.length > 11 && split[11] != null && !"".equals(split[11].trim())) {
            try {
                intWritable.set(Integer.parseInt(split[1]));
                longWritable.set(Long.parseLong(split[11]));
                context.write(intWritable, longWritable);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
  • CountCombine
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:28
 */
public class CountCombine extends Reducer<IntWritable, LongWritable, IntWritable, LongWritable> {
    private LongWritable res = new LongWritable();

    @Override
    protected void reduce(IntWritable key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        Long sum = new Long(0);
        for (LongWritable val : values) {
            sum += val.get();
        }
        res.set(sum);
        context.write(key, res);
    }
}
  • CountReduce
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:34
 */
public class CountReduce extends Reducer<IntWritable, LongWritable, IntWritable, Text> {
    private Map<Integer, Long> map = new HashMap<Integer, Long>();
    private Long all = 0L;//总销售数
    private DoubleWritable doubleWritable = new DoubleWritable();//比例

    @Override
    protected void reduce(IntWritable key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        Long sum = 0L;
        for (LongWritable val : values) {
            sum += val.get();
        }
        all += sum;
        map.put(key.get(), sum);
    }

    @Override
    protected void cleanup(Context context) throws IOException, InterruptedException {
        Set<Integer> keySet = map.keySet();
        for (Integer key : keySet) {
            Long value = map.get(key);
            double percent = value / (double) all;
            doubleWritable.set(percent);
            context.write(new IntWritable(key), new Text(value + "\t" + doubleWritable));
        }
    }
}
  • App2
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.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:45
 */
public class App2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Path input = new Path("E:\\HadoopMRData\\input");
        Path output = new Path("E:\\HadoopMRData\\output");
        if (args != null && args.length == 2) {
            input = new Path(args[0]);
            output = new Path(args[1]);
        }
        Configuration conf = new Configuration();

        //conf.set("fs.defaultFS","hdfs://node1:8020");
        /*FileSystem fs = FileSystem.get(conf);
        if (fs.exists(output)) {
            fs.delete(output, true);
        }*/
        Job job = Job.getInstance(conf, "统计山西省2013年每个月的汽车销售数量的比例,按月份排序");
        job.setJarByClass(App2.class);

        job.setMapperClass(CountMap.class);
        job.setMapOutputKeyClass(IntWritable.class);
        job.setMapOutputValueClass(LongWritable.class);

        job.setCombinerClass(CountCombine.class);
        job.setReducerClass(CountReduce.class);
        job.setOutputKeyClass(IntWritable.class);
        job.setOutputValueClass(Text.class);

        //job.setNumReduceTasks(2);

        FileInputFormat.addInputPath(job, input);
        FileOutputFormat.setOutputPath(job, output);

        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

3.统计安徽省2014年4月份各市区县的汽车销售的比例

  • 没有安徽省

用户数据市场分析

1.统计买车的男女比例及男女对车的颜色的选择

  • 没有颜色这个列
  • CountMap
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;


public class CountMap extends Mapper<LongWritable, Text, Text, LongWritable> {
    @Override//map的数量由切片决定，一个map的执行顺序setup-map1-map2-cleanup
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] split = value.toString().trim().split(",");
        if (split != null && split.length > 38 && split[38] != null) {
            if ("男性".equals(split[38]) || "女性".equals(split[38])) {
                context.write(new Text(split[38]), new LongWritable(1));
            }
        }
    }
}
  • CountCombine
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:28
 */
public class CountCombine extends Reducer<Text, LongWritable, Text, LongWritable> {
    private LongWritable res = new LongWritable();

    @Override
    protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        long sum = 0L;
        for (LongWritable val : values) {
            sum += val.get();
        }
        res.set(sum);
        context.write(key, res);
    }
}
  • CountReduce
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:34
 */
public class CountReduce extends Reducer<Text, LongWritable, Text, Text> {
    private Map<String, Long> map = new HashMap<String, Long>();
    private long all = 0L;//总销售数
    private DoubleWritable doubleWritable = new DoubleWritable();//比例

    @Override
    protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        long sum = 0L;
        for (LongWritable val : values) {
            sum += val.get();
        }
        all += sum;
        map.put(key.toString(), sum);
    }

    @Override
    protected void cleanup(Context context) throws IOException, InterruptedException {
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            long value = map.get(key);
            double percent = value / (double) all;
            doubleWritable.set(percent);
            context.write(new Text(key), new Text(value + "\t" + doubleWritable));
        }
    }
}
  • App3
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
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 java.io.IOException;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:45
 */
public class App3 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Path input = new Path("E:\\HadoopMRData\\input");
        Path output = new Path("E:\\HadoopMRData\\output");
        if (args != null && args.length == 2) {
            input = new Path(args[0]);
            output = new Path(args[1]);
        }
        Configuration conf = new Configuration();

        //conf.set("fs.defaultFS","hdfs://node1:8020");
        /*FileSystem fs = FileSystem.get(conf);
        if (fs.exists(output)) {
            fs.delete(output, true);
        }*/
        Job job = Job.getInstance(conf, "统计买车的男女比例及男女对车的颜色的选择");
        job.setJarByClass(App3.class);

        job.setMapperClass(CountMap.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(LongWritable.class);

        job.setCombinerClass(CountCombine.class);
        job.setReducerClass(CountReduce.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        //job.setNumReduceTasks(2);

        FileInputFormat.addInputPath(job, input);
        FileOutputFormat.setOutputPath(job, output);

        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

2.统计的车的所有权、型号和类型的汽车销售数及比例

  • CountMap
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;


public class CountMap extends Mapper<LongWritable, Text, Text, LongWritable> {
    @Override//map的数量由切片决定，一个map的执行顺序setup-map1-map2-cleanup
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] split = value.toString().trim().split(",");
        //所有权10、型号6和类型9
        if (split != null && split.length > 10 && split[10] != null && split[6] != null && split[9] != null) {
            if (!"".equals(split[10]) && !"".equals(split[6]) && !"".equals(split[9])) {
                context.write(new Text(split[10] + "\t" + split[6] + "\t" + split[9]), new LongWritable(1));
            }
        }
    }
}
  • CountReduce
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:34
 */
public class CountReduce extends Reducer<Text, LongWritable, Text, Text> {
    private Map<String, Long> map = new HashMap<String, Long>();
    private long all = 0L;//总销售数
    private DoubleWritable doubleWritable = new DoubleWritable();//比例

    @Override
    protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        long sum = 0L;
        for (LongWritable val : values) {
            sum += val.get();
        }
        all += sum;
        map.put(key.toString(), sum);
    }

    @Override
    protected void cleanup(Context context) throws IOException, InterruptedException {
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            long value = map.get(key);
            double percent = value / (double) all;
            doubleWritable.set(percent);
            context.write(new Text(key), new Text(value + "\t" + doubleWritable));
        }
    }
}
  • App4
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
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 java.io.IOException;

/**
 * @program: Hadoop_MR
 * @description:
 * @author: 作者
 * @create: 2022-06-21 23:45
 */
public class App4 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Path input = new Path("E:\\HadoopMRData\\input");
        Path output = new Path("E:\\HadoopMRData\\output");
        if (args != null && args.length == 2) {
            input = new Path(args[0]);
            output = new Path(args[1]);
        }
        Configuration conf = new Configuration();

        //conf.set("fs.defaultFS","hdfs://node1:8020");
        /*FileSystem fs = FileSystem.get(conf);
        if (fs.exists(output)) {
            fs.delete(output, true);
        }*/
        Job job = Job.getInstance(conf, "统计的车的所有权、型号和类型");
        job.setJarByClass(App4.class);

        job.setMapperClass(CountMap.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(LongWritable.class);

        job.setGroupingComparatorClass(Count10Group.class);

        job.setReducerClass(CountReduce.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        FileInputFormat.addInputPath(job, input);
        FileOutputFormat.setOutputPath(job, output);

        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

3.每个类型车的用户做年龄和性别的统计

不同车型销售统计分析

1.统计不同类型车在一个月(对一段时间：如每个月或每年)的总销售量

2.通过不同类型(品牌)车销售情况，来统计发动机型号和燃料种类

3.统计价格相同而类型(品牌)不同车的销售量

针对某一品牌的竞争分析

1.统计一汽大众的每一年(每一个月)的销售量和增长率(趋势)

2.统计一汽大众在山西和安徽销售量及其价格的差异

ChenJieYaYa
关注
  • 6
    点赞
  • 踩
  • 83
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
大数据Hive学习案例(2)——基于汽车销售的日志数据分析
程研板的博客
08-12 1万+
下方有数据可免费下载 目录原始数据项目实战数据仓库的构建1.构建数据仓库2.创建原始数据表3.加载数据到数据仓库4.验证数据结果数据分析1.乘用车辆和商用车辆的销售数量和比例2.山西省2013年每个月的汽车销售数量比例3.买车的男女比例和男女对车的品牌的选择4.车的所有权，车辆型号，车辆类型5.不同车型在一个月的销售量6.不同品牌车销售情况，统计发动机和燃料种类7.统计五菱某一年每月的销售量 数据下载请点击我，提取码：cxr7，觉得有用希望您能点一个赞哦。 原始数据 原始数据为csv格式，列数比较多 .
汽车销量分析系统.zip
04-26
记一次基于python和Hadoop集群的项目实战报告，压缩包包括实验报告书和txt源数据
Hadoop技术原理与应用
小刘的博客
02-19 2333
Hadoop数据处理(2020年大二上实训) 一、项目背景 本次实训内容为汽车销售数据统计分析项目。通过这个项目，加深对HDFS分布式文件系统和MapReduce分布式并行计算框架的理解，熟练掌握和应用，并且体验大数据企业实战项目的开发过程，积累实际项目开发的经验。 二、项目开发实战 （一）设计思路分析 1.任务七： 统计分析不同车型销售数据我们的需求是统计某一个月份各个类型车辆的总销售量，在这里，我们以9月份为例进行统计，那么需要过滤出9月份的汽车总销售数组，然...
【hadoop】汽车销售数据统计分析项目（部分）
暮色年华的博客
05-23 6903
来源：《hadoop大数据开发实战》 实验一：统计乘用车辆和商用车辆的数量和销售额分布 设计思路： 首先，写一个Mapper来映射输出所有乘用车辆（feiyingyun）和商用车辆（yingyun）的记录。 然后，写一个reduce统计出乘用车辆和商用车辆各自的数量,写一个map的映射集合中，其中key是车辆类型，value为车辆类型的数量。 同时，定义一个成员变量，统计乘用车辆和商用车辆的总和。 最后，重写reduce中的cleanup方法，在其中计算出乘用车辆和商用车辆各自的销售额分布 然
基于mapreduce的汽车销售需求分析
qinrunhao的博客
10-27 2292
基于mapreduce的汽车需求分析
MapReduce解决乘用车辆和商用车辆的销售数据分析
marraybug的博客
07-05 4272
首先还是看下我们的需求 然后拿到我们的数据 可以看到我们的数据里面还有很多空值,是还没清洗的脏数据,一会我们处理的时候需要将其处理掉. 一.统计车辆不同用途的数量分布 package hadoop.MapReduce.car.Use; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWr...
大数据实验数据——商用车销量数据案例.xlsx
12-13
7W+条数据，大数据实验源数据——商用车销量数据案例.xlsx，可用做大数据实验，数据挖掘、数据分析等
Google_三大论文中文版
12-11
- **应用场景**：适用于各种大数据处理任务，如搜索引擎索引构建、大规模数据分析等。 **2. MapReduce的工作原理** - **核心算法**：MapReduce通过两个主要阶段——Map阶段和Reduce阶段——来处理数据。 - **Map...
初识Hadoop.docx
10-26
- **概念解析**：大数据的概念并非特指某个具体的数据量级，而是指那些无法用传统的数据处理工具进行有效捕捉、管理和处理的数据集合。这种数据集不仅量大，而且类型多样、变化快，其价值密度往往较低。 - **...
2013年中国数据库大会-43-大数据，商业智能的挑战
04-23
大数据的背景是大会讨论的重要部分，大数据的“4V”特征——数据量大(Volume)、速度快(Velocity)、类型多(Variety)、价值密度低(Value)是大数据分析和存储技术面临的主要挑战。谷歌作为大数据时代的引领者，其产品...
大数据综合实验二 汽车销售数据统计分析项目.pdf
10-29
大数据综合实验二 汽车销售数据统计分析项目.pdf
car_lamp.rar
04-19
本文档是基于quartus2的汽车尾灯eda设计 Quartus II 是Altera公司的综合性PLD/FPGA开发软件，支持原理图、VHDL、VerilogHDL以及AHDL（Altera Hardware Description Language）等多种设计输入形式，内嵌自有的综合器以及仿真器，可以完成从设计输入到硬件配置的完整PLD设计流程。
Hadoop_in_Action.pdf
11-30
- **Hadoop 实例研究**：这部分通过实际案例展示了Hadoop 如何被应用于不同的领域，如社交网络分析、生物信息学和金融数据分析等。 #### 知识点五：Hadoop 的生态系统与工具 - **Hadoop 生态系统**：除了核心的...
mapreduce和hive 对山西省汽车销售数据分析
weixin_45067832的博客
10-26 6499
数据样本，只截取了部分，有需要可私信谢谢： 该篇内容只完成了以下两个要求： 1.统计山西省2013年每个月的汽车销售数量的比例，结果例如： 2.统计不同品牌的车在每个月的销售量分布，结果例如： 具体实现方法，使用mapreduce实现，或使用HiveQL实现 一：mapreduce实现： 1.统计山西省2013年每个月的汽车销售数量的比例 package com.cxy.car; import org.apache.hadoop.conf.Configuration; import org.apac
分布式与并行计算大作业
qq_43437122的博客
06-26 1921
一、项目 汽车销售数据分析 二、数据概况： 本数据为上牌汽车的销售数据，分为乘用车辆和商用车辆。数据包含销售相关数据与汽车具体参数。数据项包括：时间、销售地点、邮政编码、车辆类型、车辆型号、制造厂商名称、排量、油耗、功率、发动机型号、燃料种类、车外廓长宽高、轴距、前后车轮、轮胎规格、轮胎数、载客数、所有权、购买人相关信息等。 三、具体要求： 1.统计山西省2013年每个月的汽车销售数量的比例，结果例如： 2.统计不同品牌的车在每个月的销售量分布，结果例如： 四、代码实现 1. 统计山西省2013年每个月
基于spark+hive+hbase的乘用车辆和商用车辆销售数据分析
最新发布
qq_42135426的博客
12-23 1002
基于spark+hive+hbase的乘用车辆和商用车辆销售数据分析
Hadoop(4-1)-MapReduce程序案例-统计销售商品数量
知行合一，止于至善
08-09 8410
1.问题陈述： 找出销往各个国家商品数量。 输入: 我们的畋输入数据集合是一个 CSV 文件, Sales2014.csv 输出：国家名 销往次国家的商品数量 商品信息如图所示 2.前提条件： • 本教程是在Linux上开发 • 已经安装了Hadoop(本教程使用版本2.6.5) • 系统上已安装了Java(本教程使用 JDK1.8.0)。 3.步骤
hive-学习汽车销售分析
LLMUZI123456789的博客
11-28 966
from car_table where gender = ‘男性’ or gender = ‘女性’),4)*100||‘%’ raite。where (t.gender = ‘男性’ or t.gender = ‘女性’) and t.brand is not null。=‘非营运’,t1.sal_nums,0)) cycar_nums – 3884。sum(if(t1.nature=‘非营运’,t1.sal_nums,0)) sycar_nums – 66478。--跳过文件行首1行;
hive实例-乘用车辆和商用车辆销售数据分析
qq_32632603的博客
07-27 5488
数据源地址：http://pan.baidu.com/s/1cKsrKi 1.准备数据源 打开 上牌数--商用车销量数据样例.xlsx，另存为car.txt文件，打开car.txt，设置编码格式为UTF-8，保存并上传至master节点。 2.创建car 数据库，建立car表，并上传数据 create external table cars( province string, --省
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值