Apache/commons-lang
1
0
Fork 0
mirror of https://github.com/apache/commons-lang.git synced 2025-02-09 11:34:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Initial version of ArrayUtils, includes toMap

Browse Source 
git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/lang/trunk@137098 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Stephen Colebourne 2002-10-13 22:42:06 +00:00
parent 1ad5019544
commit d31f3d3f8a
1 changed files with 545 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

545
src/java/org/apache/commons/lang/ArrayUtils.java Normal file
View File

@ -0,0 +1,545 @@
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Commons", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.commons.lang;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
/**
* <code>ArrayUtils</code> contains utility methods for working for
* arrays.
*
* @author <a href="mailto:scolebourne@apache.org">Stephen Colebourne</a>
* @author Moritz Petersen
* @version $Id: ArrayUtils.java,v 1.1 2002/10/13 22:42:06 scolebourne Exp $
*/
public class ArrayUtils {
/** An empty immutable object array */
public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
/** An empty immutable class array */
public static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
/** An empty immutable string array */
public static final String[] EMPTY_STRING_ARRAY = new String[0];
/** An empty immutable long array */
public static final long[] EMPTY_LONG_ARRAY = new long[0];
/** An empty immutable int array */
public static final int[] EMPTY_INT_ARRAY = new int[0];
/** An empty immutable short array */
public static final short[] EMPTY_SHORT_ARRAY = new short[0];
/** An empty immutable byte array */
public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
/** An empty immutable double array */
public static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
/** An empty immutable float array */
public static final float[] EMPTY_FLOAT_ARRAY = new float[0];
/** An empty immutable boolean array */
public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];
/**
* ArrayUtils instances should NOT be constructed in standard programming.
* Instead, the class should be used as <code>ArrayUtils.clone(new int[] {2})</code>.
* This constructor is public to permit tools that require a JavaBean instance
* to operate.
*/
public ArrayUtils() {
}
//--------------------------------------------------------------------------
/**
* Outputs an array as a String, treating null as an empty array.
* <p>
* Multi-dimensional arrays are handled correctly, including
* multi-dimensional primitive arrays.
* The format is that of Java source code, for example {a,b}.
*
* @param array the array to get a toString for, may not be null
* @return a String representation of the array, '{}' if null passed in
*/
public static String toString(Object array) {
return toString(array, "{}");
}
/**
* Outputs an array as a String handling nulls.
* <p>
* Multi-dimensional arrays are handled correctly, including
* multi-dimensional primitive arrays.
* The format is that of Java source code, for example {a,b}.
*
* @param array the array to get a toString for, may be null
* @param stringIfNull the String to return if the array is null
* @return a String representation of the array
*/
public static String toString(Object array, String stringIfNull) {
if (array == null) {
return stringIfNull;
}
return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
}
/**
* Converts the given array into a {@link Map}. Each element of the array
* must be either a {@link Map.Entry} or an Array, containing at least two
* elements, where the first element is used as key and the second as
* value. This method can be used to initialize:
*
* <pre>
* // Create a Map mapping colors.
* Map colorMap = MapUtils.toMap(new String[][] {{
* {"RED", "#FF0000"},
* {"GREEN", "#00FF00"},
* {"BLUE", "#0000FF"}});
* </pre>
*
* @param array an array whose elements are either a {@link Map.Entry} or
* an Array containing at least two elements
* @return a Map that was created from the array
* @throws IllegalArgumentException if the array is null
* @throws IllegalArgumentException if one element of this Array is
* itself an Array containing less then two elements
* @throws IllegalArgumentException if the array contains elements other
* than {@link Map.Entry} and an Array
*/
public static Map toMap(Object[] array) {
if (array == null) {
throw new IllegalArgumentException("The array must not be null");
}
Map map = new HashMap((int) (array.length * 1.5));
for (int i = 0; i < array.length; i++) {
Object object = array[i];
if (object instanceof Map.Entry) {
Map.Entry entry = (Map.Entry) object;
map.put(entry.getKey(), entry.getValue());
} else if (object instanceof Object[]) {
Object[] entry = (Object[]) object;
if (entry.length < 2) {
throw new IllegalArgumentException("Array element " + i + ", '"
+ object
+ "', has a length less than 2");
}
map.put(entry[0], entry[1]);
} else {
throw new IllegalArgumentException("Array element " + i + ", '"
+ object
+ "', is neither of type Map.Entry nor an Array");
}
}
return map;
}
// /**
// * Output the array as a String.
// * <p>
// * Multi-dimensional arrays are handled by the Object[] method.
// * The format is that of Java source code, for example {1,2}.
// *
// * @param array the array to get a toString for, must not be null
// * @return a String representation of the array
// * @throws IllegalArgumentException if the array is null
// */
// public static String toString(long[] array) {
// return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
// }
//
// /**
// * Output the array as a String.
// * <p>
// * Multi-dimensional arrays are handled by the Object[] method.
// * The format is that of Java source code, for example {1,2}.
// *
// * @param array the array to get a toString for, must not be null
// * @return a String representation of the array
// * @throws IllegalArgumentException if the array is null
// */
// public static String toString(int[] array) {
// return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
// }
//
// /**
// * Output the array as a String.
// * <p>
// * Multi-dimensional arrays are handled by the Object[] method.
// * The format is that of Java source code, for example {1,2}.
// *
// * @param array the array to get a toString for, must not be null
// * @return a String representation of the array
// * @throws IllegalArgumentException if the array is null
// */
// public static String toString(short[] array) {
// return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
// }
//
// /**
// * Output the array as a String.
// * <p>
// * Multi-dimensional arrays are handled by the Object[] method.
// * The format is that of Java source code, for example {1,2}.
// *
// * @param array the array to get a toString for, must not be null
// * @return a String representation of the array
// * @throws IllegalArgumentException if the array is null
// */
// public static String toString(byte[] array) {
// return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
// }
//
// /**
// * Output the array as a String.
// * <p>
// * Multi-dimensional arrays are handled by the Object[] method.
// * The format is that of Java source code, for example {1.0,2.0}.
// *
// * @param array the array to get a toString for, must not be null
// * @return a String representation of the array
// * @throws IllegalArgumentException if the array is null
// */
// public static String toString(double[] array) {
// return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
// }
//
// /**
// * Output the array as a String.
// * <p>
// * Multi-dimensional arrays are handled by the Object[] method.
// * The format is that of Java source code, for example {1.0,2.0}.
// *
// * @param array the array to get a toString for, must not be null
// * @return a String representation of the array
// * @throws IllegalArgumentException if the array is null
// */
// public static String toString(float[] array) {
// return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
// }
//
// /**
// * Output the array as a String.
// * <p>
// * Multi-dimensional arrays are handled by the Object[] method.
// * The format is that of Java source code, for example {true,false}.
// *
// * @param array the array to get a toString for, must not be null
// * @return a String representation of the array
// * @throws IllegalArgumentException if the array is null
// */
// public static String toString(boolean[] array) {
// return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
// }
//--------------------------------------------------------------------------
/**
* Shallow clones an array returning a typecast result and handling null.
* <p>
* The objecs in the array are not cloned.
*
* @param array the array to shallow clone, may not be null
* @return the cloned array, or null if null passed in
*/
public static Object[] clone(Object[] array) {
if (array == null) {
return null;
}
return (Object[]) array.clone();
}
/**
* Clones an array returning a typecast result and handling null.
*
* @param array the array to clone, may not be null
* @return the cloned array, or null if null passed in
*/
public static long[] clone(long[] array) {
if (array == null) {
return null;
}
return (long[]) array.clone();
}
/**
* Clones an array returning a typecast result and handling null.
*
* @param array the array to clone, may not be null
* @return the cloned array, or null if null passed in
*/
public static int[] clone(int[] array) {
if (array == null) {
return null;
}
return (int[]) array.clone();
}
/**
* Clones an array returning a typecast result and handling null.
*
* @param array the array to clone, may not be null
* @return the cloned array, or null if null passed in
*/
public static short[] clone(short[] array) {
if (array == null) {
return null;
}
return (short[]) array.clone();
}
/**
* Clones an array returning a typecast result and handling null.
*
* @param array the array to clone, may not be null
* @return the cloned array, or null if null passed in
*/
public static byte[] clone(byte[] array) {
if (array == null) {
return null;
}
return (byte[]) array.clone();
}
/**
* Clones an array returning a typecast result and handling null.
*
* @param array the array to clone, may not be null
* @return the cloned array, or null if null passed in
*/
public static double[] clone(double[] array) {
if (array == null) {
return null;
}
return (double[]) array.clone();
}
/**
* Clones an array returning a typecast result and handling null.
*
* @param array the array to clone, may not be null
* @return the cloned array, or null if null passed in
*/
public static float[] clone(float[] array) {
if (array == null) {
return null;
}
return (float[]) array.clone();
}
/**
* Clones an array returning a typecast result and handling null.
*
* @param array the array to clone, may not be null
* @return the cloned array, or null if null passed in
*/
public static boolean[] clone(boolean[] array) {
if (array == null) {
return null;
}
return (boolean[]) array.clone();
}
//--------------------------------------------------------------------------
/**
* Checks whether two arrays are the same length, treating null arrays as length 0.
* Any multi-dimensional aspects of the arrays are ignored.
*
* @param array1 the first array, may be null
* @param array2 the second array, may be null
* @param true if length of arrays matches, treating null as an empty array
*/
public static boolean isSameLength(Object[] array1, Object[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* Checks whether two arrays are the same length, treating null arrays as length 0.
* Any multi-dimensional aspects of the arrays are ignored.
*
* @param array1 the first array, may be null
* @param array2 the second array, may be null
* @param true if length of arrays matches, treating null as an empty array
*/
public static boolean isSameLength(long[] array1, long[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* Checks whether two arrays are the same length, treating null arrays as length 0.
* Any multi-dimensional aspects of the arrays are ignored.
*
* @param array1 the first array, may be null
* @param array2 the second array, may be null
* @param true if length of arrays matches, treating null as an empty array
*/
public static boolean isSameLength(int[] array1, int[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* Checks whether two arrays are the same length, treating null arrays as length 0.
* Any multi-dimensional aspects of the arrays are ignored.
*
* @param array1 the first array, may be null
* @param array2 the second array, may be null
* @param true if length of arrays matches, treating null as an empty array
*/
public static boolean isSameLength(short[] array1, short[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* Checks whether two arrays are the same length, treating null arrays as length 0.
* Any multi-dimensional aspects of the arrays are ignored.
*
* @param array1 the first array, may be null
* @param array2 the second array, may be null
* @param true if length of arrays matches, treating null as an empty array
*/
public static boolean isSameLength(byte[] array1, byte[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* Checks whether two arrays are the same length, treating null arrays as length 0.
* Any multi-dimensional aspects of the arrays are ignored.
*
* @param array1 the first array, may be null
* @param array2 the second array, may be null
* @param true if length of arrays matches, treating null as an empty array
*/
public static boolean isSameLength(double[] array1, double[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* Checks whether two arrays are the same length, treating null arrays as length 0.
* Any multi-dimensional aspects of the arrays are ignored.
*
* @param array1 the first array, may be null
* @param array2 the second array, may be null
* @param true if length of arrays matches, treating null as an empty array
*/
public static boolean isSameLength(float[] array1, float[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* Checks whether two arrays are the same length, treating null arrays as length 0.
* Any multi-dimensional aspects of the arrays are ignored.
*
* @param array1 the first array, may be null
* @param array2 the second array, may be null
* @param true if length of arrays matches, treating null as an empty array
*/
public static boolean isSameLength(boolean[] array1, boolean[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* Checks whether two arrays are the same type taking into account
* multi-dimensional arrays.
*
* @param array1 the first array, must not be null
* @param array2 the second array, must not be null
* @param true if type of arrays matches
* @throws IllegalArgumentException if either array is null
*/
public static boolean isSameType(Object array1, Object array2) {
if (array1 == null || array2 == null) {
throw new IllegalArgumentException("The array must not be null");
}
return array1.getClass().getName().equals(array2.getClass().getName());
}
}