[
https://issues.apache.org/jira/browse/LANG-536?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14171410#comment-14171410
]
James Sawle commented on LANG-536:
----------------------------------
I can never make it as efficient as a primitive only implementation, but there
are two caveats to this:
- You wished for the Object's compareTo methods to still be used. This would
lead to boxing at the time of calling and hence on every request extra overhead
would be encountered. If we build primitive Iterators that return the wrapped
versions, we only convert to the boxed version once for each value retrieved,
which will be less than all if the array is unsorted before the last two values.
- Speed must not be considered as the only factor, maintenance, testing and
binary size should also be considered. Whilst testing is the same either way,
maintenance of a smaller reusable code base can only ever be a good thing, and
lead to other possibilities. Also the size of the binary should not be
continuously artificially inflated for small performance gains (the original
implementation was not overly efficient and not counting that), but this is a
small point in the bigger picture of the entire library from my perspective.
I will try and throw together an implementation over the next couple of days
and see what people think. It will be a major refactor of the sort methods.
> Add isSorted() to ArrayUtils
> ----------------------------
>
> Key: LANG-536
> URL: https://issues.apache.org/jira/browse/LANG-536
> Project: Commons Lang
> Issue Type: New Feature
> Components: lang.*
> Reporter: Sergei Ivanov
> Priority: Minor
> Fix For: Review Patch
>
> Attachments: LANG-536.patch
>
>
> In my unit tests I often need to verify that an array is correctly sorted.
> In order to achieve this, I've got two helper methods as follows.
> Is it possible to integrate these methods into ArrayUtils?
> {code}
> /**
> * Checks that the specified array of objects is in an ascending order
> * according to the specified comparator. All elements in the array must
> be
> * <i>mutually comparable</i> by the specified comparator (that is,
> * <tt>c.compare(e1, e2)</tt> must not throw a <tt>ClassCastException</tt>
> * for any elements <tt>e1</tt> and <tt>e2</tt> in the array).
> *
> * @param a the array to be checked.
> * @param c the comparator to determine the order of the array. A
> * <tt>null</tt> value indicates that the elements'
> * {@linkplain Comparable natural ordering} should be used.
> * @return {@code true}, if the array is sorted; {@code false}, otherwise.
> * @throws ClassCastException if the array contains elements that are
> * not <i>mutually comparable</i> using the specified comparator.
> */
> public static <T> boolean isSorted(final T[] a, final Comparator<? super
> T> c) {
> if (a.length <= 1) {
> // Empty or singleton arrays are always sorted
> return true;
> }
> // Otherwise, check that every element is not smaller than the
> previous
> T previous = a[0];
> for (int i = 1, n = a.length; i < n; i++) {
> final T current = a[i];
> if (c.compare(previous, current) > 0) {
> return false;
> }
> previous = current;
> }
> return true;
> }
> /**
> * Checks that the specified array of objects is in an ascending order,
> * according to the {@linkplain Comparable natural ordering} of its
> elements.
> * All elements in the array must implement the {@link Comparable}
> interface.
> * Furthermore, all elements in the array must be <i>mutually
> comparable</i>
> * (that is, <tt>e1.compareTo(e2)</tt> must not throw a
> <tt>ClassCastException</tt>
> * for any elements <tt>e1</tt> and <tt>e2</tt> in the array).
> *
> * @param a the array to be checked.
> * @return {@code true}, if the array is sorted; {@code false}, otherwise.
> * @throws ClassCastException if the array contains elements that are not
> * <i>mutually comparable</i> (for example, strings and integers).
> */
> @SuppressWarnings({"unchecked"})
> public static <T> boolean isSorted(final T[] a) {
> if (a.length <= 1) {
> // Empty or singleton arrays are always sorted
> return true;
> }
> // Otherwise, check that every element is not smaller than the
> previous
> T previous = a[0];
> for (int i = 1, n = a.length; i < n; i++) {
> final T current = a[i];
> if (((Comparable<? super T>) previous).compareTo(previous) > 0) {
> return false;
> }
> previous = current;
> }
> return true;
> }
> {code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
