Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.hadoop.io
Class WritableComparator

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

All Implemented Interfaces:
  Comparator, RawComparator

Direct Known Subclasses:
  KeyFieldBasedComparator, RecordComparator

    @InterfaceAudience.Public
    @InterfaceStability.Stable
    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. Comparators registered with this method must be thread-safe.

### 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`
  Parameters:
    `b1` - The first byte array.
    `s1` - The position index in b1. The object under comparison's starting index.
    `l1` - The length of the object in b1.
    `b2` - The second byte array.
    `s2` - The position index in b2. The object under comparison's starting index.
    `l2` - The length of the object under comparison in b2.
  Returns:
    An integer result of the comparison.

### 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`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2012 Apache Software Foundation. All Rights Reserved.