## org.apache.hadoop.io
Class WritableComparator

    java.lang.Object
      org.apache.hadoop.io.WritableComparator

All Implemented Interfaces:
  Comparator, RawComparator

Direct Known Subclasses:
  BooleanWritable.Comparator, BytesWritable.Comparator, ByteWritable.Comparator, DoubleWritable.Comparator, FloatWritable.Comparator, IntWritable.Comparator, KeyFieldBasedComparator, KeyFieldBasedComparator, LongWritable.Comparator, MD5Hash.Comparator, NullWritable.Comparator, RecordComparator, SecondarySort.IntPair.Comparator, Text.Comparator, UTF8.Comparator

    public class WritableComparator

extends Object
implements RawComparator

A Comparator for `WritableComparable`s.

This base implemenation uses the natural ordering. To define alternate orderings, override `compare(WritableComparable,WritableComparable)`.

One may optimize compare-intensive operations by overriding `compare(byte[],int,int,byte[],int,int)`. Static utility methods are provided to assist in optimized implementations of this method.

Constructor Summary
`protected` `WritableComparator(Class<? extends WritableComparable> keyClass)` Construct for a `WritableComparable` implementation.
`protected` `WritableComparator(Class<? extends WritableComparable> keyClass, boolean createInstances)`

Method Summary
`int` `compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2)` Optimization hook.
`int` `compare(Object a, Object b)`
`int` `compare(WritableComparable a, WritableComparable b)` Compare two WritableComparables.
`static int` `compareBytes(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2)` Lexicographic order of binary data.
`static void` `define(Class c, WritableComparator comparator)` Register an optimized comparator for a `WritableComparable` implementation.
`static WritableComparator` `get(Class<? extends WritableComparable> c)` Get a comparator for a `WritableComparable` implementation.
`Class<? extends WritableComparable>` `getKeyClass()` Returns the WritableComparable implementation class.
`static int` `hashBytes(byte[] bytes, int length)` Compute hash for binary data.
`static int` `hashBytes(byte[] bytes, int offset, int length)` Compute hash for binary data.
`WritableComparable` `newKey()` Construct a new `WritableComparable` instance.
`static double` `readDouble(byte[] bytes, int start)` Parse a double from a byte array.
`static float` `readFloat(byte[] bytes, int start)` Parse a float from a byte array.
`static int` `readInt(byte[] bytes, int start)` Parse an integer from a byte array.
`static long` `readLong(byte[] bytes, int start)` Parse a long from a byte array.
`static int` `readUnsignedShort(byte[] bytes, int start)` Parse an unsigned short from a byte array.
`static int` `readVInt(byte[] bytes, int start)` Reads a zero-compressed encoded integer from a byte array and returns it.
`static long` `readVLong(byte[] bytes, int start)` Reads a zero-compressed encoded long from a byte array and returns it.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface java.util.Comparator
`equals`

Constructor Detail

### WritableComparator

    protected WritableComparator(Class<? extends WritableComparable> keyClass)

  Construct for a `WritableComparable` implementation.

### WritableComparator

    protected WritableComparator(Class<? extends WritableComparable> keyClass,
                                 boolean createInstances)

Method Detail

### get

    public static WritableComparator get(Class<? extends WritableComparable> c)

  Get a comparator for a `WritableComparable` implementation.

### define

    public static void define(Class c,
                              WritableComparator comparator)

  Register an optimized comparator for a `WritableComparable` implementation.

### getKeyClass

    public Class<? extends WritableComparable> getKeyClass()

  Returns the WritableComparable implementation class.

### newKey

    public WritableComparable newKey()

  Construct a new `WritableComparable` instance.

### compare

    public int compare(byte[] b1,
                       int s1,
                       int l1,
                       byte[] b2,
                       int s2,
                       int l2)

  Optimization hook. Override this to make SequenceFile.Sorter's scream.

  The default implementation reads the data into two `WritableComparable`s (using `Writable.readFields(DataInput)`, then calls `compare(WritableComparable,WritableComparable)`.

  Specified by:
    `compare` in interface `RawComparator`

### compare

    public int compare(WritableComparable a,
                       WritableComparable b)

  Compare two WritableComparables.

  The default implementation uses the natural ordering, calling `Comparable.compareTo(Object)`.

### compare

    public int compare(Object a,
                       Object b)

  Specified by:
    `compare` in interface `Comparator`

### compareBytes

    public static int compareBytes(byte[] b1,
                                   int s1,
                                   int l1,
                                   byte[] b2,
                                   int s2,
                                   int l2)

  Lexicographic order of binary data.

### hashBytes

    public static int hashBytes(byte[] bytes,
                                int offset,
                                int length)

  Compute hash for binary data.

### hashBytes

    public static int hashBytes(byte[] bytes,
                                int length)

  Compute hash for binary data.

### readUnsignedShort

    public static int readUnsignedShort(byte[] bytes,
                                        int start)

  Parse an unsigned short from a byte array.

### readInt

    public static int readInt(byte[] bytes,
                              int start)

  Parse an integer from a byte array.

### readFloat

    public static float readFloat(byte[] bytes,
                                  int start)

  Parse a float from a byte array.

### readLong

    public static long readLong(byte[] bytes,
                                int start)

  Parse a long from a byte array.

### readDouble

    public static double readDouble(byte[] bytes,
                                    int start)

  Parse a double from a byte array.

### readVLong

    public static long readVLong(byte[] bytes,
                                 int start)
                          throws IOException

  Reads a zero-compressed encoded long from a byte array and returns it.

  Parameters:
    `bytes` - byte array with decode long
    `start` - starting index
  Returns:
    deserialized long
  Throws:
    `IOException`

### readVInt

    public static int readVInt(byte[] bytes,
                               int start)
                        throws IOException

  Reads a zero-compressed encoded integer from a byte array and returns it.

  Parameters:
    `bytes` - byte array with the encoded integer
    `start` - start index
  Returns:
    deserialized integer
  Throws:
    `IOException`

Copyright © 2009 The Apache Software Foundation