MapReduce经典案例 ------- 学生成绩处理

于 2018-11-09 08:52:23 发布
阅读量3.7k 收藏 58
点赞数 3
分类专栏： Java MapReduce HDFS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Z_Date/article/details/83860743
版权
MapReduce 同时被 3 个专栏收录
32 篇文章 0 订阅
订阅专栏
Java
30 篇文章 0 订阅
订阅专栏
HDFS
16 篇文章 1 订阅
订阅专栏

目录

算每个人的平均成绩

求每个学科的平均成绩

总平均分每个分数段的人数以及百分比

将三门课程中任意一门不及格的学生过滤出来

统计成材率

每一门成绩都大于60分的人数/总人数

待处理数据内容：

学生成绩表
名字语文数学英语
lh926870
zyt948875
ls967878
hgw907056
yxx808873
hz909870
xyd608873
hj905870
cs505811

算每个人的平均成绩

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

public class AvgDemo {
	//自定义myMapper
		public static class MyMapper extends Mapper<LongWritable, Text, Text, Text>{
			//只在map方法运行之前执行一次。(仅执行一次)
			@Override
			protected void setup(Context context)
					throws IOException, InterruptedException {
			}
			
			Text k = new Text();
			Text v = new Text();
			
			@Override
			protected void map(LongWritable key, Text value,Context context)
					throws IOException, InterruptedException {
				String line = value.toString();
				String [] scores = line.split("\t");
				String name = scores[0];
				String chinese = scores[1];
				String math = scores[2];
				String english = scores[3];
				double avg = (Integer.parseInt(chinese) + Integer.parseInt(math) + 
						Integer.parseInt(english)) / ((scores.length-1)*1.0);
				k.set(name);
				v.set(avg+"");
				context.write(k,v);
				
			}
			
			//map方法运行完后执行一次(仅执行一次)
			@Override
			protected void cleanup(Context context)
					throws IOException, InterruptedException {
			}
		}
		/*
		//自定义myReducer
		public static class MyReducer extends Reducer<Text, Text, Text, Text>{
			//在reduce方法执行之前执行一次。(仅一次)
			@Override
			protected void setup(Context context)
					throws IOException, InterruptedException {
			}

			@Override
			protected void reduce(Text key, Iterable<Text> value,Context context)
					throws IOException, InterruptedException {
			}
			//在reduce方法执行之后执行一次。(仅一次)
			@Override
			protected void cleanup(Context context)
					throws IOException, InterruptedException {
			}
		}
		*/
		/**
		 * job的驱动方法
		 * @param args
		 */
		public static void main(String[] args) {
			try {
				//1、获取Conf
				Configuration conf = new Configuration();
				//2、创建job
				Job job = Job.getInstance(conf, "model01");
				//3、设置运行job的class
				job.setJarByClass(AvgDemo.class);
				//4、设置map相关属性
				job.setMapperClass(MyMapper.class);
				job.setMapOutputKeyClass(Text.class);
				job.setMapOutputValueClass(Text.class);
				FileInputFormat.addInputPath(job, new Path(args[0]));
				
				//5、设置reduce相关属性
				/*job.setReducerClass(MyReducer.class);
				job.setOutputKeyClass(Text.class);
				job.setOutputValueClass(Text.class);*/
				FileOutputFormat.setOutputPath(job, new Path(args[1]));
				
				//6、提交运行job
				int isok = job.waitForCompletion(true) ? 0 : 1;
				
				//退出
				System.exit(isok);
				
			} catch (IOException | ClassNotFoundException | InterruptedException e) {
				e.printStackTrace();
			}
		}
}

求每个学科的平均成绩

import java.io.IOException;
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;
/**
每个学科的平均成绩？
语文	数学	英语
76	89	90
 * @author lyd
 *
 */
public class AvgDemo02 {
	//自定义myMapper
		public static class MyMapper extends Mapper<LongWritable, Text, Text, Text>{
			//只在map方法运行之前执行一次。(仅执行一次)
			@Override
			protected void setup(Context context)
					throws IOException, InterruptedException {
			}
			
			Text k = new Text();
			Text v = new Text();
			@Override
			protected void map(LongWritable key, Text value,Context context)
					throws IOException, InterruptedException {
				String line = value.toString();
				String scores [] = line.split("\t");
				String chinese = scores[1];
				String math = scores[2];
				String english = scores[3];
				k.set("_");
				v.set(chinese+"_"+math+"_"+english);
				context.write(k, v);
			}
			
			//map方法运行完后执行一次(仅执行一次)
			@Override
			protected void cleanup(Context context)
					throws IOException, InterruptedException {
			
			}
		}
		
		//自定义myReducer
		public static class MyReducer extends Reducer<Text, Text, Text, Text>{
			//在reduce方法执行之前执行一次。(仅一次)
			@Override
			protected void setup(Context context)
					throws IOException, InterruptedException {
				context.write(new Text("语文"+"\t"+"数学"+"\t"+"英语"), new Text(""));
			}

			@Override
			protected void reduce(Text key, Iterable<Text> value,Context context)
					throws IOException, InterruptedException {
				int counter = 0;
				double c = 0;
				double m = 0;
				double e = 0;
				for (Text t : value) {
					String scores [] =  t.toString().split("_");
					c += Double.parseDouble(scores[0]);
					m += Double.parseDouble(scores[1]);
					e += Double.parseDouble(scores[2]);
					counter ++;
				}
				context.write(new Text(c/counter+"\t"+m/counter+"\t"+e/counter), new Text(""));
			
			}
			//在reduce方法执行之后执行一次。(仅一次)
			@Override
			protected void cleanup(Context context)
					throws IOException, InterruptedException {
			}
		}
		
		/**
		 * job的驱动方法
		 * @param args
		 */
		public static void main(String[] args) {
			try {
				//1、获取Conf
				Configuration conf = new Configuration();
				//2、创建job
				Job job = Job.getInstance(conf, "model01");
				//3、设置运行job的class
				job.setJarByClass(AvgDemo02.class);
				//4、设置map相关属性
				job.setMapperClass(MyMapper.class);
				job.setMapOutputKeyClass(Text.class);
				job.setMapOutputValueClass(Text.class);
				FileInputFormat.addInputPath(job, new Path(args[0]));
				
				//5、设置reduce相关属性
				job.setReducerClass(MyReducer.class);
				job.setOutputKeyClass(Text.class);
				job.setOutputValueClass(Text.class);
				FileOutputFormat.setOutputPath(job, new Path(args[1]));
				
				//6、提交运行job
				int isok = job.waitForCompletion(true) ? 0 : 1;
				
				//退出
				System.exit(isok);
				
			} catch (IOException | ClassNotFoundException | InterruptedException e) {
				e.printStackTrace();
			}
		}
}

总平均分每个分数段的人数以及百分比

各阶段成绩所占百分比
分数段人数占总数的百分比
<6018%
60-70216%
70-80533%
80-90216%
90-100328%
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

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;
/**
<60	1 8%
60-70 2 %16
70-80 5 33%
80-90 2 16%
90-100 3 28%
 * @author lyd
 *
 */
public class AvgDemo03 {
	//static int counter = 0;
		//自定义myMapper
		public static class MyMapper extends Mapper<LongWritable, Text, Text, Text>{
			//只在map方法运行之前执行一次。(仅执行一次)
			@Override
			protected void setup(Context context)
					throws IOException, InterruptedException {
			}
			
			Text k = new Text();
			Text v = new Text();
			@Override
			protected void map(LongWritable key, Text value,Context context)
					throws IOException, InterruptedException {
				String line = value.toString();
				String scores [] = line.split("\t");
				String chinese = scores[1];
				String math = scores[2];
				String english = scores[3];
				double avg = (Double.parseDouble(chinese) + Double.parseDouble(math) 
						+ Double.parseDouble(english))/(scores.length-1);
				//判断
				if(avg < 60){
					k.set("<60");
					v.set("1");
				} else if(avg >= 60 && avg < 70){
					k.set("60-70");
					v.set("1");
				} else if(avg >= 70 && avg < 80){
					k.set("70-80");
					v.set("1");
				} else if(avg >= 80 && avg < 90){
					k.set("80-90");
					v.set("1");
				} else if(avg >= 90 && avg <= 100){
					k.set("90-100");
					v.set("1");
				} 
				//context.getConfiguration().setInt("counter", counter);
				context.write(k, v);
			}
			
			//map方法运行完后执行一次(仅执行一次)
			@Override
			protected void cleanup(Context context)
					throws IOException, InterruptedException {
			
			}
		}
		
		//自定义myReducer
		public static class MyReducer extends Reducer<Text, Text, Text, Text>{
			//在reduce方法执行之前执行一次。(仅一次)
			@Override
			protected void setup(Context context)
					throws IOException, InterruptedException {
				context.write(new Text("分数段"), new Text("人数"+"\t"+"百分比"));
			}

			int totalPerson = 0;
			/*int l6 = 0;
			int g6l7 = 0;
			int g7l8 = 0;
			int g8l9 = 0;
			int g9l10 = 0;*/
			
			List<String> li = new ArrayList<String>();
			@Override
			protected void reduce(Text key, Iterable<Text> value,Context context)
					throws IOException, InterruptedException {
				/**
				 * <60 list(1,1)
				 */
				int i = 0;
				for (Text t : value) {
					if(key.toString().equals("<60")){
						//l6 ++;
						i ++ ;
					} else if (key.toString().equals("60-70")){
						//g6l7 ++;
						i ++ ;
					}  else if (key.toString().equals("70-80")){
						//g7l8 ++ ;
						i ++ ;
					}  else if (key.toString().equals("80-90")){
						//g8l9 ++;
						i ++ ;
					}  else if (key.toString().equals("90-100")){
						//g9l10 ++;
						i ++ ;
					} 
					totalPerson ++ ;
				}
				li.add(key.toString()+"_"+i);
				//context.getConfiguration().get("counter");
			}
			//在reduce方法执行之后执行一次。(仅一次)
			@Override
			protected void cleanup(Context context)
					throws IOException, InterruptedException {
				for (String s : li) {
					String l [] = s.split("_");
					context.write(new Text(l[0]), new Text(l[1]+"\t"+Double.parseDouble(l[1])/totalPerson*100+"%"));
				}
			}
		}
		
		/**
		 * job的驱动方法
		 * @param args
		 */
		public static void main(String[] args) {
			try {
				//1、获取Conf
				Configuration conf = new Configuration();
				//2、创建job
				Job job = Job.getInstance(conf, "model01");
				//3、设置运行job的class
				job.setJarByClass(AvgDemo03.class);
				//4、设置map相关属性
				job.setMapperClass(MyMapper.class);
				job.setMapOutputKeyClass(Text.class);
				job.setMapOutputValueClass(Text.class);
				FileInputFormat.addInputPath(job, new Path(args[0]));
				
				//5、设置reduce相关属性
				job.setReducerClass(MyReducer.class);
				job.setOutputKeyClass(Text.class);
				job.setOutputValueClass(Text.class);
				FileOutputFormat.setOutputPath(job, new Path(args[1]));
				
				//6、提交运行job
				int isok = job.waitForCompletion(true) ? 0 : 1;
				
				//退出
				System.exit(isok);
				
			} catch (IOException | ClassNotFoundException | InterruptedException e) {
				e.printStackTrace();
			}
		}
}

将三门课程中任意一门不及格的学生过滤出来


import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

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;
/**
将三门课程中任意一门不及格的学生过滤出来？
 * @author lyd
 *
 */
public class GrepDemo {
	//static int counter = 0;
		//自定义myMapper
		public static class MyMapper extends Mapper<LongWritable, Text, Text, Text>{
			//只在map方法运行之前执行一次。(仅执行一次)
			@Override
			protected void setup(Context context)
					throws IOException, InterruptedException {
			}
			
			Text k = new Text();
			Text v = new Text();
			@Override
			protected void map(LongWritable key, Text value,Context context)
					throws IOException, InterruptedException {
				String line = value.toString();
				String scores [] = line.split("\t");
				String chinese = scores[1];
				String math = scores[2];
				String english = scores[3];
				if(Double.parseDouble(chinese) < 60 || Double.parseDouble(math) < 60 || Double.parseDouble(english) < 60){
					context.write(value, new Text(""));
				}
			}
			
			//map方法运行完后执行一次(仅执行一次)
			@Override
			protected void cleanup(Context context)
					throws IOException, InterruptedException {
			
			}
		}
		
		/**
		 * job的驱动方法
		 * @param args
		 */
		public static void main(String[] args) {
			try {
				//1、获取Conf
				Configuration conf = new Configuration();
				//2、创建job
				Job job = Job.getInstance(conf, "model01");
				//3、设置运行job的class
				job.setJarByClass(GrepDemo.class);
				//4、设置map相关属性
				job.setMapperClass(MyMapper.class);
				job.setMapOutputKeyClass(Text.class);
				job.setMapOutputValueClass(Text.class);
				FileInputFormat.addInputPath(job, new Path(args[0]));
				
				//5、设置reduce相关属性
				FileOutputFormat.setOutputPath(job, new Path(args[1]));
				
				//6、提交运行job
				int isok = job.waitForCompletion(true) ? 0 : 1;
				
				//退出
				System.exit(isok);
				
			} catch (IOException | ClassNotFoundException | InterruptedException e) {
				e.printStackTrace();
			}
		}
}

统计成材率

每一门成绩都大于60分的人数/总人数

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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;
/**
统计成材率？每一门成绩都大于60分的人数/总人数
成材率 88%
留级率 12%
 * @author lyd
 *
 */
public class SuccessDemo {
	//static int counter = 0;
		//自定义myMapper
		public static class MyMapper extends Mapper<LongWritable, Text, Text, Text>{
			//只在map方法运行之前执行一次。(仅执行一次)
			@Override
			protected void setup(Context context)
					throws IOException, InterruptedException {
			}
			
			@Override
			protected void map(LongWritable key, Text value,Context context)
					throws IOException, InterruptedException {
				String line = value.toString();
				String scores [] = line.split("\t");
				String chinese = scores[1];
				String math = scores[2];
				String english = scores[3];
				if(Double.parseDouble(chinese) >= 60 && Double.parseDouble(math) >= 60 && Double.parseDouble(english) >= 60){
					context.write(new Text("up"), new Text("1"));
				} else {
					context.write(new Text("down"), new Text("1"));
				}
				
				
			}
			
			//map方法运行完后执行一次(仅执行一次)
			@Override
			protected void cleanup(Context context)
					throws IOException, InterruptedException {
			
			}
		}
		
		//自定义myReducer
		public static class MyReducer extends Reducer<Text, Text, Text, Text>{
			//在reduce方法执行之前执行一次。(仅一次)
			@Override
			protected void setup(Context context)
					throws IOException, InterruptedException {
				context.write(new Text("分数段"), new Text("人数"+"\t"+"百分比"));
			}

			int totalPerson = 0;
			int u = 0;
			@Override
			protected void reduce(Text key, Iterable<Text> value,Context context)
					throws IOException, InterruptedException {
				for (Text t : value) {
					if(key.toString().equals("up")){
						u ++;
					}
					totalPerson ++;
				}
			}
			//在reduce方法执行之后执行一次。(仅一次)
			@Override
			protected void cleanup(Context context)
					throws IOException, InterruptedException {
				context.write(new Text("成才率"), new Text(u*100.0/totalPerson+"%"));
				context.write(new Text("留级率"), new Text((totalPerson-u)*100.0/totalPerson+"%"));
			}
		}
		
		/**
		 * job的驱动方法
		 * @param args
		 */
		public static void main(String[] args) {
			try {
				//1、获取Conf
				Configuration conf = new Configuration();
				conf.set("fs.defaultFS", "hdfs://hadoop01:9000");
				//2、创建job
				Job job = Job.getInstance(conf, "model01");
				//3、设置运行job的class
				job.setJarByClass(SuccessDemo.class);
				//4、设置map相关属性
				job.setMapperClass(MyMapper.class);
				job.setMapOutputKeyClass(Text.class);
				job.setMapOutputValueClass(Text.class);
				FileInputFormat.addInputPath(job, new Path(args[0]));
				
				//5、设置reduce相关属性
				job.setReducerClass(MyReducer.class);
				job.setOutputKeyClass(Text.class);
				job.setOutputValueClass(Text.class);
				//判断输出目录是否存在，若存在则删除
				FileSystem fs = FileSystem.get(conf);
				if(fs.exists(new Path(args[1]))){
					fs.delete(new Path(args[2]), true);
				}
				FileOutputFormat.setOutputPath(job, new Path(args[1]));
				
				//6、提交运行job
				int isok = job.waitForCompletion(true) ? 0 : 1;
				
				//退出
				System.exit(isok);
				
			} catch (IOException | ClassNotFoundException | InterruptedException e) {
				e.printStackTrace();
			}
		}
}

 

 

Z_Data
关注
专栏目录
博客
面向对象程序设计——第3章 案例
08-06 1122
用户通过键盘输入一个整数值，判断该数值是否为“水仙花数”。“水仙花数”是指一个3位数，其各位数的三次方和等于该数本身。例如：水仙花例如: 153是一个“水仙花数”，因为本案例程序运行的结果如图本案例的实现过程应满足以下要求。
博客
面向对象程序设计——单元3 流程控制与数组
08-06 535
程序设计的流程控制主要包括3种结构：顺序结构、选择结构和循环结构。其中，选择结构根据给定条件的判断结果来控制程序的流程，而循环结构可以减少重复书写代码的工作量，用来描述重复执行某段算法的问题，这是程序设计中最能发挥计算机特长的程序结构。优良的程序控制结构需要和合适的数据组织形式搭配使用，才能提升程序的运行效能，数组就是一种最常用的数据组织结构。本单元将介绍Java灵活、高效的选择结构、循环结构以及Java独特的数组结构。
博客
面向对象程序设计——单元2 Java语言基础
07-05 640
构成程序的最基本元素包括变量、常量和语句等。变量是指程序运行过程中其值可以被改变的量，比如表示不同班级学生平均成绩的变量；常量则是指程序运过程中，值不会发生变化的量，比如最常见的圆周率。无论是变量还是常量，在使用之前都要先为它们指定一个名字。而语句则是组成一段程序的最基本单元。本单元主要介绍 Java 的基本语法，包括标识符、保留字、变量、常量、数据类型、运算符和表达式等。
博客
面向对象程序设计——Java语言基础
06-25 861
构成程序的最基本元素包括变量、常量和语句等。变量是指程序运行过程中其值可以被改变的量，比如表示不同班级学生平均成绩的变量；常量则是指程序运过程中，值不会发生变化的量，比如最常见的圆周率。无论是变量还是常量，在使用之前都要先为它们指定一个名字。而语句则是组成一段程序的最基本单元。
博客
Ubuntu Linux操作系统——项目7 Shell编程基础
06-21 1040
​ 在Linux操作系统环境中，Shell不仅是常用的命令解释程序，还是高级编程语言。​ 用户可以通过编写Shell程序来完成大量自动化的任务。​ Shell可以互动地解释和执行用户输入的命令，也可以用来进行程序设计，它提供了定义变量和参数的手段以及丰富的程序控制结构。
博客
Ubuntu Linux操作系统——项目6 软件包安装配置与管理
06-14 795
在系统的使用和维护过程中，安装和卸载软件是必须掌握的技能。​ Linux软件的安装需要考虑软件的依赖性问题，目前在Linux系统上安装软件已经变得与Windows系统上一样便捷。​ 可供Linux安装的开源软件非常丰富，Linux提供多种软件安装方式，从最原始的源码编译到最高级的在线自动安装和更新。​ 在简单介绍Linux软件包管理知识的基础上，重点讲解Ubuntu系统的软件安装方式和方法，除了传统的Deb软件包安装，还讲解APT高级软件包工具以及Snap软件包安装，这种方式提供更好的隔离性和安全性
博客
Ubuntu Linux操作系统——项目5 系统高级配置与管理
04-25 932
进程：Linux系统上所有运行的任务都可以称之为一个进程，每个用户任务、每个应用程序或服务也都可以称之为进程，Ubuntu也不例外。对于管理员来说，没有必要关心进程的内部机制，而是要关心进程的控制管理。管理员应经常查看系统运行的进程服务，对于异常和不需要的进程，应及时将其结束，让系统更加稳定地运行。
博客
Ubuntu Linux操作系统——项目4 磁盘配置与管理
04-20 1503
对于任何一个通用操作系统而言，磁盘管理与文件管理都是必不可少的功能，因此，Linux操作系统提供了非常强大的磁盘与文件管理功能。Linux操作系统的管理员应掌握配置和管理磁盘的技巧，高效地对磁盘空间进行使用和管理。如果Linux服务器有多个用户经常存取数据，则为了有效维护用户数据的安全性与可靠性，应配置逻辑卷及RAID管理。本章主要讲解了磁盘管理、磁盘挂载与卸载、磁盘管理其他相关命令、配置管理逻辑卷以及RAID管理。
博客
Ubuntu Linux操作系统——项目3 用户群组与文件目录权限管理
04-19 1747
Ubuntu Linux是一个多用户、多任务的操作系统，可以让多个用户同时使用系统。为了保证用户之间的独立性，允许用户保护自己的资源不被非法访问，用户之间可以共享信息和文件，也允许用户分组工作，对不同的用户分配不同的权限，使每个用户都能各自不受干扰地独立工作，因此，作为系统的管理员，掌握系统配置、用户权限设置与管理、文件和目录的权限设置是至关重要的。本章主要讲解了用户账户、组群管理、su和sudo命令的使用以及文件和目录权限管理。
博客
Ubuntu Linux操作系统——项目2 Linux基本操作命令
04-18 857
Linux操作系统的Shell作为操作系统的外壳，为用户提供使用操作系统的接口。它是命令语言、命令解释程序及程序设计语言的统称。Shell是用户和Linux内核之间的接口程序，如果把Linux内核想象成一个球体的中心，Shell就是围绕内核的外层。当从Shell或其他程序向Linux传递命令时，内核会做出相应的反应。Shell是一个命令语言解释器，它拥有自己内建的Shell命令集，Shell也能被系统中的其他应用程序所调用。用户在提示符下输入的命令都先由Shell解释再传给Linux核心。
博客
搭建Java开发环境
04-17 910
JDK 基本介绍JDK 的全称(Java Development Kit Java 开发工具包)JDK = JRE + java 的开发工具 [java, javac,javadoc,javap 等]JDK 是提供给 Java 开发人员使用的，其中包含了 java 的开发工具，也包括了 JRE。所以安装了 JDK，就不用在单独安装 JRE 了。JRE 基本介绍JRE(Java Runtime Environment Java 运行环境)JRE = JVM + Java 的核心类库[类]
博客
Ubuntu Linux操作系统——项目1 Ubuntu安装与基本操作
04-17 4450
选项，进入下一步。选择 硬件兼容性，这里选择默认的。
博客
Spark运行架构
04-12 961
Spark Core包含Spark最基础和最核心的功能，当提及Spark运行架构时，就是指Spark Core的运行架构。本节首先介绍Spark的基本概念和架构设计，然后介绍Spark运行基本流程，最后介RDD 的设计与运行原理。
博客
Hadoop分布式计算框架（MapReduce）——案例实践：气象大数据离线分析
12-21 1671
数据格式由Year(年)、Month(月)、Day(日)、Hour(时)、Temperature(气温)、Dew(湿度)、Pressure(气压)、Wind dir.(风向)、Wind speed(风速)、Sky Cond.(天气状况)、Rain 1h(每小时降雨量)、Rain 6h(每6小时降雨量)组成。打包成功后，在项目的targer目录下找到编译好的bigdata-1.0-SNAPSHOT.jar包，然后将其上传至/home/hadoop/shell/lib目录下（没有相关目录可手动创建）
博客
Hadoop分布式计算框架（MapReduce）——MapReduce运行机制
12-21 179
它首先为Map任务发出请求，该请求优先级要高于Reduce任务的请求，这是因为所有的Map任务必须在Reduce的排序阶段能够启动前完成，直到有5%的Map任务已经完成时，为Roduce任务的请求才会发出。在Map任务和Reduce任务运行时，子进程和自己的父Application Master通过接口进行通信，默认每隔3s，任务通过这个接口向自己的Application Master报告进度和状态(包括计数器)， Application Master会形成一个作业的汇聚视图。
博客
Hadoop分布式计算框架（MapReduce）—— MapReduce的编程模型
12-21 483
从MapReduce自身的命名特点可以看出，MapReduce由Map和Reduce两个部分组成。用户只需实现Mapper和Reducer两个抽象类，编写map和reduce两个函数，即可完成简单的分布式程序的开发。这就是最简单的MapReduce编程模型。
博客
Hadoop分布式计算框架（MapReduce）——初识MapReduce
12-21 202
MapReduce 是一个使用简单的软件框架，基于它写出来的应用程序能够运行在由上千个商用机器组成的大型集群上，并以一种可靠容错式并行处理TB级别的数据集。MapReduce是一个并行程序的计算模型与方法MapReduce是一个并行程序运行的软件框架MapReduce是一个基于集群的高性能并行计算平台。
博客
案例实践：YARN调度器的配置与使用
09-28 544
以Hadoop自带的WordCount为例，操作演示公平调度器的配置与使用。
博客
YARN的调度器
09-28 377
理想情况下，YARN应用发出的资源请求应该立刻给予满足，然而在现实中，资源是有限的。在一个繁忙的集群上，一个应用经常需要等待才能得到所需要的资源。YARN调度器的工作就是根据既定策略为应用分配资源。
博客
YARN的高可用
09-28 284
HA表示高可用，YARN的HA主要指ResourceManager的HA，因为ResourceManager作为主节点存在单点故障，所以要通过HA的方式解决ResourceManager单点故障问题。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值