1、 在hadoop中所有的key/value都必须实现Writable接口，有两个方法，分别用于读（反序列化）和写（序列化）操作。
参考代码：
package org.dragon.hadoop.mapreduce.app; import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException; import org.apache.hadoop.io.Writable; /**
*
* @author ZhuXY
* @time 2016-3-10 下午3:49:55
*
*/
public class DataWritable implements Writable { // telsphone // upload
private int upPackNum;
private int upPayLoad; // download
private int downPackNum;
private int downPayLoad; public DataWritable() { } public void set(int upPackNum, int upPayLoad, int downPackNum,
int downPayload) {
this.upPackNum = upPackNum;
this.upPayLoad = upPayLoad;
this.downPackNum = downPackNum;
this.downPayLoad = downPayload; } public int getUpPackNum() {
return upPackNum;
} public int getUpPayLoas() {
return upPayLoad;
} public int getDownPackNum() {
return downPackNum;
} public int getDownPayload() {
return downPayLoad;
} @Override
public void write(DataOutput out) throws IOException {
out.writeInt(upPackNum);
out.writeInt(upPayLoad);
out.writeInt(downPackNum);
out.writeInt(downPayLoad);
} /**
* 讀出的順序要和寫入的順序相同
*/
@Override
public void readFields(DataInput in) throws IOException {
// TODO Auto-generated method stub
this.upPackNum = in.readInt();
this.upPayLoad = in.readInt();
this.downPackNum = in.readInt();
this.downPayLoad = in.readInt();
} @Override
public String toString() {
return upPackNum + "\t" + upPayLoad + "\t" + downPackNum + "\t"
+ downPayLoad;
} @Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + downPackNum;
result = prime * result + downPayLoad;
result = prime * result + upPackNum;
result = prime * result + upPayLoad;
return result;
} @Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
DataWritable other = (DataWritable) obj;
if (downPackNum != other.downPackNum)
return false;
if (downPayLoad != other.downPayLoad)
return false;
if (upPackNum != other.upPackNum)
return false;
if (upPayLoad != other.upPayLoad)
return false;
return true;
} }
简单继承Writable例子 Code
2、所有的key必须实现Comparable接口，在MapReduce过程中需要对Key/Value对进行反复的排序。默认情况下依据Key进行排序的，要实现comparaTo()方法。所以通过Key既要实现Writable接口又要实现Comparable接口，Hadoop中提供了一个公共的接口，叫做WritableComparable接口：
3、由于需要序列化反序列化和进行比较，对java对象需要重写一下几个方法：
① equals();
② hashCode();
③ toString()方法
如IntWritable类型的实现：
package org.apache.hadoop.io; import java.io.*; /** A WritableComparable for ints. */
public class IntWritable implements WritableComparable {
private int value; public IntWritable() {} public IntWritable(int value) { set(value); } /** Set the value of this IntWritable. */
public void set(int value) { this.value = value; } /** Return the value of this IntWritable. */
public int get() { return value; } public void readFields(DataInput in) throws IOException {
value = in.readInt();
} public void write(DataOutput out) throws IOException {
out.writeInt(value);
} /** Returns true iff <code>o</code> is a IntWritable with the same value. */
public boolean equals(Object o) {
if (!(o instanceof IntWritable))
return false;
IntWritable other = (IntWritable)o;
return this.value == other.value;
} public int hashCode() {
return value;
} /** Compares two IntWritables. */
public int compareTo(Object o) {
int thisValue = this.value;
int thatValue = ((IntWritable)o).value;
return (thisValue<thatValue ? -1 : (thisValue==thatValue ? 0 : 1));
} public String toString() {
return Integer.toString(value);
}
4、数据类型，必须有一个无参的构造方法，为了方便反射创建对象。
在自定义数据类型中，建议使用java原生数据类型，最好不要使用hadoop对原生类型封装好的数据类型，即如下样例代码：
推荐使用：
不建议使用：
5、问题：
当数据写入磁盘时，如果要进行排序的话，需要首先从磁盘中读取数据进行反序列化成对象，然后在内存中对反序列化的对象进行比较。
对字节（未经过反序列化字节）进行直接比较，不需要进行反序列化以后再比较呢？如果要实现上述功能，Hadoop数据类型需要实现一个接口RawComparator。
在Hadoop中有一个针对Writable数据类型，进行实现的一个通用实现类WritableComparator类。所有的数据类型，只需要继承通用类，再去需要具体功能复写相应的compara()方法。一下以IntWritable为例，查看一下：
对于自定义的Comparator类需要以下几步：
1） 推荐Comparator类定义在数据类型内部，静态内部类，实现WritableComparator类。
2） 重写默认无参构造方法，方法内必须调用父类有参构造方法，如下截图：
3） 重载父类的compare()方法，依据具体功能覆写。
4） 向WritableComparator类中注册自定义的Comparator类，代码如下：
5、自定义数据类型
样例代码：
package org.dragon.hadoop.mr.io; import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;
import org.apache.hadoop.io.WritableUtils; /**
* 自定义数据类型对Writable的实现。
* 快捷键get、set选择器alt+shift+s
* @author ZhuXY
* @time 2016-3-9 下午10:40:02
*
*/
/**
* 1、Hadoop之——数据类型
1） 在hadoop中所有的key/value都必须实现Writable接口，有两个方法，分别用于读（反序列化）和写（序列化）操作。
2） 所有的key必须实现Comparable接口，在MapReduce过程中需要对Key/Value对进行反复的排序。默认情况下依据Key进行排序的，要实现comparaTo()方法。所以通过Key既要实现Writable接口又要实现Comparable接口，Hadoop中提供了一个公共的接口，叫做WritableComparable接口
3） 由于需要序列化反序列化和进行比较，对java对象需要重写一下几个方法：
① equals();
② hashCode();
③ toString()方法
4） 数据类型，必须有一个无参的构造方法，为了方便反射创建对象。
5） 在自定义数据类型中，建议使用java原生数据类型，最好不要使用hadoop对原生类型封装好的数据类型，即 */ /**
* 问题：
当数据写入磁盘时，如果要进行排序的话，需要首先从磁盘中读取数据进行反序列化成对象，然后在内存中对反序列化的对象进行比较。
* 对字节（未经过反序列化字节）进行直接比较，不需要进行反序列化以后再比较呢？如果要实现上述功能，Hadoop数据类型需要实现一个接口RawComparator。
在Hadoop中有一个针对Writable数据类型，进行实现的一个通用实现类WritableComparator类。所有的数据类型，只需要继承通用类，再去需要具体功能复写相应的compara()方法。
对于自定义的Comparator类需要以下几步：
1） 推荐Comparator类定义在数据类型内部，静态内部类，实现WritableComparator类。
2） 重写默认无参构造方法，方法内必须调用父类有参构造方法，如下截图： 3） 重载父类的compare()方法，依据具体功能覆写。
4） 向WritableComparator类中注册自定义的Comparator类，代码如下： */ /**
* WritableCOmparator是RawComparator对WritableComparable类的一个通用实现。它提供两个主要的功能。
* 首先他提供了一个默认的对原始compare()函数的调用，对从数据流对要比较的对象进行反序列化，然后调用对象
* 的compare方法。
* 其次，他充当的是RawComparator实例的工厂方法（Writable方法已经注册）。
* @author ZhuXY
*
*/
public class PairWritable implements WritableComparable<PairWritable> { private String name;// Text
private Integer age;// IntWritale public PairWritable() {
} public PairWritable(String name, Integer age) {
this.set(name, age);
} public void set(String name, Integer age) {
this.name = name;
this.age = age;
} public String getName() {
return name;
} public Integer getAge() {
return age;
} /**
* write方法是在写入数据时调用，进行序列化
*/
@Override
public void write(DataOutput out) throws IOException {
out.writeUTF(name);
out.writeInt(age);
} /**
* readField()方法是在取出数据时调用的方法，反序列化方法
* 以便生成对象
*/
@Override
public void readFields(DataInput in) throws IOException {
this.name = in.readUTF();
this.age = in.readInt();
} /**
*
hashCode 的常规协定是：
1）在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
2）如果根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。
3）以下情况不 是必需的：如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。
4）实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。） 5）当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
*/
@Override
public int hashCode() {
return name.hashCode() * 31 + age.hashCode();
} @Override
public boolean equals(Object obj) {
if (obj instanceof PairWritable) {
PairWritable pairWritable = (PairWritable) obj; return this.name.equals(pairWritable.getName())
&& this.age.equals(pairWritable.getAge());
}
return false;
} @Override
public String toString() {
// TODO Auto-generated method stub
return this.name+"\t"+this.age;
} @Override
public int compareTo(PairWritable o) {
int cmp=this.name.compareTo(o.getName());
if (cmp!=0) {
return cmp;
}
return this.age.compareTo(o.getAge());
} public static class Comparator extends WritableComparator{ public Comparator(){
super(PairWritable.class);
} /**
* 第一个字节数组
* byte[] b1, int s1, int l1,
* 字节数组起始位置长度
*
* 第二个字节数组
* byte[] b2, int s2, int l2
* 字节数组的起始位置长度
*/
/**
*
* 核心：
* 这个接口允许执行者比较从流中读取的未被反序列化为对象的记录，从而省去了创建对象的所有开销。
* 例如，IntWritables的comparator使用原始的compare()方法从每个字节数组的指定
* 开始位置（S1和S2）和长度（L1和L2）读取整数（b1和b2），然后直接进行比较。
*/
@Override
public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
int n1=WritableUtils.decodeVIntSize(b1[s1]);
int n2=WritableUtils.decodeVIntSize(b2[s2]); int cmp=WritableComparator.compareBytes(b1, s1+n1, l1-n1, b2, s2+n2, l2+n2); if (0!=cmp) {
return cmp;
} int thisValue=readInt(b1, l1-s1-n1);
int thatValue=readInt(b2, l2-s2-n2); return (thisValue<thatValue ?-1:(thisValue==thatValue?0:1));
}
static {
WritableComparator.define(PairWritable.class, new Comparator());
}
}
}
PairWritable Code包括Writable和RawComparator
通常情况下，实现一个静态方法read(DataInput)，用于构造数据类型的实例对象，方法内部调用readFields(DataInput)方法。
Hadoop MapReduce Data Type中所有的Key，必须实现WritableComparable接口，官方文档说明如下：
比较器RawComparator，官方文档说明如下：
6、注意NullWritable类型
package org.apache.hadoop.io; import java.io.*; /** Singleton Writable with no data. */
public class NullWritable implements WritableComparable { private static final NullWritable THIS = new NullWritable(); private NullWritable() {} // no public ctor /** Returns the single instance of this class. */
public static NullWritable get() { return THIS; } public String toString() {
return "(null)";
} public int hashCode() { return 0; }
public int compareTo(Object other) {
if (!(other instanceof NullWritable)) {
throw new ClassCastException("can't compare " + other.getClass().getName()
+ " to NullWritable");
}
return 0;
}
public boolean equals(Object other) { return other instanceof NullWritable; }
public void readFields(DataInput in) throws IOException {}
public void write(DataOutput out) throws IOException {} /** A Comparator "optimized" for NullWritable. */
public static class Comparator extends WritableComparator {
public Comparator() {
super(NullWritable.class);
} /**
* Compare the buffers in serialized form.
*/
public int compare(byte[] b1, int s1, int l1,
byte[] b2, int s2, int l2) {
assert 0 == l1;
assert 0 == l2;
return 0;
}
} static { // register this comparator
WritableComparator.define(NullWritable.class, new Comparator());
}
}