Hadoop中Writable类

1.Writable简单介绍

在前面的博客中，经常出现IntWritable，ByteWritable.....光从字面上，就可以看出，给人的感觉是基本数据类型 和 序列化！在Hadoop中自带的org.apache.hadoop.io包中有广泛的Writable类可供选择。它们的层次结构如下图所示：

Writable类对Java基本类型提供封装，short 和 char除外（可以存储在IntWritable中）。所有的封装包包含get()  和 set() 方法用于读取或者设置封装的值。如下表所示，Java基本类型的Writable类：

Java 基本类型的Writable类

Java 基本数据类型	Writable实现	序列化大小（字节）
boolean	BooleanWritable	1
byte	ByteWritable	1
int	IntWritable VIntWritable	4 1~5
float	FloatWritable	4
long	LongWritable VLongWritable	8 1~9
double	DoubleWritable	8

2.IntWritable 和 VIntWritable

如上表所示，这两个的区别，很明显，序列化的大小，IntWriable是固定的4个字节，而VintWritable是1～5个字节，是可以变化的！这两个分别在什么场合用？如果需要编码的数值在-127～127之间，变长格式就只用一个字节进行编码；否则，使用一个字节来表示数值的正负和后跟多少个字节。

相比与定长格式，变长格式有什么优点：

(1).定长格式适合对整个值域空间中分布均匀的数值进行编码，大多数数值变量的分布都不均匀，而且变长格式 一般更节省空间。

(2).还有，就是变长格式的VIntWritable和VLlongWritable可以转换，因为他们的编码实际上一致！选择变长格式，更有增长空间。

通过上面，可以知道，变长格式的范围是1～5个字节，那么什么时候是5个字节，什么时候又是3个字节呢？

整数的范围	序列化字节的大小（字节）
-127～127   （-2^7  - 1  ~   2^7  -1 ）	1
-256（2的8次方）~ -128  或者  128～255	2
-65536（2的16次方）～ -257  或者 256～65535	3
-16777216(2的24次方) ～  -65537   或者  65536 ～ 16777215	4
-2147483648(2的31次方) ～ -16777217 或者 16777216 ～ 2147483647	5

问题：

《Hadoop权威指南》上说，需要编码的数值如果相当小（在-127和127之间，包括-127和127）,变长格式就只用一个字节进行编码！理论上，我也认为是正确的，但是，我用代码测试了以下，发现-127～-113之间，占用的是2个字节。如下面的例子以及运行结果：

Example:

 package cn.roboson.writable;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;

 import org.apache.hadoop.io.IntWritable;
 import org.apache.hadoop.io.VIntWritable;
 import org.apache.hadoop.io.Writable;
 /**
  * 这个例子，主要是为了区分定长和变长，还有就是变长的范围
  * 1.先定义两个IntWritable
  * 2.分别序列化这两个类
  * 3.比较序列化后字节大小
  * @author roboson
  *
  */

 public class IntWritableTest {

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

         //定义两个比较小的IntWritable，序列化后1个字节的临界点，《Hadoop权威指南》中所说的是-127～127，但是，我发现只能是-112～127
         //超过-112后，就成为2个字节了
         IntWritable writable = new IntWritable(127);
         VIntWritable vwritable = new VIntWritable(-112);
         show(writable,vwritable);

         //验证不是从-127～127
         writable.set(-113);
         vwritable.set(-113);
         show(writable,vwritable);

         //序列化后两个字节大小的范围   -256（2的8次方）~ -128  或者  128～255
         writable.set(-256);
         vwritable.set(-256);
         show(writable,vwritable);

         //序列化后3个字节大小的范围  -65536（2的16次方）～ -257  或者 256～65535
         writable.set(-65536);
         vwritable.set(-65536);
         show(writable,vwritable);

         //序列化后4个字节大小的范围  -16777216(2的24次方) ～  -65537   或者  65536 ～ 16777215
         writable.set(-16777216);
         vwritable.set(-16777216);
         show(writable,vwritable);

         //序列化后4个字节大小的范围  -2147483648(2的31次方) ～ -16777217 或者 16777216 ～ 2147483647
         writable.set(-2147483648);
         vwritable.set(-2147483648);
         show(writable,vwritable);
     }

     public static byte[] serizlize(Writable writable) throws IOException{

         //创建一个输出字节流对象
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         DataOutputStream dataout = new DataOutputStream(out);

         //将结构化数据的对象writable写入到输出字节流。
         writable.write(dataout);
         return out.toByteArray();
     }

     public static byte[] deserizlize(Writable writable,byte[] bytes) throws IOException{

         //创建一个输入字节流对象，将字节数组中的数据，写入到输入流中
         ByteArrayInputStream in = new ByteArrayInputStream(bytes);
         DataInputStream datain = new DataInputStream(in);

         //将输入流中的字节流数据反序列化
         writable.readFields(datain);
         return bytes;

     }

     public static void show(Writable writable,Writable vwritable) throws IOException{
         //对上面两个进行序列化
         byte[] writablebyte = serizlize(writable);
         byte[] vwritablebyte = serizlize(vwritable);

         //分别输出字节大小
         System.out.println("定长格式"+writable+"序列化后字节长大小："+writablebyte.length );
         System.out.println("变长格式"+vwritable+"序列化后字节长大小："+vwritablebyte.length );
     }
 }

运行结果：

 

先到这，后面的数据类型，下次继续