[
https://issues.apache.org/jira/browse/LANG-536?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14172945#comment-14172945
]
James Sawle commented on LANG-536:
----------------------------------
Sorry about the patch, I forgot to add my package private IteratorUtils class.
Even with only boxing as required could not even get close to the performance
of pure primitive implementations even if it did give me a 3x improvement. As a
note, the performance is comparable to changing Duncan's implementation to
boxing when retrieved from the array (this is all the iterator is doing with
layers of abstraction).
{noformat}
# Run complete. Total time: 00:16:08
Benchmark Mode Samples Score Error Units
o.s.MyBenchmark.testObject thrpt 200 26282.374 ± 143.565 ops/s
o.s.MyBenchmark.testPrimitive thrpt 200 185028.652 ± 1398.114 ops/s
{noformat}
The only point of note is that not all wrapper class contain a compare(prim,
prim) method in Java 6 so some logic will need to be reversed engineered from
Java 7. These could be made public for more general use.
I can provide my implementation if anyone wishes, but beyond basic Iterator
implementations I am not sure what will be gained if we take the pure primitive
route.
> 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, perftest.zip
>
>
> 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)
