MapReduce自定义序列化对象

任务

1原始数据中一行内容为一个学生的考试成绩信息，主要包括学号和成绩（第一个字段为学号，其余的都是这个同学的分数，可能有多个分数，用空格隔开）。
1001 85 87 91 93 85 77
1002 88 85 87
1003 78 73 83 88
1004 76 65
1005 73 91 86 88
根据上面的数据发现，每个学生的考试次数不一样，譬如学号1001的同学有6次成绩，而学号1002的同学只有3次成绩。
需要你编写Mapredcue程序，用自定义序列化对象的方式计算每个同学的考试次数和平均分，即输出字段有三个，分别为学号、考试次数、平均分
输出结果为：
1001 6 86
1002 3 86
1003 4 80
1004 2 70
1005 4 84

2 将上一题的输出结果作为原始数据，也就是说字段为学号、考试次数、平均分。请编写mapreduce程序实现数据的排序功能，排序规则为先按照平均分从小到大的顺序排序，如果平均分一样，则按照考试次数从小到大的顺序排序。最终输出结果为：
1004 2 70
1003 4 80
1005 4 84
1002 3 86
1001 6 86

参考代码如下：

package Hadoop;



import java.io.DataInput;
import java.io.DataOutput;
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.io.WritableComparable;
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;



public class Demo1 {

	public static class Tonji implements WritableComparable<Tonji>{
		
		

		private int cishu;//考试次数
		private int aver;//平均分
		
		//定义一个默认的构造方法，并且给遍历初设化
		public Tonji() {
			this.cishu=0;
			this.aver=0;
		}
		
		//
		public Tonji(int cishu,int aver){
			this.cishu=cishu;
			this.aver=aver;
		}
		
		public int getCishu() {
			return this.cishu;
		}

		public void setCishu(int cishu) {
			this.cishu = cishu;
		}

		public int getAver() {
			return this.aver;
		}

		public void setAver(int aver) {
			this.aver = aver;
		}
		
		
		//
		@Override
		public void readFields(DataInput in) throws IOException {
			// TODO 自动生成的方法存根
			this.cishu=in.readInt();
			this.aver=in.readInt();
		}

		@Override
		public void write(DataOutput out) throws IOException {
			// TODO 自动生成的方法存根
			out.writeInt(this.cishu);
			out.writeInt(this.aver);
		}

		
		
		@Override
		public int compareTo(Tonji arg0) {
			// 如果平均分相同，就给次数从小到大排序
			if(this.aver == arg0.aver){
				return this.cishu-arg0.cishu;
			}
			//否则平均分从小到大排序
			else {
				return this.aver-arg0.aver;
			}
		}
		
		public String toString(){
			return this.cishu+" "+this.aver;
		}
		
	}
	
	
	public static class TjMapper extends Mapper<Object, Text, Tonji, Text>{ 

		public void map(Object key, Text value, Context context ) throws IOException, InterruptedException { 
			int cishu=0;//次数
			int totol = 0;//总分
			int aver=0;//平均分
			
			String str = value.toString();
			String[] ss = str.split(" ");
			String id = ss[0]; //学号
			
			//由于数据第一位是学号，成绩是从第二位开始的，所以从第二位开始遍历
			for(int i =1;i<ss.length;i++){
				//遍历一次考试次数加1
				cishu++;
				//总分等于自身加上遍历出来的成绩
				//由于遍历的字符串是字符串的，所以将遍历出来的值转换为整形
				totol += Integer.valueOf(ss[i]);	
			}
			//计算平均分
			aver=totol/cishu;
			Text t =new Text();
			t.set(id);
			Tonji d = new Tonji(cishu,aver);
			
			//由于我们需求是进行次数的大小排序，所以输出形式为<对应的Tonji对象，学号>
			context.write(d, t);
		}	
			}
	
	public static class TjReducer extends Reducer<Tonji,Text,Text,Tonji> { 
		public void reduce(Tonji key, Iterable<Text> values, Context context ) throws IOException, InterruptedException {
			
			//由于我们的输出需求是学号 次数 平均分
			//而mapper传进来的是<次数 平均分，[学号]>
			//所以我们要先将values遍历
			//输出改为<学号，对应的Tonji对象>
			
			for(Text p :values){
				context.write(p,key);
			}
			
		}
			
		}
	
	
	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: wordcount <in> <out>"); 
			System.exit(2); 
		} 
		
		
		Job job = Job.getInstance(conf, "cj tonji"); 
		
		//map的输出key
		job.setMapOutputKeyClass(Tonji.class);
		//reduce的输出value
		job.setMapOutputValueClass(Text.class);

		job.setJarByClass(Demo1.class); 

		job.setMapperClass(TjMapper.class);

		job.setReducerClass(TjReducer.class); 

		job.setOutputKeyClass(Text.class); 

		job.setOutputValueClass(Tonji.class); 
		

		FileInputFormat.addInputPath(job, new Path(otherArgs[0]));

		FileOutputFormat.setOutputPath(job, new Path(otherArgs[1])); 
		System.exit(job.waitForCompletion(true) ? 0 : 1); 
	} 


}