You need to test an array to see if it contains an element. If the array contains the element, you need the index of the matching element.
Use ArrayUtils.contains()
to see if an array contains a specified element, and use
ArrayUtils.indexOf( )
or ArrayUtils.lastIndexOf( )
to find the position of a matching element. The following
example demonstrates the use of these three methods:
import org.apache.commons.lang.ArrayUtils; String[] stringArray = { "Red", "Orange", "Blue", "Brown", "Red" }; boolean containsBlue = ArrayUtils.contains( stringArray, "Blue" ); int indexOfRed = ArrayUtils.indexOf( stringArray, "Red"); int lastIndexOfRed = ArrayUtils.lastIndexOf( string, "Red" ); System.out.println( "Array contains 'Blue'? " + containsBlue ); System.out.println( "Index of 'Red'? " + indexOfRed ); System.out.println( "Last Index of 'Red'? " + lastIndexOfRed );
This example locates strings in a string array and produces the following output:
Array contains 'Blue'? true Index of 'Red'? 0 Last Index of 'Red'? 4
All three methods work with an object array or any primitive
array; in fact, almost every method defined in ArrayUtils
can be applied to every possible
array type—boolean[]
, byte[]
, char[]
, double[]
, float[]
, long[]
, short[]
, and Object[]
. When using a primitive array,
ArrayUtils
compares the value in
question to each element of an array until a match is found. When using
an object array, ArrayUtils
calls the
equals( )
method to check for a
matching array element.
ArrayUtils.indexOf( )
and
ArrayUtils.lastIndexOf( )
take an
optional third parameter that controls where an element search begins.
In the next example, you are searching an array of double primitives for
the value -9999. Example 1-7
demonstrates how to establish that the value is contained within an
array and how to locate the index for each matching element.
Example 1-7. Searching an array using ArrayUtils.contains( ) and ArrayUtils.indexOf( )
// temps is a 1000 element long[] long[] temps = readTemps( ); // Check to see if the array contains -9999 boolean hasErrorFlag = ArrayUtils.contains( temperature, -9999 ); // Print out the index of every errored reading int start = 0; while( hasErrorFlag && (ArrayUtils.indexOf(temperature, -9999, start) != -1) ) { int errorIdx = ArrayUtils.indexOf(temperature, -9999, start); System.out.println( "Error reading at index: " + errorIdx ); start = errorIdx + 1; }
You could easily implement this method yourself; ArrayUtils.contains( )
and ArrayUtils.indexOf( )
are simply methods that
iterate through every element of an array and test for equality. The
simple savings you gain from ArrayUtils
is one less for
loop you have to test and maintain:
long testValue = -9999; boolean hasErrors = false; for( int i = 0; i < temps.length; i++ ) { if( temps[i] == testValue ) { hasErrors = true; } }
The benefits are small, but maintaining your own custom utility
classes is a pain—it is just another thing to test and maintain.
ArrayUtils
isn't going to change your
application's architecture, but it will ultimately reduce the amount of
trivial code you have to write, and you will not have to expend energy
maintaining or testing trivial code.
Chapter 4 contains a number of
recipes dealing with Predicate
objects and filtering collections. Instead of using the three methods
defined in this recipe, you can put objects into a collection and count
or select the elements that match an EqualPredicate
. See Chapter 4 for more information about querying
collections with predicates.