Package com.avoka.core.util

Class StringComparator

java.lang.Object
com.avoka.core.util.StringComparator
All Implemented Interfaces:
Comparator
public class StringComparator extends Object implements Comparator
Provides a string comparator that can sort in ascending or descending order. Comparison is done as follows: Case 1: If both objects implement Comparable but are not java.lang.String, they are compared using object1.compareTo(object2) Case 2: Otherwise, if neither object is null, they are converted to strings and trimmed (.toString().trim()), then compared (ignoring case). Case 3: Otherwise, null is considered less than non-null objects (and two null objects are considered equal). Note: If the strings are numeric, they are still compared as strings (otherwise transitivity may be violated when sorting certain datasets). If you need to sort strings numerically, this is not the right comparator to use.

  • Constructor Details

    • StringComparator

      public StringComparator()
      Default constructor.

    • StringComparator

      public StringComparator(boolean ascending)
      Constructor that takes whether the sorting is ascending.
      Parameters:
      ascending - true if the sorting order is ascending

  • Method Details

    • compare

      public int compare(Object value1, Object value2)
      Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

      The implementor must ensure that sgn(compare(x, y)) == -sgn(compare(y, x)) for all x and y. (This implies that compare(x, y) must throw an exception if and only if compare(y, x) throws an exception.)

      The implementor must also ensure that the relation is transitive: ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0.

      Finally, the implementer must ensure that compare(x, y)==0 implies that sgn(compare(x, z))==sgn(compare(y, z)) for all z.

      It is generally the case, but not strictly required that (compare(x, y)==0) == (x.equals(y)). Generally speaking, any comparator that violates this condition should clearly indicate this fact. The recommended language is "Note: this comparator imposes orderings that are inconsistent with equals."

      Specified by:
      compare in interface Comparator
      Parameters:
      value1 - the first object to be compared.
      value2 - the second object to be compared.
      Returns:
      a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
      See Also:

    • greaterThan

      public boolean greaterThan(Object value1, Object value2)
      Return true if value1 is greater than value2.
      Parameters:
      value1 - object 1 for comparison
      value2 - object 2 for comparison
      Returns:
      true if value1 is greater than value2

    • lessThan

      public boolean lessThan(Object value1, Object value2)
      Return true if value1 is less than value2.
      Parameters:
      value1 - object 1 for comparison
      value2 - object 2 for comparison
      Returns:
      true if value1 is less than value2

    • stringCompare

      protected int stringCompare(Object value1, Object value2)
      Perform a string comparison on given values
      Parameters:
      value1 - first object to compare
      value2 - second object to compare
      Returns:
      1 if value1 is greater than value2, -1 if value1 is less than value2, otherwise 0