org.apache.hadoop.io

## Class WritableComparator

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

- All Implemented Interfaces:
    Comparator, Configurable, RawComparator
  Direct Known Subclasses:
    BooleanWritable.Comparator, BytesWritable.Comparator, ByteWritable.Comparator, DoubleWritable.Comparator, FloatWritable.Comparator, IntWritable.Comparator, LongWritable.Comparator, MD5Hash.Comparator, NullWritable.Comparator, ShortWritable.Comparator, Text.Comparator, UTF8.Comparator

      @InterfaceAudience.Public
       @InterfaceStability.Stable
      public class WritableComparator
      extends Object
      implements RawComparator, Configurable

  A Comparator for `WritableComparable`s.

  This base implementation 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

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `WritableComparator()`
    `protected` | `WritableComparator(Class<? extends WritableComparable> keyClass)` Construct for a `WritableComparable` implementation.
    `protected` | `WritableComparator(Class<? extends WritableComparable> keyClass, boolean createInstances)`
    `protected` | `WritableComparator(Class<? extends WritableComparable> keyClass, Configuration conf, boolean createInstances)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `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)` For backwards compatibility.
    `static WritableComparator` | `get(Class<? extends WritableComparable> c, Configuration conf)` Get a comparator for a `WritableComparable` implementation.
    `Configuration` | `getConf()` Return the configuration used by this object.
    `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.
    `void` | `setConf(Configuration conf)` Set the configuration to be used by this object.

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

      `comparing, comparing, comparingDouble, comparingInt, comparingLong, equals, naturalOrder, nullsFirst, nullsLast, reversed, reverseOrder, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong`

- - ### Constructor Detail

    - #### WritableComparator

          protected WritableComparator()

    - #### WritableComparator

          protected WritableComparator(Class<? extends WritableComparable> keyClass)

      Construct for a `WritableComparable` implementation.

    - #### WritableComparator

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

    - #### WritableComparator

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

  - ### Method Detail

    - #### get

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

      For backwards compatibility.

    - #### get

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

      Get a comparator for a `WritableComparable` implementation.

    - #### setConf

          public void setConf(Configuration conf)

      Description copied from interface: `Configurable`
      Set the configuration to be used by this object.
      Specified by:
        `setConf` in interface `Configurable`

    - #### getConf

          public Configuration getConf()

      Description copied from interface: `Configurable`
      Return the configuration used by this object.
      Specified by:
        `getConf` in interface `Configurable`

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

Copyright © 2008–2022 Apache Software Foundation. All rights reserved.