掩码计算UDAF

写的一个内部使用的UDAF，参照hive的sum和这位大哥的udafhttp://www.fuzhijie.me/?p=118,经过n多次的尝试终于成功了！！！

话不多说，直接上代码：

package hive.IRUDAF2;

import org.apache.hadoop.hive.ql.exec.UDAF;   
import org.apache.hadoop.hive.ql.exec.UDAFEvaluator;   
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.commons.lang.StringUtils;

//
/*掩码计算：
 * *ibit=(hour*60+min)/5
 * ibit=0——5掩码第0位置1，5——10掩码第1位置1，以此类推
 */

public class IRMask extends UDAF{   
         
     public static class IRorEvaluator implements UDAFEvaluator{
         
          public    static String sResult; 
          public char chTemp [] =  new char[400];           
          public IRorEvaluator(){ 
                  super();
                  sResult = new String(); 

               init();   
          }   
             
          /*  
          *init函数类似于构造函数，用于UDAF的初始化  
          */  
          public void init(){   
               //score.pSum = 0;   
             
              sResult = new String();
              for(int i=0 ; i<40 ; i++)
                 sResult += "0000000000";
              chTemp = sResult.toCharArray();
          }   
             
          /*  
          *iterate接收传入的参数，并进行内部的轮转。其返回类型为boolean  
          *类似Combiner中的mapper  
          */  
          public boolean iterate(Text in1){   
               if(in1 != null){                   
                   int iBit =  ChangeVstartToInt(in1.toString());
                 // score.sResult.setCharAt(score.iBit, '1');
                 
                    if( 0<=iBit && iBit<288)
                    {                                                   
                        chTemp[iBit] = '1';
                        sResult = String.valueOf(chTemp);
                    }
                
               }   
               
               return true;   
          }   
             
          /*  
          *terminatePartial无参数，其为iterate函数轮转结束后，返回轮转数据  
          *类似Combiner中的reducer  
          */  
          public String terminatePartial(){   
               return  sResult ;   
          }   
             
          /*  
          *merge接收terminatePartial的返回结果，进行数据merge操作，其返回类型为boolean  
          */  
          public boolean merge(String in1) //in1是terminatePartial传入的结果
          {    //merge的时候要和iterate差不多的计算，相当于把iterate计算得出的结果合并。
              for(int j=0 ;j<288 ;j++ )
              {
                  if(in1.charAt(j) == '1')
                      chTemp[j] = '1';
              }
              sResult = String.valueOf(chTemp);
               return true;   
          }   
             
          /*  
          *terminate返回最终的聚集函数结果  
          */  
          public Text terminate(){               
              return new Text(sResult);               
          }   
          
     
         public int ChangeVstartToInt(String vstart)
         {
                 String arrStart[] =vstart.split(" ");
                String arrStart2[] = arrStart[1].split(":");
                int lHour = changeStringToInt(arrStart2[0]);
                int lMinute = changeStringToInt(arrStart2[1]) ;      
                return (lHour*60 + lMinute)/5; //5分钟一个位
         }
          public  boolean isNumeric(String str)
          {
            for (int i = str.length();--i>=0;)
            {   
             if (!Character.isDigit(str.charAt(i)))
             {
              return false;
             }
            }
            return true;
           }

          public int changeStringToInt(String str)
          {
              int iResult=0;
              if( str.length()!=0 && isNumeric(str) )
                  iResult = Integer.parseInt(str);
              if( iResult <0 || iResult >=288)
                  iResult=0;
              return iResult;
          }
     }           
}