目前Java基本类型对应的Writable封装如表所示
所有这些Writable类都继承自WritableComparable。也就是说，它们是可比较的。
同时，它们都有get()和set()方法，用于获得和设置封装的值。
对整形（int和long）进行编码的时候，有固定长度格式（IntWritable和LongWritable）和可变长度格式（VIntWritable和VLongWritable）两种选择。
固定长度格式的整形，序列化后的数据是定长的，而可变长度格式则是用一种比较灵活的编码方式，对于数之比较小的整形，它们往往比较节省空间。
同时，由于VIntwritable和VLongWritable的编码规则是一样的，所以VIntwritable的输出可以用VLongWritable读入。
下面以VLongWritable为例，说明Writable的Java基本类封装实现。
代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
public
class
VIntWritable
implements
WritableComparable
&
lt
;
VIntWritable
&
gt
;
{
private
int
value
;
public
VIntWritable
(
)
{
}
public
VIntWritable
(
int
value
)
{
set
(
value
)
;
}
/** 设置VIntWritable的值. */
public
void
set
(
int
value
)
{
this
.
value
=
value
;
}
/** 获取VIntWritable的值. */
public
int
get
(
)
{
return
value
;
}
@
Override
public
void
readFields
(
DataInput
in
)
throws
IOException
{
value
=
WritableUtils
.
readVInt
(
in
)
;
}
@
Override
public
void
write
(
DataOutput
out
)
throws
IOException
{
WritableUtils
.
writeVInt
(
out
,
value
)
;
}
/** Returns true iff <code>o</code> is a VIntWritable with the same value. */
@
Override
public
boolean
equals
(
Object
o
)
{
if
(
!
(
o
instanceof
VIntWritable
)
)
return
false
;
VIntWritable
other
=
(
VIntWritable
)
o
;
return
this
.
value
==
other
.
value
;
}
@
Override
public
int
hashCode
(
)
{
return
value
;
}
/** Compares two VIntWritables. */
@
Override
public
int
compareTo
(
VIntWritable
o
)
{
int
thisValue
=
this
.
value
;
int
thatValue
=
o
.
value
;
return
(
thisValue
&
lt
;
thatValue
?
-
1
:
(
thisValue
==
thatValue
?
0
:
1
)
)
;
}
@
Override
public
String
toString
(
)
{
return
Integer
.
toString
(
value
)
;
}
}
|
首先，每个Java基本类型的Writale封装，其类的内部都包含一个对应基本类型的成员变量value，get()和set()方法就是用来对该变量进行取值/赋值操作的。
而Writable接口要求的readFields()和write()方法，VIntWritable则是通过调用Writable工具类中提供的readVInt()和writeVInt()读/写数据。方法readVInt()和writeVInt()的实现也只是简单调用了readVLong()和writeVLong()，所以，通过writeVInt()写的数据自然可以通过readVLong()读入。
读：
|
1
2
3
4
5
6
7
8
|
public
static
int
readVInt
(
DataInput
stream
)
throws
IOException
{
long
n
=
readVLong
(
stream
)
;
if
(
(
n
&
gt
;
Integer
.
MAX_VALUE
)
||
(
n
&
lt
;
Integer
.
MIN_VALUE
)
)
{
throw
new
IOException
(
&
quot
;
value
too
long
to
fit
in
integer
&
quot
;
)
;
}
return
(
int
)
n
;
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public
static
long
readVLong
(
DataInput
stream
)
throws
IOException
{
byte
firstByte
=
stream
.
readByte
(
)
;
int
len
=
decodeVIntSize
(
firstByte
)
;
if
(
len
==
1
)
{
return
firstByte
;
}
long
i
=
0
;
for
(
int
idx
=
0
;
idx
&
lt
;
len
-
1
;
idx
++
)
{
byte
b
=
stream
.
readByte
(
)
;
i
=
i
&
lt
;
&
lt
;
8
;
i
=
i
|
(
b
&
amp
;
0xFF
)
;
}
return
(
isNegativeVInt
(
firstByte
)
?
(
i
^
-
1L
)
:
i
)
;
}
|
|
1
2
3
4
5
6
7
8
9
|
public
static
int
decodeVIntSize
(
byte
value
)
{
if
(
value
&
gt
;
=
-
112
)
{
return
1
;
}
else
if
(
value
&
lt
;
-
120
)
{
return
-
119
-
value
;
}
return
-
111
-
value
;
}
|
写：
|
1
2
3
4
|
public
static
void
writeVInt
(
DataOutput
stream
,
int
i
)
throws
IOException
{
writeVLong
(
stream
,
i
)
;
}
|
writeVLong()方法实现了对整形数值的变长编码，它的编码规则如下：
如果输入的整数大于或等于-112同时小于或等于127，那么编码需要1字节
否则，序列化结果的第一个字节，保存了输入整数的符号和后续编码的字节数。
符号和后续字节数依据下面的编码规则（又一个规则）：
-113和-120间（闭区间），后续字节数可以通过-(v+112)计算。-121和-128间（闭区间），后续字节数可以通过-(v+120)计算。后续编码将高位在前，写入输入的整数（除去前面全0字节）。代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
public
static
void
writeVInt
(
DataOutput
stream
,
int
i
)
throws
IOException
{
writeVLong
(
stream
,
i
)
;
}
/**
* Serializes a long to a binary stream with zero-compressed encoding.
* For -112 <= i <= 127, only one byte is used with the actual value.
* For other values of i, the first byte value indicates whether the
* long is positive or negative, and the number of bytes that follow.
* If the first byte value v is between -113 and -120, the following long
* is positive, with number of bytes that follow are -(v+112).
* If the first byte value v is between -121 and -128, the following long
* is negative, with number of bytes that follow are -(v+120). Bytes are
* stored in the high-non-zero-byte-first order.
*
* @param stream 保存序列化结果输出流
* @param i 被序列化的整数
* @throws java.io.IOException
*/
public
static
void
writeVLong
(
DataOutput
stream
,
long
i
)
throws
IOException
{
// 处于[-112,127]的整数
if
(
i
&
gt
;
=
-
112
&
amp
;
&
amp
;
i
&
lt
;
=
127
)
{
stream
.
writeByte
(
(
byte
)
i
)
;
return
;
}
// 计算情况2的第一个字节
int
len
=
-
112
;
if
(
i
&
lt
;
0
)
{
i
^=
-
1L
;
// take one's complement'
len
=
-
120
;
}
long
tmp
=
i
;
while
(
tmp
!=
0
)
{
tmp
=
tmp
&
gt
;
&
gt
;
8
;
len
--
;
}
stream
.
writeByte
(
(
byte
)
len
)
;
len
=
(
len
&
lt
;
-
120
)
?
-
(
len
+
120
)
:
-
(
len
+
112
)
;
// 输出后续字节
for
(
int
idx
=
len
;
idx
!=
0
;
idx
--
)
{
int
shiftbits
=
(
idx
-
1
)
*
8
;
long
mask
=
0xFFL
&
lt
;
&
lt
;
shiftbits
;
stream
.
writeByte
(
(
byte
)
(
(
i
&
amp
;
mask
)
&
gt
;
&
gt
;
shiftbits
)
)
;
}
}
|