Package com.avoka.core.util

Class 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 Detail

      • 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 Detail

      • 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:
        Comparator.compare(java.lang.Object, java.lang.Object)

      • 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