hadoop 自学指南四之常见MapReduce案例

最新推荐文章于 2022-02-20 09:52:44 发布
最新推荐文章于 2022-02-20 09:52:44 发布
阅读量581 收藏
点赞数
分类专栏： hadoop 自学指南
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ice_grey/article/details/48441699
版权

一、前言

介绍MapReduce 一些常见的经典案例

二、去重

思想：利用MapReduce 的shuffle过程，合并相同的key 特性，可实现。

核心：Map ->context.write(new Text(line),new Text("")) ;      Reduce->context.write(key,new Text(""))

package hadoop.v5;

import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configured;
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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import hadoop.utils.HDFSUtils;

/**
 * @author : chenhaipeng
 * @date : 2015年9月6日 上午2:00:50
 */
public class Duplication extends Configured implements Tool {
	
	public static class Map extends Mapper<LongWritable, Text, Text, Text>{
//		private final static IntWritable one = new IntWritable(1);
//		private Text word = new Text("UTF-8");
		/* (non-Javadoc)
		 * @see org.apache.hadoop.mapreduce.Mapper#map(java.lang.Object, java.lang.Object, org.apache.hadoop.mapreduce.Mapper.Context)
		 */
		@Override
		public void map(LongWritable key, Text value, Context context)
				throws IOException, InterruptedException {
			String line = value.toString();
//			StringTokenizer tokenizer = new StringTokenizer(line);
//			while(tokenizer.hasMoreTokens()){
//				word.set(tokenizer.nextToken());
				context.write(new Text(line), new Text(""));
//			}
		}
		
	}
	
	public static class Reduce extends Reducer<Text, Text, Text, Text>{
		/* (non-Javadoc)
		 * @see org.apache.hadoop.mapreduce.Reducer#reduce(java.lang.Object, java.lang.Iterable, org.apache.hadoop.mapreduce.Reducer.Context)
		 */
		@Override
		public void reduce(Text key, Iterable<Text> values,Context context) throws IOException, InterruptedException {
/* 			int sum = 0; 
			for(IntWritable value : values){
				sum += value.get();
			}
			System.out.println("key----->"+key);*/
			context.write(key, new Text(""));
		}
		
	}

	public static void main(String[] args) throws Exception {
		int ret = ToolRunner.run(new Duplication(), args);
		System.exit(ret);

	}
	
	public static void deletedir(String path){
		try {
			HDFSUtils.DeleteHDFSFile(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/* 
	 * @see org.apache.hadoop.util.Tool#run(java.lang.String[])
	 */
	@Override
	public int run(String[] args) throws Exception {
		Job job = new Job(getConf());
		job.setJarByClass(Duplication.class);
		job.setJobName("Duplication");
		
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(Text.class);
	//并不是一定要	
//		job.setInputFormatClass(TextInputFormat.class);
//		job.setOutputFormatClass(TextOutputFormat.class);
		
		job.setMapperClass(Map.class);
		job.setReducerClass(Reduce.class);
		
		job.setCombinerClass(Reduce.class);
		
		FileInputFormat.setInputPaths(job, new Path(args[0]));
		deletedir(args[1]);
		FileOutputFormat.setOutputPath(job, new Path(args[1]));
		
		boolean sucess = job.waitForCompletion(true);
		return sucess == true? 0 : 1;
		
	}

}

三、排序

思想：Map输出hadoop 会自动进行shuffle过程，需要重写comparator和partition

package hadoop.v5;

import java.io.File;
import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.commons.lang.StringUtils;
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.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;
import org.apache.hadoop.mapred.JobConf;
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;

import hadoop.utils.EJob;
import hadoop.utils.HDFSUtils;

/**
 * 场景：对刚才统计出的单词数作一个由高到低的排序
 * 思路：Map输出hadoop 会自动进行shuffle过程，需要重写comparator和partition
 * @author : chenhaipeng
 * @date : 2015年9月8日 下午11:58:32
 */
public class SortWordCount {

	public static class SortMap extends Mapper<LongWritable, Text, IntWritable, Text> {
		private Text word = new Text();
		private IntWritable count = new IntWritable();

		/*
		 * 使key--value反转输出
		 * 
		 * @see org.apache.hadoop.mapreduce.Mapper#map(java.lang.Object,
		 * java.lang.Object, org.apache.hadoop.mapreduce.Mapper.Context)
		 */
		@Override
		protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
			String line = value.toString();
			if (StringUtils.isNotEmpty(line)) {
				// 读入每一个数据
				StringTokenizer tokenizer = new StringTokenizer(line);
				while (tokenizer.hasMoreTokens()) {
					word.set(tokenizer.nextToken().trim().toString());
					count.set(Integer.parseInt(tokenizer.nextToken().trim()));
					System.out.println(count+"-->"+word);
					context.write(count, word);
				}
			}

		}
	}

	public static class SortReduce extends Reducer<IntWritable, Text, Text, IntWritable> {
		private Text result = new Text();
		/*
		 * 由于shuffle过程是自带排序的，我们要自定义自己的Partion 和Comparator
		 * 
		 * @see org.apache.hadoop.mapreduce.Reducer#reduce(java.lang.Object,
		 * java.lang.Iterable, org.apache.hadoop.mapreduce.Reducer.Context)
		 */
		@Override
		protected void reduce(IntWritable key, Iterable<Text> values, Context context)
				throws IOException, InterruptedException {
			for (Text value : values) {
				result.set(value.toString());
				context.write(value, key);
			}

		}

	}
	
	/**
	 * partition 目的是给多个reduce使用的时候，分割数据，有时候你会看到一个reduce 输出为空
	 * @author : chenhaipeng
	 * @date : 2015年9月9日 上午12:38:54
	 */
	public static class SortPartition extends Partitioner<IntWritable, Text>{

		/* 
		 * @see org.apache.hadoop.mapreduce.Partitioner#getPartition(java.lang.Object, java.lang.Object, int)
		 */
		@Override
		public int getPartition(IntWritable key, Text value, int numPartitions) {
			//以数值大于2为一个分区
			int maxValue = 2;
			int keySection = 0; 
			//只有key 大于 maxValue 并且numPartitions 的大于2的时候才需要分区，否则直接返回0
			if(numPartitions > 1 && key.hashCode() < maxValue){
				int sectionValue = maxValue / (numPartitions -1);
				int count = 0; 
				while(key.hashCode() - sectionValue * count > sectionValue){
					count++; 
				}
				keySection = numPartitions -1 - count;
			}
			return keySection;
		}
		
	}
	
	public static class SortComparator extends WritableComparator{

		/**
		 * @param keyClass
		 */
		protected SortComparator() {
			super(IntWritable.class,true);
		}

		/* 降序
		 * @see org.apache.hadoop.io.WritableComparator#compare(org.apache.hadoop.io.WritableComparable, org.apache.hadoop.io.WritableComparable)
		 */
		@Override
		public int compare(WritableComparable a, WritableComparable b) {
			return -super.compare(a, b);
		}
		
	}
	public static void deletedir(String path){
		try {
			HDFSUtils.DeleteHDFSFile(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) throws Exception {
		//-
		File jarFile = EJob.createTempJar("bin");
//		EJob.addClasspath("D:/hadoop-1.2.1/conf/conf");
		ClassLoader classLoader = EJob.getClassLoader();
		Thread.currentThread().setContextClassLoader(classLoader);
		
		Configuration conf = new Configuration();
		String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
		if (otherArgs.length != 2) {
			System.err.println("Usage: SortWordCount <in> <out>");
			System.exit(2);
		}
		//运行在真正的集群上
		conf.set("mapred.job.tracker", "192.168.100.150:9001");
		
		Job job = new Job(conf);
		job.setJobName("SortWordCount");
		job.setJarByClass(SortWordCount.class);
		
		job.setOutputKeyClass(IntWritable.class);
		job.setOutputValueClass(Text.class);
		
		job.setMapperClass(SortMap.class);
		job.setReducerClass(SortReduce.class);
		job.setPartitionerClass(SortPartition.class);
		job.setSortComparatorClass(SortComparator.class);
		job.setNumReduceTasks(2);
		
		//-
		((JobConf) job.getConfiguration()).setJar(jarFile.toString());
		
		
		FileInputFormat.setInputPaths(job, new Path(args[0]));
		deletedir(args[1]);
		FileOutputFormat.setOutputPath(job, new Path(args[1]));
		
		System.exit(job.waitForCompletion(true)? 0 : 1);
		
		

	}

}

四、单表关联

思想：表与表之间的自连接 思路：在hadoop shuffle过程的时候会进行合并，左表parent 为key 右表child 为key

package hadoop.v5;

import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;

import org.apache.commons.lang.StringUtils;
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.mapred.JobConf;
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;

import hadoop.utils.HDFSUtils;
import hadoop.v5.Sort.IntKeyDescComparator;
import hadoop.v5.Sort.KeySectionPartitioner;
import hadoop.v5.Sort.Map;
import hadoop.v5.Sort.Reduce;

/**
 * 表与表之间的自连接 思路：在hadoop shuffle过程的时候会进行合并，左表parent 为key 右表child 为key,
 * 这样在shuffle的过程中，并自动合并表一个笛卡尔积
 * 
 * @author : chenhaipeng
 * @date : 2015年9月9日 上午1:48:20
 */
public class SelfJoin {

	public static int time = 0;

	/*
	 * Map 将输入分割成child 和parent ,然后正序输入 一次作为右表，反序输入 一次作为左表,左右表加上标记
	 */
	public static class Map extends Mapper<LongWritable, Text, Text, Text> {

		/*
		 * @see org.apache.hadoop.mapreduce.Mapper#map(java.lang.Object,
		 * java.lang.Object, org.apache.hadoop.mapreduce.Mapper.Context)
		 */
		@Override
		protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
				throws IOException, InterruptedException {
			String line = value.toString();
			if (StringUtils.isNotEmpty(line)) {
				String childName = new String();
				String parentName = new String();
				String relationType = new String();
				System.out.println(line);
				int i = 0;
				// 找出字符隔的位置
				while (line.charAt(i) != '\t') {
					i++;
				}
				String[] values = { line.substring(0, i), line.substring(i + 1) };
				// 开头的表头不处理
				if (values[0].compareTo("child") != 0) {
					childName = values[0].trim();
					parentName = values[1].trim();
					// 左右表标记
					relationType = "1";
					context.write(new Text(parentName), new Text(relationType + "+" + childName + "+" + parentName));
					relationType = "2";
					// 这样左右表在shuffle 过程中合并 在一起
					context.write(new Text(childName), new Text(relationType + "+" + childName + "+" + parentName));
				}
			}

		}

	}

	public static class Reduce extends Reducer<Text, Text, Text, Text> {

		/*
		 * @see org.apache.hadoop.mapreduce.Reducer#reduce(java.lang.Object,
		 * java.lang.Iterable, org.apache.hadoop.mapreduce.Reducer.Context)
		 */
		@Override
		protected void reduce(Text key, Iterable<Text> values, Context context)
				throws IOException, InterruptedException {
			if (time == 0) {
				context.write(new Text("grandChild"), new Text("grandParent"));
				time++;
			}
			int grandChildNum = 0;
			String[] grandChild = new String[10];
			int grandParentNum = 0;
			String[] grandParent = new String[10];
			Iterator iter = values.iterator();
			while (iter.hasNext()) {
				String record = iter.next().toString();
//				System.out.println(record);
				int len = record.length();
				int i = 2;
				if (len == 0)
					continue;
				char relationType = record.charAt(0);
				String childname = new String();
				String parnetname = new String();
				while (record.charAt(i) != '+') {
					i++;
				}
				childname = record.substring(2, i);
				parnetname = record.substring(i + 1);
//				System.out.println("childname-->"+childname);
//				System.out.println("parnetname-->"+parnetname);

				// 左表
				if (relationType == '1') {
					grandChild[grandChildNum] = childname;
					grandChildNum++;
				} else {
					grandParent[grandParentNum] = parnetname;
					grandParentNum++;
				}
			}
//			System.out.println(Arrays.asList(grandChild));
//			System.out.println(Arrays.asList(grandParent));
			// 求数组的笛卡尔积
			if (grandParentNum != 0 && grandChildNum != 0) {
				for (int m = 0; m < grandChildNum; m++) {
					for (int n = 0; n < grandParentNum; n++) {
						context.write(new Text(grandChild[m].trim()),new Text(grandParent[n].trim()));
					}
				}
			}
		}

	}

	public static void deletedir(String path) {
		try {
			HDFSUtils.DeleteHDFSFile(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

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

		Configuration conf = new Configuration();
		String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
		if (otherArgs.length != 2) {
			System.err.println("Usage: SelfJon <in> <out>");
			System.exit(2);
		}
		Job job = new Job(conf);
		job.setJarByClass(SelfJoin.class);
		job.setJobName("SelfJoin");
		job.setMapperClass(Map.class);
		job.setReducerClass(Reduce.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(Text.class);
		FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
		deletedir(args[1]);
		FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
		System.exit(job.waitForCompletion(true) ? 0 : 1);

	}

}

输入 为： 

child	parent
Tom		Lucy
Tom		Jack
Jone	Lucy
Lucy	Marry
Lucy	Ben
Jack	Alice
Jack	Jesse
Terry	Alice
Terry	Jesse
Philip	Terry
Philip	Alma
Mark	Terry
Mark	Alma


五、多表关联

思想：与单表关联相似，要提前指定好那个是左表，那个是右表

核心 ： 

			//找出数据的分割点
			while(line.charAt(i) >= '9' || line.charAt(i) <= '0'){
				i++;
			}
			
			//代表的是左表
			if(line.charAt(0)>= '9' || line.charAt(0) <= '0'){
				int j = i-1; 
				while(line.charAt(j) != ' ')j--;
				String[] values = {line.substring(0,j),line.substring(i)};
				context.write(new Text(values[1].trim()), new Text("1+"+values[0]));
			}else{
				int j = i+1;
				while(line.charAt(j) != ' ')j++;
				String[] values = {line.substring(0,i+1),line.substring(j)};
				context.write(new Text(values[0].trim()), new Text("2+"+values[1]));
			}

代码：

package hadoop.v5;

import java.io.IOException;
import java.util.Iterator;

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.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;

import hadoop.utils.HDFSUtils;

/**
 * 多表连接，类似自连接
 * @author : chenhaipeng
 * @date : 2015年9月10日 上午12:33:26
 */
public class MTJoin {
	
	public static int time = 0; 
	
	public static class Map extends Mapper<LongWritable, Text, Text, Text>{

		/* 
		 * @see org.apache.hadoop.mapreduce.Mapper#map(java.lang.Object, java.lang.Object, org.apache.hadoop.mapreduce.Mapper.Context)
		 */
		@Override
		protected void map(LongWritable key, Text value, Context context)throws IOException, InterruptedException {
			String line = value.toString();
			int i = 0; 
			if(line.contains("factoryname") == true || line.contains("addressID") == true){
				return;
			}
			//找出数据的分割点
			while(line.charAt(i) >= '9' || line.charAt(i) <= '0'){
				i++;
			}
			
			//代表的是左表
			if(line.charAt(0)>= '9' || line.charAt(0) <= '0'){
				int j = i-1; 
				while(line.charAt(j) != ' ')j--;
				String[] values = {line.substring(0,j),line.substring(i)};
				context.write(new Text(values[1].trim()), new Text("1+"+values[0]));
			}else{
				int j = i+1;
				while(line.charAt(j) != ' ')j++;
				String[] values = {line.substring(0,i+1),line.substring(j)};
				context.write(new Text(values[0].trim()), new Text("2+"+values[1]));
			}
			
			
		}
		
	}
	
	public static class Reduce extends Reducer<Text, Text, Text, Text>{

		/* 
		 * @see org.apache.hadoop.mapreduce.Reducer#reduce(java.lang.Object, java.lang.Iterable, org.apache.hadoop.mapreduce.Reducer.Context)
		 */
		@Override
		protected void reduce(Text text, Iterable<Text> values, Context context)
				throws IOException, InterruptedException {
			if(time == 0){
				context.write(new Text("factoryname"), new Text("addressname"));
				time++;
			}
			int factorynum = 0; 
			String factory[] = new String[10];
			int addressnum  = 0; 
			String address[] = new String[10];
			Iterator iter = values.iterator();
			while(iter.hasNext()){
				String record = iter.next().toString();
				int len = record.length();
				int i = 2;
				char type = record.charAt(0);
				String factoryname = new String();
				String addressname = new String();
				if(type == '1' ){	//左表
					factory[factorynum] = record.substring(2);	
					factorynum++;
				}else{		//右表
					address[addressnum] = record.substring(2);
					addressnum++;
				}
			}
			//
			if(factorynum != 0 && addressnum!= 0){
				for(int m = 0; m < factorynum; m++){
					for(int n = 0; n < addressnum; n++){
						context.write(new Text(factory[m]), new Text(address[n]));
					}
				}
			}
			
		
		}
		
	}
	public static void deletedir(String path) {
		try {
			HDFSUtils.DeleteHDFSFile(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
		if (otherArgs.length != 2) {
			System.err.println("Usage: MTJoin <in> <out>");
			System.exit(2);
		}
		Job job = new Job(conf);
		job.setJarByClass(MTJoin.class);
		job.setJobName("MTJoin");
		job.setMapperClass(Map.class);
		job.setReducerClass(Reduce.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(Text.class);
		FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
		deletedir(args[1]);
		FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
		System.exit(job.waitForCompletion(true) ? 0 : 1);

	}

}

输入为：

factoryname addressed
Beijing	Red Star 1

addressID addressname
1 Beijing




holo_hai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据Hadoop学习(4)-MapReduce经典案例-单词统计
LoongKK的博客
05-04 2203
大数据Hadoop学习(4)-MapReduce经典案例-单词统计 MapReduce单词统计案例（分别使用样例带的jar包和自己编写代码实现的jar包运行） 1. Hadoop经典案例——单词统计 1） 打开HDFS的UI界面，选择Utilities-Browse the file system可查看文件系统里的文件。使用-cat也可。 2） 准备文本文件，执行vi word.txt指令新建...
Hadoop学习(四)Mapreduce实例
cuibin1991的专栏
09-02 251
首先需要修改配置文件，修改yarn-site.xml，配置如下： <configuration> <property> <name>yarn.resourcemanager.hostname</name> <value>localhost</value> </propert...
Hadoop学习笔记(4)——MapReduce的一些案例
weixin_44898959的博客
01-21 323
一、流量统计 首先给出元数据表 这是一张手机流量统计表 需求一: 统计求和 统计每个手机号的上行数据包总和，下行数据包总和，上行总流量之和，下行总流量之和。 分析：以手机号码作为key值，上行流量，下行流量，上行总流量，下行总流量四个字段作为value值，然后以这个key，和value作为map阶段的输出，reduce阶段的输入 step 1:创建javaBean用于封装数据 public class FlowBean implements Writable { private Integer
hadoop：hdfs：HdfsUtil
不花的花和尚的博客
07-28 982
NoClassDefFoundError: org/apache/hadoop/crypto/key/KeyProviderTokenIssuer
Hadoop之HDFS的使用
郭龙飞的学习博客
02-20 2021
目录 HDFS介绍 HDFS基础操作 Java操作HDFS HDFS介绍 HDFS 是一种允许文件通过网络在多台主机上分享的文件系统，可以让多台机器上的多个用户分享文件和存储空间。 分布式文件管理系统有很多，HDFS 只是其中一种实现 注意：HDFS 不适合存储小文件（几KB或几M的小文件） HDFS基础操作 操作格式 hdfs dfs -xxx schema: // authority / path -xxx : 命令（读、写、创建、查看等） schema ：hdfs authority ：地
hadoop权威指南第四版高清 pdf下载
11-18
《Hadoop权威指南》第四版是Hadoop领域的经典著作，由Tom White撰写，该书深入浅出地介绍了Hadoop生态系统的核心技术和应用场景。这本书对于想要理解、学习和掌握Hadoop技术的人来说，具有极高的参考价值。 Hadoop...
hadoop权威指南合集第四版
10-30
《Hadoop权威指南》第四版是一本全面介绍Hadoop生态系统及其相关技术的书籍，适合对分布式计算和大数据处理感兴趣的初学者。这本书详细讲解了Hadoop的设计理念、核心组件以及实际应用，旨在帮助读者深入理解Hadoop的...
hadoop权威指南第四版英文原版
05-20
《Hadoop权威指南》第四版英文原版是大数据领域中一本极为重要的参考书籍，它深入浅出地介绍了Apache Hadoop生态系统的核心概念和技术。Hadoop是一个开源的分布式计算框架，最初由Doug Cutting和Mike Cafarella创建...
Hadoop中MapReduce基本案例及代码（四）
01-07
如果想将mapreduce结果排序，需将排序对象作为键值。 案例：将利润求和后按照顺序排序 数据源 profit.txt 编号 | 姓名 | 收入 | 支出 1 ls 2850 100 2 ls 3566 200 3 ls 4555 323 1 zs 19000 2000 2 zs 28599 3900 3...
Hadoop原理与技术MapReduce实验
05-24
（1）熟悉Hadoop开发包 （2）编写MepReduce程序 （3）调试和运行MepReduce程序 （4）完成上课老师演示的内容 二、实验环境 Windows 10 VMware Workstation Pro虚拟机 Hadoop环境 Jdk1.8 二、实验内容 1.单词计数实验...
Hadoop学习之HDFS的相关操作
iMonster
08-27 182
以下是使用Hadoop2.4.1的JAVA API进行HDFS的相关操作 import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream;...
MapReduce编程练习
qq_60317308的博客
11-12 2095
目录 编程实现按日期统计访问次数 2.编程实现按访问次数排序 获取成绩表最高分 编译jar'包方法 编程实现按日期统计访问次数 (1) 定义输入/输出格式 社交网站用户的访问日期在格式上属于文本格式，访问次数为整型数值格式。其组成的键值对为<访问日期，访问次数>，因此Mapper的输出与Reducer的输出都选用Text类与IntWritable类。 (2)Mapper 类的逻辑实现 ...
java连接cdh集群_0553-6.1.0-如何使用Java代码同时访问安全和非安全CDH集群
weixin_39598472的博客
02-25 607
温馨提示：如果使用电脑查看图片不清晰，可以使用手机打开文章单击文中的图片放大查看高清原图。Fayson的github：https://github.com/fayson/cdhproject提示：代码块部分可以左右滑动查看噢1文档编写目的做Hadoop应用开发的过程中，用户会有这样的需求，在同一个Java应用中同时访问安全和非安装的CDH集群。同一个Java应用即同一个进程同一个JVM，由于一些全...
深入理解Arrays.sort()
weixin_34253539的博客
11-16 889
翻译人员: 铁锚 翻译日期: 2013年11月16日 原文链接:Deep Understanding of Arrays.sort(T[], Comparator < ? super T > c) Arrays.sort(T[], Comparator < ? super T > c) 方法用于对象数组按用户自定义规则排序. 官方Java文档只是简...
comparator接口与Comparable接口的区别
blastbaobao的专栏
10-19 494
comparator接口与Comparable接口的区别 1. Comparator 和 Comparable 相同的地方 他们都是java的一个接口, 并且是用来对自定义的class比较大小的, 什么是自定义class: 如 public class Person{ String name; int age }. 当我们有这么一个personList,里面包含了person1, pe
mapreduce程序中避免reduce输出空文件
Rollerqing的博客
05-28 2907
从埋点日志获取select结果，维度比较多，union了好多次，因为源表没有符合条件数据，跑出来没有结果，null都没有， 但是看hdfs上该表的指定目录，发现该分区含有几十个空文件，上网找到了原因： 在mapreduce里，如果某个reduce输出为空，默认也会生成一个大小为0的文件。原因是reduce写的时候，不知道会不会有输出数据，所以默认初始化了一个文件。如果没有输出，close文件最终会生成一个空文件。 ps：explain了一下发现 很多reduce 还有group 61正好对应分区下的61个空
Arrays.sort和Collections.sort实现原理解析
热门推荐
一年e度的夏天的专栏
02-23 5万+
title: Array.sort和Collections.sort实现原理解析 date: 2017-02-13 19:22:01 tags: java基础 Arrays.sort和Collections.sort实现原理解析 1、使用 排序 2、原理 事实上Collections.sort方法底层就是调用的array.sort方法，而且不论是Collect...
Ubuntu常用命令大全
cxianf
07-17 1840
Ubuntu常用命令大全 查看软件xxx安装内容#dpkg -L xxx 查找软件#apt-cache search 正则表达式查找文件属于哪个包#dpkg -S filename apt-file search filename 查询软件xxx依赖哪些包#apt-cache depends xxx 查询软件xxx被哪些包依赖#apt-cache rdepends xxx 增加一个光盘...
intel-hadoop/HiBench流程分析----以贝叶斯算法为例
shiter编写程序的艺术
10-23 4675
1.HiBench算法简介Hibench 包含9个典型的hadoop负载（micro benchmarks,hdfs benchmarks,web search bench marks,machine learning benchmarks和data analytics benchmarks）具体参考CDH集群安装&测试总结：第三节内容 micro benchmarks Sort:使用hadoop
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值