笔记-hadoop-MapReduce

最新推荐文章于 2023-02-12 21:10:53 发布
最新推荐文章于 2023-02-12 21:10:53 发布
阅读量252 收藏 1
点赞数
分类专栏： 笔记-hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu_1221/article/details/97272920
版权

——尚硅谷视频笔记

MapReduce核心思想

 

1）分布式的运算程序往往需要分成至少2个阶段。

2）第一个阶段的MapTask并发实例，完全并行运行，互不相干。

3）第二个阶段的ReduceTask并发实例互不相干，但是他们的数据依赖于上一个阶段的所有MapTask并发实例的输出。

4）MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段，如果用户的业务逻辑非常复杂，那就只能多个MapReduce程序，串行运行。

总结：分析WordCount数据流走向深入理解MapReduce核心思想。

MapReduce进程

一个完整的MapReduce程序在分布式运行时有三类实例进程：

  1. MrAppMaster：负责整个程序的过程调度及状态协调。
  2. MapTask：负责Map阶段的整个数据处理流程。
  3. ReduceTask：负责Reduce阶段的整个数据处理流程。

常用数据序列化类型

Java类型

Hadoop Writable类型

boolean

BooleanWritable

byte

ByteWritable

int

IntWritable

float

FloatWritable

long

LongWritable

double

DoubleWritable

String

Text

map

MapWritable

array

ArrayWritable

MapReduce编程规范

用户编写的程序分成三个部分：Mapper、Reducer和Driver。

1．Mapper阶段

（1）用户自定义的Mapper要继承自己的父类

（2）Mapper的输入数据是KV对的形式（KV的类型可自定义）

（3）Mapper中的业务逻辑写在map()方法中

（4）Mapper的输出数据是KV对的形式（KV的类型可自定义）

（5）map()方法（MapTask进程）对每一个<K,V>调用一次

2．Reducer阶段

（1）用户自定义的Reducer要继承自己的父类

（2）Reducer的输入数据类型对应Mapper的输出数据类型，也是KV

（3）Reducer的业务逻辑写在reduce()方法中

（4）ReduceTask进程对每一组相同k的<k,v>组调用一次reduce()方法

3．Driver阶段

相当于YARN集群的客户端，用于提交我们整个程序到YARN集群，提交的是封装了MapReduce程序相关运行参数的job对象

WordCount案例

1．在pom.xml文件中添加如下依赖

<dependencies>
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.apache.logging.log4j</groupId>
		<artifactId>log4j-core</artifactId>
		<version>2.8.2</version>
	</dependency>
	<dependency>
		<groupId>org.apache.hadoop</groupId>
		<artifactId>hadoop-common</artifactId>
		<version>2.7.2</version>
	</dependency>
	<dependency>
		<groupId>org.apache.hadoop</groupId>
		<artifactId>hadoop-client</artifactId>
		<version>2.7.2</version>
	</dependency>
	<dependency>
		<groupId>org.apache.hadoop</groupId>
		<artifactId>hadoop-hdfs</artifactId>
		<version>2.7.2</version>
	</dependency>
</dependencies>

2．在项目的src/main/resources目录下，新建一个文件，命名为“log4j.properties”，在文件中填入。

log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

 3．编写程序

（1）编写Mapper类

package com.liun.mr.wordcount;

import java.io.IOException;

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

// map
public class WordcountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
	Text k = new Text();
	IntWritable v = new IntWritable(1);
	@Override
	protected void map(LongWritable key, Text value, Context context)
			throws IOException, InterruptedException {
		
		// 1 获取一行数据
		String line = value.toString();
		
		// 2 处理数据
		String[] words = line.split(" ");

		// 3 循环写出
		for (String word : words) {
			// 4 去除标点符号
			String  kword= word.replaceAll("[\\pP\\p{Punct}]","");
			
			k.set(kword);
			context.write(k, v);
		}
		
	}

}

（2）编写Reducer类

package com.liun.mr.wordcount;

import java.io.IOException;

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

public class WordcountReducer extends Reducer<Text, IntWritable, Text, IntWritable>{
	IntWritable v = new IntWritable();
	
	@Override
	protected void reduce(Text key, Iterable<IntWritable> values,
			Context context) throws IOException, InterruptedException {
		
		int sum =0;
		// 1 累加求和
		for (IntWritable value : values) {
			
			sum += value.get();
		}
		
		v.set(sum);
		
		// 2 写出
		context.write(key, v);
	}

}

（3）编写Driver驱动类

package com.liun.mr.wordcount;

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.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;


public class WordcountDriver {
	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		
		Configuration conf = new Configuration();
		// 1 获取Job对象
		Job job = Job.getInstance(conf);
		
		// 2 设置jar存储位置
		job.setJarByClass(WordcountDriver.class);
		
		// 3 关联Map和Reduce类
		job.setMapperClass(WordcountMapper.class);
		job.setReducerClass(WordcountReducer.class);
		
		// 4 设置Mapper阶段输出数据的key和value类型
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(IntWritable.class);
		
		// 5 设置最终数据输出的key和valu类型
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		
		// 6 设置输入路径和输出路径
		FileInputFormat.setInputPaths(job, new Path(args[0]));
		
		FileOutputFormat.setOutputPath(job, new Path(args[1]));
		
		// 7 提交Job
		boolean result = job.waitForCompletion(true);
		
		System.exit(result ? 0:1);
	}

}

（4）集群上测试

用maven打jar包，需要pom.xml添加的打包插件依赖

<build>
	<plugins>
		<plugin>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>2.3.2</version>
			<configuration>
				<source>1.8</source>
				<target>1.8</target>
			</configuration>
		</plugin>
		<plugin>
			<artifactId>maven-assembly-plugin </artifactId>
			<configuration>
				<descriptorRefs>
					<descriptorRef>jar-with-dependencies</descriptorRef>
				</descriptorRefs>
				<archive>
					<manifest>
						<mainClass>com.liun.mr.wordcount.WordcountDriver</mainClass>
					</manifest>
				</archive>
			</configuration>
			<executions>
				<execution>
					<id>make-assembly</id>
					<phase>package</phase>
					<goals>
						<goal>single</goal>
					</goals>
				</execution>
			</executions>
		</plugin>
	</plugins>
</build>

在项目上右键->maven->update project

右键->Run as->maven install。

Hadoop序列化

序列化概述

 什么是序列化

    序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储到磁盘（持久化）和网络传输。

    反序列化就是将收到字节序列（或其他数据传输协议）或者是磁盘的持久化数据，转换成内存中的对象。

为什么要序列化

    一般来说，“活的”对象只生存在内存里，关机断电就没有了。而且“活的”对象只能由本地的进程使用，不能被发送到网络上的另外一台计算机。 然而序列化可以存储“活的”对象，可以将“活的”对象发送到远程计算机。

为什么不用Java的序列化

   Java的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息，Header，继承体系等），不便于在网络中高效传输。所以，Hadoop自己开发了一套序列化机制（Writable）。

Hadoop序列化特点：

（1）紧凑 ：高效使用存储空间。
（2）快速：读写数据的额外开销小。
（3）可扩展：随着通信协议的升级而可升级。
（4）互操作：支持多语言的交互。

自定义bean对象实现序列化接口（Writable）

在企业开发中往往常用的基本序列化类型不能满足所有需求，比如在Hadoop框架内部传递一个bean对象，那么该对象就需要实现序列化接口。

具体实现bean对象序列化步骤如下7步。

（1）必须实现Writable接口

（2）反序列化时，需要反射调用空参构造函数，所以必须有空参构造

（3）重写序列化方法

（4）重写反序列化方法

（5）注意：反序列化的顺序和序列化的顺序完全一致

（6）要想把结果显示在文件中，需要重写toString()，可用”\t”分开，方便后续用。

（7）如果需要将自定义的bean放在key中传输，则还需要实现Comparable接口，因为MapReduce框中的Shuffle过程要求对key必须能排序。

序列化案例

需求

统计每一个手机号耗费的总上行流量、下行流量、总流量

输入数据格式：

7      13560436666      120.196.100.99            1116           954                    200

id      手机号码            网络ip                         上行流量  下行流量     网络状态码

期望输出数据格式：

13560436666              1116                 954                            2070

手机号码                上行流量        下行流量                         总流量

输入数据

1    13736230513    192.196.100.1    www.atguigu.com    2481    24681    200
2    13846544121    192.196.100.2            264    0    200
3     13956435636    192.196.100.3            132    1512    200
4     13966251146    192.168.100.1            240    0    404
5     18271575951    192.168.100.2    www.atguigu.com    1527    2106    200
6     84188413    192.168.100.3    www.atguigu.com    4116    1432    200
7     13590439668    192.168.100.4            1116    954    200
8     15910133277    192.168.100.5    www.hao123.com    3156    2936    200
9     13729199489    192.168.100.6            240    0    200
10     13630577991    192.168.100.7    www.shouhu.com    6960    690    200
11     15043685818    192.168.100.8    www.baidu.com    3659    3538    200
12     15959002129    192.168.100.9    www.atguigu.com    1938    180    500
13     13560439638    192.168.100.10            918    4938    200
14     13470253144    192.168.100.11            180    180    200
15     13682846555    192.168.100.12    www.qq.com    1938    2910    200
16     13992314666    192.168.100.13    www.gaga.com    3008    3720    200
17     13509468723    192.168.100.14    www.qinghua.com    7335    110349    404
18     18390173782    192.168.100.15    www.sogou.com    9531    2412    200
19     13975057813    192.168.100.16    www.baidu.com    11058    48243    200
20     13768778790    192.168.100.17            120    120    200
21     13568436656    192.168.100.18    www.alibaba.com    2481    24681    200
22     13568436656    192.168.100.19            1116    954    200

需求分析：

编写MapReduce程序

（1）编写流量统计的Bean对象

package com.liun.mr.flowsum;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

import org.apache.hadoop.io.Writable;

public class FlowBean implements Writable{
	
	private long upFlow; // 上行流量
	private long downFlow;// 下行流量
	private long sumFlow;// 总流量
	
	
	// 空参构造，为了后续反射用
	public FlowBean() {
		super();
	}

	//序列化
	@Override
	public void write(DataOutput out) throws IOException {
		out.writeLong(upFlow);
		out.writeLong(downFlow);
		out.writeLong(sumFlow);
	}

	//反序列化
	@Override
	public void readFields(DataInput in) throws IOException {
		upFlow = in.readLong();
		downFlow = in.readLong();
		sumFlow = in.readLong();
	}



	@Override
	public String toString() {
		return upFlow + "\t" + downFlow + "\t" + sumFlow ;
	}



	public long getUpFlow() {
		return upFlow;
	}



	public void setUpFlow(long upFlow) {
		this.upFlow = upFlow;
	}



	public long getDownFlow() {
		return downFlow;
	}



	public void setDownFlow(long downFlow) {
		this.downFlow = downFlow;
	}



	public long getSumFlow() {
		return sumFlow;
	}



	public void setSumFlow(long sumFlow) {
		this.sumFlow = sumFlow;
	}

	public void setsumFlow(long sum_upFlow, long sum_downFlow) {
		
		sumFlow = sum_downFlow+sum_upFlow;
	}
}

（2）编写Mapper类

package com.liun.mr.flowsum;

import java.io.IOException;

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

public class FlowCountMapper extends Mapper<LongWritable, Text, Text, FlowBean>{
	Text k = new Text();
	FlowBean v = new FlowBean();
	@Override
	protected void map(LongWritable key, Text value, Context context)
			throws IOException, InterruptedException {
		
		// 1 获取一行数据
		String line = value.toString();
		
		// 2 切割\t
		String[] fields = line.split("\t");
		
		// 3 封装对象
		k.set(fields[1]);// 封装手机号
		
		long upFlow = Long.parseLong(fields[fields.length - 3]);
		long downFlow = Long.parseLong(fields[fields.length - 2]);
		
		v.setUpFlow(upFlow);
		v.setDownFlow(downFlow);
		
		// 4 写出
		context.write(k, v);
		
	}

}

（3）编写Reducer类

package com.liun.mr.flowsum;

import java.io.IOException;

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

public class FlowCountReducer extends Reducer<Text, FlowBean, Text, FlowBean>{
	FlowBean v = new FlowBean();
	
	@Override
	protected void reduce(Text key, Iterable<FlowBean> values,Context context)
			throws IOException, InterruptedException {
		
		long sum_upFlow =0;
		long sum_downFlow =0;
		// 1 累加求和
		for (FlowBean flowBean : values) {
			sum_upFlow += flowBean.getUpFlow();
			sum_downFlow += flowBean.getDownFlow();
			
		}
		v.setUpFlow(sum_upFlow);
		v.setDownFlow(sum_downFlow);
		v.setsumFlow(sum_upFlow,sum_downFlow);
		
		// 2 写出
		context.write(key, v);
	}

}

（4）编写Driver驱动类

package com.liun.mr.flowsum;

import java.io.IOException;

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

public class FlowsumDriver {
	
	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		
		Configuration conf = new Configuration();
		// 1 获取Job对象
		Job job = Job.getInstance(conf);
		
		// 2 设置jar的路径
		job.setJarByClass(FlowsumDriver.class);
		
		// 3 关联mapper和reducer
		job.setMapperClass(FlowCountMapper.class);
		job.setReducerClass(FlowCountReducer.class);
		
		// 4 设置mapper输出key和value类型
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(FlowBean.class);
		
		// 5 设置最终输出key和value类型
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(FlowBean.class);
		
		// 6 设置输入输出路径
		FileInputFormat.setInputPaths(job, new Path(args[0]));
		FileOutputFormat.setOutputPath(job, new Path(args[1]));
		
		// 7 提交Job
		boolean result = job.waitForCompletion(true);
		
		System.exit(result ? 0:1);
		
	}

}

 

liu_1221
关注
专栏目录
大数据之-Hadoop3.x_MapReduce_shuffle机制---大数据之hadoop3.x工作笔记0110
添柴程序猿的专栏
12-17 654
1.这个shuffle机制,是在map方法和reduce方法之间的一种机制 shuffle是在map方法之后,reduce方法之前,用来处理数据的过程. 可以看到我们再来回想一下,map方法执行以后,会对数据进行,整理,然后写入环形缓冲区,会把元数据,索引写入到环形缓冲区左侧, 把真正的数据写入到环形缓冲区,右侧,然后当写入的数据,达到环形缓冲区的,百分之80的时候,就可以溢写,同时进行反向逆写,这样好留出, 一些空闲时间,这样的话,不至于,等到环形缓冲区,被写满了以后,再去溢写,这样.
大数据之-Hadoop3.x_MapReduce_HashPartitioner分区---大数据之hadoop3.x工作笔记0111
添柴程序猿的专栏
12-20 454
我们通过一个案例来说明,比如我们要将135开头的手机号,放到一个文件中,将136开头的手机号, 放到另一个文件中..这个需求怎么来做. 1.首先我们来看一下hadoop的默认的分区是怎么做的,可以看到,默认进行分区的,一个类,叫做HashPartitioner,这个其实就是 可以看到,根据了来源数据的key,进行分区,可以看到这里,key.hashCode & Integer.MAX_VALUE 这个的作用是什么? 这个的作用其实很简单,可以看到用到的是与,而且与上,int的...
大数据学习之路01——让Hadoop在MacOS上跑起来
汪志宾的博客
05-17 833
文章目录安装目录准备工作JDK下载Hadoop安装与配置Hadoop修改JDK配置验证Hadoop单机模式执行配置core-site.xml配置hdfs-site.xml启动与停止Hadoop配置.bash_profile第一次启动hdfs需要格式化启动HDFS停止HDFSHDFS启动状态查看验证HDFS启动时遇到的坑一、sh: connect to host localhost port 22:...
【MapReduce】Mac上单机Hadoop安装
Mr_zhuo_的博客
10-20 608
说明： 安装JDK版本：jdk1.8.0_231 安装Hadoop版本：3.2.1 1. 安装JDK https://www.jianshu.com/p/a85658902f26 注意添加export那一行的时候根据自己的jdk版本更改，我的是jdk1.8.0_231.jdk，不是jdk1.8.0_211.jdk。 2. 安装Homebrew和Homebrew-cask ...
Hadoop，MapReduce，参数
weixin_30642561的博客
05-15 114
下面介绍MapReduce的主要的六个类，只有了解了这六个类的作用，才能在编写程序中知道哪个类是要自己实现，哪些类可以调用默认的类，才能真正的做到游刃有余，关于需要自己编写的类（用户制定类）可以参考：http://www.cnblogs.com/liqizhou/archive/2012/05/14/2499498.html InputFormat类。该类的作用是将输入的文件和数...
关于macbook m1 hadoop集群求助
qq_39371390的博客
10-13 662
请问大佬们 MacBook m1 可以搭建起来hadoop集群吗 有哪些方式
CENTOS上的网络安全工具（十一）走向Hadoop（3） MapReduce示例解析
lhyzws的专栏
09-09 639
对MapReduce示例程序Grep.java的源码执行流程进行分析，涉及Configuration,FileInputFromat,RegexMapper,ToolRunner,Tool,RecordReader等主要类
Java笔记---Hadoop 2.7.1下WordCount程序详解
热门推荐
GuLu_GuLu_jp的专栏
05-02 2万+
一、前言 在之前我们已经在 CenOS6.5 下搭建好了 Hadoop2.x 的开发环境。既然环境已经搭建好了，那么现在我们就应该来干点正事嘛！比如来一个Hadoop世界的HelloWorld，也就是WordCount程序(一个简单的单词计数程序) 二、WordCount 官方案例的运行 2.1 程序简介 WordCount程序是hadoop自带的案例，我们可以在 hadoop...
Hadoop学习笔记--MapReduce
weixin_49588575的博客
02-12 570
介绍了MapReduce的作业执行流程、序列化、Shuffle机制和MapReduce调优！
Hadoop学习笔记-MapReduce实现好友推荐记录
Dengrz的Blog
11-11 895
一、简介 好友推荐功能简单的说是这样一个需求，预测某两个人是否认识，并推荐为好友。 二、思路 某两个非好友的用户，他们的共同好友越多，那么他们越可能认识。 比如，原始数据如下 Tom Cat Hello Hadoop Spring Cat Hello Spring Hello Tom Netty Hadoop Cat Hadoop Tom Hello Netty Spring Spring Tom Cat Hadoop Netty Hello Hadoop 每一行表示某个用户的好
Hadoop运行MapReduce Job
小小码农
01-27 427
在Hadoop的share目录里，自带了一些jar包，里面带有一些mapreduce实例小例子，位置在share/hadoop/mapreduce/hadoop-mapreduce-examples-2.5.0.jar，可以运行这些例子体验刚搭建好的Hadoop平台，我们这里来运行最经典的WordCount实例，来进行单词个数的统计。 1、 创建测试用的Input文件 创建输入目录:
Hadoop学习笔记（二）MapReduce Job
leminfei的博客
11-04 534
Hadoop学习笔记（三）MapReduce
mac上基于docker搭建hadoop集群
01-20
1、拉取centos8的镜像 在用户目录下： 2、构建集群子网 按照集群的架构，创建容器时需要设置固定IP，所以先要在docker使用如下命令创建固定IP的子网 docker network create –subnet=172.18.0.0/16 netgroup 对各个节点指定好功能 maseter为主节点，hadoop01 为从节点和datanode hadoop02 为yarn主节点负责各个节点的资源调度, hadoop02，hadoop03为datanode节点 OS hostname IP Centos8 hadoop-master 172.1
Hadoop学习——MapReduce的job机制和job链介绍
凌大大的博客
12-28 6351
  前边写了MapReduce的介绍、以及四大组件、序列化机制和排序。   这一篇记录一下MapReduce相关的job机制，对于在代码里，我们总要有一个Driver，比如下边： public static void main(String[] args) throws Exception { Configuration conf = new Configuration(); //获取j...
CentOS搭建MapReduce环境
weixin_49995598的博客
03-12 580
MapReduce环境搭建前言1、修改yarn-site.xml文件2、修改mapred-site.xml2.启动 前言 上一篇配置的hadoop单机环境，这篇依靠hadoop搭建MapReduce环境，如无hadoop环境请参考上篇文章搭建https://blog.csdn.net/weixin_49995598/article/details/114263408?spm=1001.2014.3001.5501 1、修改yarn-site.xml文件 <configuration>
【hadoop学习笔记】---MapReduce
菜菜鸟的博客
09-28 809
MapReduce介绍 一个以高可靠，高容错方式编写程序并行的处理在大的集群上存储的大量的数据的软件框架，这些集群可以由通用的硬件组成。其对外提供了5个标准的可编程接口，InputFormat、Mappper、Partitioner、Reducer、OutputFormat。 MapReduce架构 采用master/slave架构，主要组成组件有：Client、JobTracker、T...
Hadoop-MapReduce-学习资料及文档.zip
最新发布
10-02
内容概要： mr执行笔记； mapreduce框架的规范； wc流程.xls； wordcount的伪代码； yarn提交job的源码流程； YARN中提交job的详细流程； 打开流的关键代码； 打开流的调用流程； 日志格式；
五、Hadoop系统应用之MapReduce分布式计算框架（二）（超详细步骤指导操作，WIN10，VMware Workstation 15.5 PRO，CentOS-6.7）
weixin_42051846的博客
12-14 565
Hadoop系统应用实验之MapReduce分布式计算框架（一），操作案例为在本地模式使用MapReduce程序实现倒排索引，WIN10系统，虚拟机软件VMware Workstation 15.5 PRO，Linux版本CentOS-6.7，超详细步骤配图详解，对新手友好。
Hadoop集群搭建_centos8虚拟机安装
weixin_44909514的博客
03-30 2233
一、通过VMware准备好三台centos8.0虚拟机 第一步： 第二步： 第三步： 第四步(选择之前准备好的centos8镜像)： 第五步： 第六步： 第七步： 第八步: 第九步： 第十步： 第十一步： 第十二步： 第十三步： 第十四步： 第十五步：若需修改，可在此进行编辑虚拟机配置 第十六步： ...
MapReduce编程初体验（idea+VMware）:统计一个文档里的单词数量
Hxm6440的博客
11-15 525
将在idea里的java代码放在VMware里运行，具体操作步骤 java代码与在idea里的差不多，只有WordCountDriverLinux 做了一点改变 其他的代码参考 MapReduce编程初体验（idea）：统计一个文档里的单词个数 编写 WordCountDriverLinux 类 package com.czxy.test01; import org.apache.hadoop....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值