Re: Did the sort do anything?

On 11/7/2011 1:27 AM, Roedy Green wrote:


The best and most correct would be to scan the new array for changes.
If you're willing to relax your definition of "change" (and maybe
"best"), you could just test if any element was out of order while the
list was sorted. If so, you can assume the list was changed, and if
not, you might assume it was not.

Here's my attempt:

package quicktest;

import java.util.Arrays;
import java.util.Comparator;

/**
  *
  * @author Brenden
  */
public class LatchOutOfOrderComparator<T> implements Comparator<T> {

    private Comparator delegate;
    private boolean wasOutOfOrder;

    public LatchOutOfOrderComparator( Comparator delegate ) {
       this.delegate = delegate;
    }

    public boolean getWasOutOfOrder() {
       return wasOutOfOrder;
    }

    @Override
    public int compare(T o1, T o2) {
       int compare = delegate.compare( o1, o2 );
       if( compare < 0 ) wasOutOfOrder = true;
       return compare;
    }

}

class LatchOutOfOrderComparableTest {

    public static void main(String[] args) {
       String[] reversed = {"c", "b", "a" };
       System.out.println( Arrays.toString( reversed ) +
       " out of order:" );
       LatchOutOfOrderComparator l1 = new LatchOutOfOrderComparator(
               new StringComapartor() );
       Arrays.sort( reversed, l1 );
       System.out.println( l1.getWasOutOfOrder() );

       String[] ordered = {"a", "b", "c" };
       System.out.println( Arrays.toString( ordered ) +
       " out of order:" );
       LatchOutOfOrderComparator l2 = new LatchOutOfOrderComparator(
               new StringComapartor() );
       Arrays.sort( ordered, l2 );
       System.out.println( l2.getWasOutOfOrder() );
    }

    private static class StringComapartor implements Comparator<String> {

       public int compare(String o1, String o2) {
          return o1.compareTo(o2);
       }
    }
}