Use ArrayUtils.clone()
and ArrayUtils.reverse()
methods from Commons Lang. Example 1-5 demonstrates the reversal and cloning of a
primitive array full of long
primitives.
Example 1-5. Cloning and reversing a primitive array with ArrayUtils
import org.apache.commons.lang.ArrayUtils; long[] array = { 1, 3, 2, 3, 5, 6 }; long[] reversed = ArrayUtils.clone( array ); ArrayUtils.reverse( reversed ); System.out.println( "Original: " + ArrayUtils.toString( array ) ); System.out.println( "Reversed: " + ArrayUtils.toString( reversed ) );
The array
is cloned and reversed, and the contents
of the original and the reversed array are displayed as output using
ArrayUtils.toString( )
:
Original: { 1, 3, 2, 3, 5, 6 } Reversed: { 6, 5, 3, 2, 3, 1 }
In Example 1-5, clone( )
returns
a reference to a new array, and reverse( )
operates on the array reference supplied as a parameter. It is
important to realize that while clone( )
leaves
the original array alone, reverse( )
operates
directly on the supplied array. In addition to supporting all
primitive arrays, ArrayUtils.clone( )
and
ArrayUtils.reverse( )
work with object arrays. If
array
had been an array of Long
objects, the code would bear a striking resemblance to the previous
example.
The only difference between Examples Example 1-6 and
Example 1-5 is the type of array being cloned and
reversed. Again, ArrayUtils.toString( )
is used to
print out the contents of both the original and the reverse array:
Original: { 3, 56, 233 } Reversed: { 233, 56, 3 }
Example 1-6. Cloning and reversing an Object[ ] with ArrayUtils
Long[] array = new Long[] { new Long(3), new Long(56), new Long(233) }; Long[] reversed = ArrayUtils.clone( array ); ArrayUtils.reverse( reversed ); System.out.println( "Original: " + ArrayUtils.toString( array ) ); System.out.println( "Reversed: " + ArrayUtils.toString( reversed ) );
Without the aid of ArrayUtils.clone( )
and
ArrayUtils.reverse( )
, this task would have
involved writing a loop to populate a reversed array. The following
code completes the same task, but, in order to reverse an array, this
example assigns the values from the original array in reverse;
elements are inserted starting at
reversed[reversed.length
- 1]
and ending at reversed[0]
:
// readTemps returns a 1000 member double[] double[] temperature = readTemps( ); double[] reversed = new double[temperature.length]; for( int i = 0; i < temperature.length; i++ ) { reversed[reversed.length - (i+1)] = temperature[i]; }
Another option is the use of the Collections.reverse()
method. J2SE contains a
Collections
object with a static reverse()
method, but this only operates on a
List
object. If you had an array of
double
primitives, and you wanted to take
advantage of the Collections
class, you would need
to convert your double array to a list. Without Java
1.5’s
autoboxing
feature, a double[]
will need to be translated
into a Double[]
before elements can be used to
populate a list:
double[] temps = readTemps( ); List tempList = new ArrayList( ); for( int i = 0; i < temps.length; i++ ) { tempList.add( new Double[temps[i]] ); } Collections.reverse( tempList ); double[] reversed = new double( tempList.size( ) ); Iterator i = tempList.iterator( ); int index = 0; while( i.hasNext( ) ) { reversed[index] = ((Double) i.next( )).doubleValue( ); index++; }
That nasty translation between a double
array and
a list of Double
objects complicates your code.
The next recipe will touch upon an easier method for performing this
translation.
Is ArrayUtils.clone( )
really necessary? All
arrays have a clone( )
method, and all Java arrays
implement Cloneable
and
Serializable
, but I would be surprised if many
Java developers have read the relevant section of the Java Language
Specification (JLS), which discusses Array Members (section 10.7).
All arrays can be cloned by calling the clone( )
method:
long[] temps = readTemps( ); long[] cloned = (long[]) temps.clone( );
ArrayUtils.clone( )
doesn’t
provide you with any performance benefits, it
doesn’t necessarily improve your code, and one could
debate the assertion that it makes for more readable code. But,
mainly, it exists as a safe way to handle null
array references. If you attempt to clone a null
reference, this utility will return a null
instead
of throwing a runtime exception.
18.223.172.132