You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@commons.apache.org by Benedikt Ritter <br...@apache.org> on 2015/06/28 11:02:47 UTC
Re: [1/2] [lang] Javadoc: Fix typo but working is still awkward.
Hello Gary,
it is not clear to me, what happened here. The diff looks like ArrayUtils
has been removed completely in this commit. What were you trying to do?
Benedikt
2015-06-27 23:44 GMT+02:00 <gg...@apache.org>:
> Repository: commons-lang
> Updated Branches:
> refs/heads/master 38e829fb3 -> 3ff366c3d
>
>
>
> http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3ff366c3/src/main/java/org/apache/commons/lang3/ArrayUtils.java
> ----------------------------------------------------------------------
> diff --git a/src/main/java/org/apache/commons/lang3/ArrayUtils.java
> b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
> index d9b6516..7a80e47 100644
> --- a/src/main/java/org/apache/commons/lang3/ArrayUtils.java
> +++ b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
> @@ -1,7893 +1,7893 @@
> -/*
> - * Licensed to the Apache Software Foundation (ASF) under one or more
> - * contributor license agreements. See the NOTICE file distributed with
> - * this work for additional information regarding copyright ownership.
> - * The ASF licenses this file to You under the Apache License, Version 2.0
> - * (the "License"); you may not use this file except in compliance with
> - * the License. You may obtain a copy of the License at
> - *
> - * http://www.apache.org/licenses/LICENSE-2.0
> - *
> - * Unless required by applicable law or agreed to in writing, software
> - * distributed under the License is distributed on an "AS IS" BASIS,
> - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> - * See the License for the specific language governing permissions and
> - * limitations under the License.
> - */
> -package org.apache.commons.lang3;
> -
> -import java.lang.reflect.Array;
> -import java.util.Arrays;
> -import java.util.BitSet;
> -import java.util.Comparator;
> -import java.util.HashMap;
> -import java.util.Map;
> -
> -import org.apache.commons.lang3.builder.EqualsBuilder;
> -import org.apache.commons.lang3.builder.HashCodeBuilder;
> -import org.apache.commons.lang3.builder.ToStringBuilder;
> -import org.apache.commons.lang3.builder.ToStringStyle;
> -import org.apache.commons.lang3.math.NumberUtils;
> -import org.apache.commons.lang3.mutable.MutableInt;
> -
> -/**
> - * <p>Operations on arrays, primitive arrays (like {@code int[]}) and
> - * primitive wrapper arrays (like {@code Integer[]}).</p>
> - *
> - * <p>This class tries to handle {@code null} input gracefully.
> - * An exception will not be thrown for a {@code null}
> - * array input. However, an Object array that contains a {@code null}
> - * element may throw an exception. Each method documents its
> behaviour.</p>
> - *
> - * <p>#ThreadSafe#</p>
> - * @since 2.0
> - */
> -public class ArrayUtils {
> -
> - /**
> - * An empty immutable {@code Object} array.
> - */
> - public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
> - /**
> - * An empty immutable {@code Class} array.
> - */
> - public static final Class<?>[] EMPTY_CLASS_ARRAY = new Class[0];
> - /**
> - * An empty immutable {@code String} array.
> - */
> - public static final String[] EMPTY_STRING_ARRAY = new String[0];
> - /**
> - * An empty immutable {@code long} array.
> - */
> - public static final long[] EMPTY_LONG_ARRAY = new long[0];
> - /**
> - * An empty immutable {@code Long} array.
> - */
> - public static final Long[] EMPTY_LONG_OBJECT_ARRAY = new Long[0];
> - /**
> - * An empty immutable {@code int} array.
> - */
> - public static final int[] EMPTY_INT_ARRAY = new int[0];
> - /**
> - * An empty immutable {@code Integer} array.
> - */
> - public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new
> Integer[0];
> - /**
> - * An empty immutable {@code short} array.
> - */
> - public static final short[] EMPTY_SHORT_ARRAY = new short[0];
> - /**
> - * An empty immutable {@code Short} array.
> - */
> - public static final Short[] EMPTY_SHORT_OBJECT_ARRAY = new Short[0];
> - /**
> - * An empty immutable {@code byte} array.
> - */
> - public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
> - /**
> - * An empty immutable {@code Byte} array.
> - */
> - public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = new Byte[0];
> - /**
> - * An empty immutable {@code double} array.
> - */
> - public static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
> - /**
> - * An empty immutable {@code Double} array.
> - */
> - public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = new
> Double[0];
> - /**
> - * An empty immutable {@code float} array.
> - */
> - public static final float[] EMPTY_FLOAT_ARRAY = new float[0];
> - /**
> - * An empty immutable {@code Float} array.
> - */
> - public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = new Float[0];
> - /**
> - * An empty immutable {@code boolean} array.
> - */
> - public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];
> - /**
> - * An empty immutable {@code Boolean} array.
> - */
> - public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = new
> Boolean[0];
> - /**
> - * An empty immutable {@code char} array.
> - */
> - public static final char[] EMPTY_CHAR_ARRAY = new char[0];
> - /**
> - * An empty immutable {@code Character} array.
> - */
> - public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = new
> Character[0];
> -
> - /**
> - * The index value when an element is not found in a list or array:
> {@code -1}.
> - * This value is returned by methods in this class and can also be
> used in comparisons with values returned by
> - * various method from {@link java.util.List}.
> - */
> - public static final int INDEX_NOT_FOUND = -1;
> -
> - /**
> - * <p>ArrayUtils instances should NOT be constructed in standard
> programming.
> - * Instead, the class should be used as <code>ArrayUtils.clone(new
> int[] {2})</code>.</p>
> - *
> - * <p>This constructor is public to permit tools that require a
> JavaBean instance
> - * to operate.</p>
> - */
> - public ArrayUtils() {
> - super();
> - }
> -
> -
> - // NOTE: Cannot use {@code} to enclose text which includes {}, but
> <code></code> is OK
> -
> -
> - // Basic methods handling multi-dimensional arrays
> -
> //-----------------------------------------------------------------------
> - /**
> - * <p>Outputs an array as a String, treating {@code null} as an empty
> array.</p>
> - *
> - * <p>Multi-dimensional arrays are handled correctly, including
> - * multi-dimensional primitive arrays.</p>
> - *
> - * <p>The format is that of Java source code, for example
> <code>{a,b}</code>.</p>
> - *
> - * @param array the array to get a toString for, may be {@code null}
> - * @return a String representation of the array, '{}' if null array
> input
> - */
> - public static String toString(final Object array) {
> - return toString(array, "{}");
> - }
> -
> - /**
> - * <p>Outputs an array as a String handling {@code null}s.</p>
> - *
> - * <p>Multi-dimensional arrays are handled correctly, including
> - * multi-dimensional primitive arrays.</p>
> - *
> - * <p>The format is that of Java source code, for example
> <code>{a,b}</code>.</p>
> - *
> - * @param array the array to get a toString for, may be {@code null}
> - * @param stringIfNull the String to return if the array is {@code
> null}
> - * @return a String representation of the array
> - */
> - public static String toString(final Object array, final String
> stringIfNull) {
> - if (array == null) {
> - return stringIfNull;
> - }
> - return new ToStringBuilder(array,
> ToStringStyle.SIMPLE_STYLE).append(array).toString();
> - }
> -
> - /**
> - * <p>Get a hash code for an array handling multi-dimensional arrays
> correctly.</p>
> - *
> - * <p>Multi-dimensional primitive arrays are also handled correctly
> by this method.</p>
> - *
> - * @param array the array to get a hash code for, {@code null}
> returns zero
> - * @return a hash code for the array
> - */
> - public static int hashCode(final Object array) {
> - return new HashCodeBuilder().append(array).toHashCode();
> - }
> -
> - /**
> - * <p>Compares two arrays, using equals(), handling multi-dimensional
> arrays
> - * correctly.</p>
> - *
> - * <p>Multi-dimensional primitive arrays are also handled correctly
> by this method.</p>
> - *
> - * @param array1 the left hand array to compare, may be {@code null}
> - * @param array2 the right hand array to compare, may be {@code null}
> - * @return {@code true} if the arrays are equal
> - * @deprecated this method has been replaced by {@code
> java.util.Objects.deepEquals(Object, Object)} and will be
> - * removed from future releases.
> - */
> - @Deprecated
> - public static boolean isEquals(final Object array1, final Object
> array2) {
> - return new EqualsBuilder().append(array1, array2).isEquals();
> - }
> -
> - // To map
> -
> //-----------------------------------------------------------------------
> - /**
> - * <p>Converts the given array into a {@link java.util.Map}. Each
> element of the array
> - * must be either a {@link java.util.Map.Entry} or an Array,
> containing at least two
> - * elements, where the first element is used as key and the second as
> - * value.</p>
> - *
> - * <p>This method can be used to initialize:</p>
> - * <pre>
> - * // Create a Map mapping colors.
> - * Map colorMap = MapUtils.toMap(new String[][] {{
> - * {"RED", "#FF0000"},
> - * {"GREEN", "#00FF00"},
> - * {"BLUE", "#0000FF"}});
> - * </pre>
> - *
> - * <p>This method returns {@code null} for a {@code null} input
> array.</p>
> - *
> - * @param array an array whose elements are either a {@link
> java.util.Map.Entry} or
> - * an Array containing at least two elements, may be {@code null}
> - * @return a {@code Map} that was created from the array
> - * @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 java.util.Map.Entry} and an Array
> - */
> - public static Map<Object, Object> toMap(final Object[] array) {
> - if (array == null) {
> - return null;
> - }
> - final Map<Object, Object> map = new HashMap<Object, Object>((int)
> (array.length * 1.5));
> - for (int i = 0; i < array.length; i++) {
> - final Object object = array[i];
> - if (object instanceof Map.Entry<?, ?>) {
> - final Map.Entry<?,?> entry = (Map.Entry<?,?>) object;
> - map.put(entry.getKey(), entry.getValue());
> - } else if (object instanceof Object[]) {
> - final 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;
> - }
> -
> - // Generic array
> -
> //-----------------------------------------------------------------------
> - /**
> - * <p>Create a type-safe generic array.</p>
> - *
> - * <p>The Java language does not allow an array to be created from a
> generic type:</p>
> - *
> - * <pre>
> - public static <T> T[] createAnArray(int size) {
> - return new T[size]; // compiler error here
> - }
> - public static <T> T[] createAnArray(int size) {
> - return (T[])new Object[size]; // ClassCastException at runtime
> - }
> - * </pre>
> - *
> - * <p>Therefore new arrays of generic types can be created with this
> method.
> - * For example, an array of Strings can be created:</p>
> - *
> - * <pre>
> - String[] array = ArrayUtils.toArray("1", "2");
> - String[] emptyArray = ArrayUtils.<String>toArray();
> - * </pre>
> - *
> - * <p>The method is typically used in scenarios, where the caller
> itself uses generic types
> - * that have to be combined into an array.</p>
> - *
> - * <p>Note, this method makes only sense to provide arguments of the
> same type so that the
> - * compiler can deduce the type of the array itself. While it is
> possible to select the
> - * type explicitly like in
> - * <code>Number[] array =
> ArrayUtils.<Number>toArray(Integer.valueOf(42),
> Double.valueOf(Math.PI))</code>,
> - * there is no real advantage when compared to
> - * <code>new Number[] {Integer.valueOf(42),
> Double.valueOf(Math.PI)}</code>.</p>
> - *
> - * @param <T> the array's element type
> - * @param items the varargs array items, null allowed
> - * @return the array, not null unless a null array is passed in
> - * @since 3.0
> - */
> - public static <T> T[] toArray(final T... items) {
> - return items;
> - }
> -
> - // Clone
> -
> //-----------------------------------------------------------------------
> - /**
> - * <p>Shallow clones an array returning a typecast result and handling
> - * {@code null}.</p>
> - *
> - * <p>The objects in the array are not cloned, thus there is no
> special
> - * handling for multi-dimensional arrays.</p>
> - *
> - * <p>This method returns {@code null} for a {@code null} input
> array.</p>
> - *
> - * @param <T> the component type of the array
> - * @param array the array to shallow clone, may be {@code null}
> - * @return the cloned array, {@code null} if {@code null} input
> - */
> - public static <T> T[] clone(final T[] array) {
> - if (array == null) {
> - return null;
> - }
> - return array.clone();
> - }
> -
> - /**
> - * <p>Clones an array returning a typecast result and handling
> - * {@code null}.</p>
> - *
> - * <p>This method returns {@code null} for a {@code null} input
> array.</p>
> - *
> - * @param array the array to clone, may be {@code null}
> - * @return the cloned array, {@code null} if {@code null} input
> - */
> - public static long[] clone(final long[] array) {
> - if (array == null) {
> - return null;
> - }
> - return array.clone();
> - }
> -
> - /**
> - * <p>Clones an array returning a typecast result and handling
> - * {@code null}.</p>
> - *
> - * <p>This method returns {@code null} for a {@code null} input
> array.</p>
> - *
> - * @param array the array to clone, may be {@code null}
> - * @return the cloned array, {@code null} if {@code null} input
> - */
> - public static int[] clone(final int[] array) {
> - if (array == null) {
> - return null;
> - }
> - return array.clone();
> - }
> -
> - /**
> - * <p>Clones an array returning a typecast result and handling
> - * {@code null}.</p>
> - *
> - * <p>This method returns {@code null} for a {@code null} input
> array.</p>
> - *
> - * @param array the array to clone, may be {@code null}
> - * @return the cloned array, {@code null} if {@code null} input
> - */
> - public static short[] clone(final short[] array) {
> - if (array == null) {
> - return null;
> - }
> - return array.clone();
> - }
> -
> - /**
> - * <p>Clones an array returning a typecast result and handling
> - * {@code null}.</p>
> - *
> - * <p>This method returns {@code null} for a {@code null} input
> array.</p>
> - *
> - * @param array the array to clone, may be {@code null}
> - * @return the cloned array, {@code null} if {@code null} input
> - */
> - public static char[] clone(final char[] array) {
> - if (array == null) {
> - return null;
> - }
> - return array.clone();
> - }
> -
> - /**
> - * <p>Clones an array returning a typecast result and handling
> - * {@code null}.</p>
> - *
> - * <p>This method returns {@code null} for a {@code null} input
> array.</p>
> - *
> - * @param array the array to clone, may be {@code null}
> - * @return the cloned array, {@code null} if {@code null} input
> - */
> - public static byte[] clone(final byte[] array) {
> - if (array == null) {
> - return null;
> - }
> - return array.clone();
> - }
> -
> - /**
> - * <p>Clones an array returning a typecast result and handling
> - * {@code null}.</p>
> - *
> - * <p>This method returns {@code null} for a {@code null} input
> array.</p>
> - *
> - * @param array the array to clone, may be {@code null}
> - * @return the cloned array, {@code null} if {@code null} input
> - */
> - public static double[] clone(final double[] array) {
> - if (array == null) {
> - return null;
> - }
> - return array.clone();
> - }
> -
> - /**
> - * <p>Clones an array returning a typecast result and handling
> - * {@code null}.</p>
> - *
> - * <p>This method returns {@code null} for a {@code null} input
> array.</p>
> - *
> - * @param array the array to clone, may be {@code null}
> - * @return the cloned array, {@code null} if {@code null} input
> - */
> - public static float[] clone(final float[] array) {
> - if (array == null) {
> - return null;
> - }
> - return array.clone();
> - }
> -
> - /**
> - * <p>Clones an array returning a typecast result and handling
> - * {@code null}.</p>
> - *
> - * <p>This method returns {@code null} for a {@code null} input
> array.</p>
> - *
> - * @param array the array to clone, may be {@code null}
> - * @return the cloned array, {@code null} if {@code null} input
> - */
> - public static boolean[] clone(final boolean[] array) {
> - if (array == null) {
> - return null;
> - }
> - return array.clone();
> - }
> -
> - // nullToEmpty
> -
> //-----------------------------------------------------------------------
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @param type the class representation of the desired array
> - * @return the same array, {@code public static} empty array if
> {@code null}
> - * @throws IllegalArgumentException if the type argument is null
> - * @since 3.5
> - */
> - public static <T> T[] nullToEmpty(final T[] array, final Class<T[]>
> type) {
> - if(type == null) {
> - throw new IllegalArgumentException("The type must not be
> null");
> - }
> -
> - if(array == null) {
> - return type.cast(Array.newInstance(type.getComponentType(),
> 0));
> - }
> - return array;
> - }
> -
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static Object[] nullToEmpty(final Object[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_OBJECT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 3.2
> - */
> - public static Class<?>[] nullToEmpty(final Class<?>[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_CLASS_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static String[] nullToEmpty(final String[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_STRING_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static long[] nullToEmpty(final long[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_LONG_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static int[] nullToEmpty(final int[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_INT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static short[] nullToEmpty(final short[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_SHORT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static char[] nullToEmpty(final char[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_CHAR_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static byte[] nullToEmpty(final byte[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_BYTE_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static double[] nullToEmpty(final double[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_DOUBLE_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static float[] nullToEmpty(final float[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_FLOAT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static boolean[] nullToEmpty(final boolean[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_BOOLEAN_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static Long[] nullToEmpty(final Long[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_LONG_OBJECT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static Integer[] nullToEmpty(final Integer[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_INTEGER_OBJECT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static Short[] nullToEmpty(final Short[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_SHORT_OBJECT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static Character[] nullToEmpty(final Character[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_CHARACTER_OBJECT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static Byte[] nullToEmpty(final Byte[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_BYTE_OBJECT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static Double[] nullToEmpty(final Double[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_DOUBLE_OBJECT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static Float[] nullToEmpty(final Float[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_FLOAT_OBJECT_ARRAY;
> - }
> - return array;
> - }
> -
> - /**
> - * <p>Defensive programming technique to change a {@code null}
> - * reference to an empty one.</p>
> - *
> - * <p>This method returns an empty array for a {@code null} input
> array.</p>
> - *
> - * <p>As a memory optimizing technique an empty array passed in will
> be overridden with
> - * the empty {@code public static} references in this class.</p>
> - *
> - * @param array the array to check for {@code null} or empty
> - * @return the same array, {@code public static} empty array if
> {@code null} or empty input
> - * @since 2.5
> - */
> - public static Boolean[] nullToEmpty(final Boolean[] array) {
> - if (isEmpty(array)) {
> - return EMPTY_BOOLEAN_OBJECT_ARRAY;
> - }
> - return array;
> - }
> -
> - // Subarrays
> -
> //-----------------------------------------------------------------------
> - /**
> - * <p>Produces a new array containing the elements between
> - * the start and end indices.</p>
> - *
> - * <p>The start index is inclusive, the end index exclusive.
> - * Null array input produces null output.</p>
> - *
> - * <p>The component type of the subarray is always the same as
> - * that of the input array. Thus, if the input is an array of type
> - * {@code Date}, the following usage is envisaged:</p>
> - *
> - * <pre>
> - * Date[] someDates = (Date[])ArrayUtils.subarray(allDates, 2, 5);
> - * </pre>
> - *
> - * @param <T> the component type of the array
> - * @param array the array
> - * @param startIndexInclusive the starting index. Undervalue (<0)
> - * is promoted to 0, overvalue (>array.length) results
> - * in an empty array.
> - * @param endIndexExclusive elements up to endIndex-1 are present in
> the
> - * returned subarray. Undervalue (< startIndex) produces
> - * empty array, overvalue (>array.length) is demoted to
> - * array length.
> - * @return a new array containing the elements between
> - * the start and end indices.
> - * @since 2.1
> - * @see Arrays#copyOfRange(Object[], int, int)
> - */
> - public static <T> T[] subarray(final T[] array, int
> startIndexInclusive, int endIndexExclusive) {
> - if (array == null) {
> - return null;
> - }
> - if (startIndexInclusive < 0) {
> - startIndexInclusive = 0;
> - }
> - if (endIndexExclusive > array.length) {
> - endIndexExclusive = array.length;
> - }
> - final int newSize = endIndexExclusive - startIndexInclusive;
> - final Class<?> type = array.getClass().getComponentType();
> - if (newSize <= 0) {
> - @SuppressWarnings("unchecked") // OK, because array is of
> type T
> - final T[] emptyArray = (T[]) Array.newInstance(type, 0);
> - return emptyArray;
> - }
> - @SuppressWarnings("unchecked") // OK, because array is of type T
> - final
> - T[] subarray = (T[]) Array.newInstance(type, newSize);
> - System.arraycopy(array, startIndexInclusive, subarray, 0,
> newSize);
> - return subarray;
> - }
> -
> - /**
> - * <p>Produces a new {@code long} array containing the elements
> - * between the start and end indices.</p>
> - *
> - * <p>The start index is inclusive, the end index exclusive.
> - * Null array input produces null output.</p>
> - *
> - * @param array the array
> - * @param startIndexInclusive the starting index. Undervalue (<0)
> - * is promoted to 0, overvalue (>array.length) results
> - * in an empty array.
> - * @param endIndexExclusive elements up to endIndex-1 are present in
> the
> - * returned subarray. Undervalue (< startIndex) produces
> - * empty array, overvalue (>array.length) is demoted to
> - * array length.
> - * @return a new array containing the elements between
> - * the start and end indices.
> - * @since 2.1
> - * @see Arrays#copyOfRange(long[], int, int)
> - */
> - public static long[] subarray(final long[] array, int
> startIndexInclusive, int endIndexExclusive) {
> - if (array == null) {
> - return null;
> - }
> - if (startIndexInclusive < 0) {
> - startIndexInclusive = 0;
> - }
> - if (endIndexExclusive > array.length) {
> - endIndexExclusive = array.length;
> - }
> - final int newSize = endIndexExclusive - startIndexInclusive;
> - if (newSize <= 0) {
> - return EMPTY_LONG_ARRAY;
> - }
> -
> - final long[] subarray = new long[newSize];
> - System.arraycopy(array, startIndexInclusive, subarray, 0,
> newSize);
> - return subarray;
> - }
> -
> - /**
> - * <p>Produces a new {@code int} array containing the elements
> - * between the start and end indices.</p>
> - *
> - * <p>The start index is inclusive, the end index exclusive.
> - * Null array input produces null output.</p>
> - *
> - * @param array the array
> - * @param startIndexInclusive the starting index. Undervalue (<0)
> - * is promoted to 0, overvalue (>array.length) results
> - * in an empty array.
> - * @param endIndexExclusive elements up to endIndex-1 are present in
> the
> - * returned subarray. Undervalue (< startIndex) produces
> - * empty array, overvalue (>array.length) is demoted to
> - * array length.
> - * @return a new array containing the elements between
> - * the start and end indices.
> - * @since 2.1
> - * @see Arrays#copyOfRange(int[], int, int)
> - */
> - public static int[] subarray(final int[] array, int
> startIndexInclusive, int endIndexExclusive) {
> - if (array == null) {
> - return null;
> - }
> - if (startIndexInclusive < 0) {
> - startIndexInclusive = 0;
> - }
> - if (endIndexExclusive > array.length) {
> - endIndexExclusive = array.length;
> - }
> - final int newSize = endIndexExclusive - startIndexInclusive;
> - if (newSize <= 0) {
> - return EMPTY_INT_ARRAY;
> - }
> -
> - final int[] subarray = new int[newSize];
> - System.arraycopy(array, startIndexInclusive, subarray, 0,
> newSize);
> - return subarray;
> - }
> -
> - /**
> - * <p>Produces a new {@code short} array containing the elements
> - * between the start and end indices.</p>
> - *
> - * <p>The start index is inclusive, the end index exclusive.
> - * Null array input produces null output.</p>
> - *
> - * @param array the array
> - * @param startIndexInclusive the starting index. Undervalue (<0)
> - * is promoted to 0, overvalue (>array.length) results
> - * in an empty array.
> - * @param endIndexExclusive elements up to endIndex-1 are present in
> the
> - * returned subarray. Undervalue (< startIndex) produces
> - * empty array, overvalue (>array.length) is demoted to
> - * array length.
> - * @return a new array containing the elements between
> - * the start and end indices.
> - * @since 2.1
> - * @see Arrays#copyOfRange(short[], int, int)
> - */
> - public static short[] subarray(final short[] array, int
> startIndexInclusive, int endIndexExclusive) {
> - if (array == null) {
> - return null;
> - }
> - if (startIndexInclusive < 0) {
> - startIndexInclusive = 0;
> - }
> - if (endIndexExclusive > array.length) {
> - endIndexExclusive = array.length;
> - }
> - final int newSize = endIndexExclusive - startIndexInclusive;
> - if (newSize <= 0) {
> - return EMPTY_SHORT_ARRAY;
> - }
> -
> - final short[] subarray = new short[newSize];
> - System.arraycopy(array, startIndexInclusive, subarray, 0,
> newSize);
> - return subarray;
> - }
> -
> - /**
> - * <p>Produces a new {@code char} array containing the elements
> - * between the start and end indices.</p>
> - *
> - * <p>The start index is inclusive, the end index exclusive.
> - * Null array input produces null output.</p>
> - *
> - * @param array the array
> - * @param startIndexInclusive the starting index. Undervalue (<0)
> - * is promoted to 0, overvalue (>array.length) results
> - * in an empty array.
> - * @param endIndexExclusive elements up to endIndex-1 are present in
> the
> - * returned subarray. Undervalue (< startIndex) produces
> - * empty array, overvalue (>array.length) is demoted to
> - * array length.
> - * @return a new array containing the elements between
> - * the start and end indices.
> - * @since 2.1
> - * @see Arrays#copyOfRange(char[], int, int)
> - */
> - public static char[] subarray(final char[] array, int
> startIndexInclusive, int endIndexExclusive) {
> - if (array == null) {
> - return null;
> - }
> - if (startIndexInclusive < 0) {
> - startIndexInclusive = 0;
> - }
> - if (endIndexExclusive > array.length) {
> - endIndexExclusive = array.length;
> - }
> - final int newSize = endIndexExclusive - startIndexInclusive;
> - if (newSize <= 0) {
> - return EMPTY_CHAR_ARRAY;
> - }
> -
> - final char[] subarray = new char[newSize];
> - System.arraycopy(array, startIndexInclusive, subarray, 0,
> newSize);
> - return subarray;
> - }
> -
> - /**
> - * <p>Produces a new {@code byte} array containing the elements
> - * between the start and end indices.</p>
> - *
> - * <p>The start index is inclusive, the end index exclusive.
> - * Null array input produces null output.</p>
> - *
> - * @param array the array
> - * @param startIndexInclusive the starting index. Undervalue (<0)
> - * is promoted to 0, overvalue (>array.length) results
> - * in an empty array.
> - * @param endIndexExclusive elements up to endIndex-1 are present in
> the
> - * returned subarray. Undervalue (< startIndex) produces
> - * empty array, overvalue (>array.length) is demoted to
> - * array length.
> - * @return a new array containing the elements between
> - * the start and end indices.
> - * @since 2.1
> - * @see Arrays#copyOfRange(byte[], int, int)
> - */
> - public static byte[] subarray(final byte[] array, int
> startIndexInclusive, int endIndexExclusive) {
> - if (array == null) {
> - return null;
> - }
> - if (startIndexInclusive < 0) {
> - startIndexInclusive = 0;
> - }
> - if (endIndexExclusive > array.length) {
> - endIndexExclusive = array.length;
> - }
> - final int newSize = endIndexExclusive - startIndexInclusive;
> - if (newSize <= 0) {
> - return EMPTY_BYTE_ARRAY;
> - }
> -
> - final byte[] subarray = new byte[newSize];
> - System.arraycopy(array, startIndexInclusive, subarray, 0,
> newSize);
> - return subarray;
> - }
> -
> - /**
> - * <p>Produces a new {@code double} array containing the elements
> - * between the start and end indices.</p>
> - *
> - * <p>The start index is inclusive, the end index exclusive.
> - * Null array input produces null output.</p>
> - *
> - * @param array the array
> - * @param startIndexInclusive the starting index. Undervalue (<0)
> - * is promoted to 0, overvalue (>array.length) results
> - * in an empty array.
> - * @param endIndexExclusive elements up to endIndex-1 are present in
> the
> - * returned subarray. Undervalue (< startIndex) produces
> - * empty array, overvalue (>array.length) is demoted to
> - * array length.
> - * @return a new array containing the elements between
> - * the start and end indices.
> - * @since 2.1
> - * @see Arrays#copyOfRange(double[], int, int)
> - */
> - public static double[] subarray(final double[] array, int
> startIndexInclusive, int endIndexExclusive) {
> - if (array == null) {
> - return null;
> - }
> - if (startIndexInclusive < 0) {
> - startIndexInclusive = 0;
> - }
> - if (endIndexExclusive > array.length) {
> - endIndexExclusive = array.length;
> - }
> - final int newSize = endIndexExclusive - startIndexInclusive;
> - if (newSize <= 0) {
> - return EMPTY_DOUBLE_ARRAY;
> - }
> -
> - final double[] subarray = new double[newSize];
> - System.arraycopy(array, startIndexInclusive, subarray, 0,
> newSize);
> - return subarray;
> - }
> -
> - /**
> - * <p>Produces a new {@code float} array containing the elements
> - * between the start and end indices.</p>
> - *
> - * <p>The start index is inclusive, the end index exclusive.
> - * Null array input produces null output.</p>
> - *
> - * @param array the array
> - * @param startIndexInclusive the starting index. Undervalue (<0)
> - * is promoted to 0, overvalue (>array.length) results
> - * in an empty array.
> - * @param endIndexExclusive elements up to endIndex-1 are present in
> the
> - * returned subarray. Undervalue (< startIndex) produces
> - * empty array, overvalue (>array.length) is demoted to
> - * array length.
> - * @return a new array containing the elements between
> - * the start and end indices.
> - * @since 2.1
> - * @see Arrays#copyOfRange(float[], int, int)
> - */
> - public static float[] subarray(final float[] array, int
> startIndexInclusive, int endIndexExclusive) {
> - if (array == null) {
> - return null;
> - }
> - if (startIndexInclusive < 0) {
> - startIndexInclusive = 0;
> - }
> - if (endIndexExclusive > array.length) {
> - endIndexExclusive = array.length;
> - }
> - final int newSize = endIndexExclusive - startIndexInclusive;
> - if (newSize <= 0) {
> - return EMPTY_FLOAT_ARRAY;
> - }
> -
> - final float[] subarray = new float[newSize];
> - System.arraycopy(array, startIndexInclusive, subarray, 0,
> newSize);
> - return subarray;
> - }
> -
> - /**
> - * <p>Produces a new {@code boolean} array containing the elements
> - * between the start and end indices.</p>
> - *
> - * <p>The start index is inclusive, the end index exclusive.
> - * Null array input produces null output.</p>
> - *
> - * @param array the array
> - * @param startIndexInclusive the starting index. Undervalue (<0)
> - * is promoted to 0, overvalue (>array.length) results
> - * in an empty array.
> - * @param endIndexExclusive elements up to endIndex-1 are present in
> the
> - * returned subarray. Undervalue (< startIndex) produces
> - * empty array, overvalue (>array.length) is demoted to
> - * array length.
> - * @return a new array containing the elements between
> - * the start and end indices.
> - * @since 2.1
> - * @see Arrays#copyOfRange(boolean[], int, int)
> - */
> - public static boolean[] subarray(final boolean[] array, int
> startIndexInclusive, int endIndexExclusive) {
> - if (array == null) {
> - return null;
> - }
> - if (startIndexInclusive < 0) {
> - startIndexInclusive = 0;
> - }
> - if (endIndexExclusive > array.length) {
> - endIndexExclusive = array.length;
> - }
> - final int newSize = endIndexExclusive - startIndexInclusive;
> - if (newSize <= 0) {
> - return EMPTY_BOOLEAN_ARRAY;
> - }
> -
> - final boolean[] subarray = new boolean[newSize];
> - System.arraycopy(array, startIndexInclusive, subarray, 0,
> newSize);
> - return subarray;
> - }
> -
> - // Is same length
> -
> //-----------------------------------------------------------------------
> - /**
> - * <p>Checks whether two arrays are the same length, treating
> - * {@code null} arrays as length {@code 0}.
> - *
> - * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
> - *
> - * @param array1 the first array, may be {@code null}
> - * @param array2 the second array, may be {@code null}
> - * @return {@code true} if length of arrays matches, treating
> - * {@code null} as an empty array
> - */
> - public static boolean isSameLength(final Object[] array1, final
> Object[] array2) {
> - return getLength(array1) == getLength(array2);
> - }
> -
> - /**
> - * <p>Checks whether two arrays are the same length, treating
> - * {@code null} arrays as length {@code 0}.</p>
> - *
> - * @param array1 the first array, may be {@code null}
> - * @param array2 the second array, may be {@code null}
> - * @return {@code true} if length of arrays matches, treating
> - * {@code null} as an empty array
> - */
> - public static boolean isSameLength(final long[] array1, final long[]
> array2) {
> - return getLength(array1) == getLength(array2);
> - }
> -
> - /**
> - * <p>Checks whether two arrays are the same length, treating
> - * {@code null} arrays as length {@code 0}.</p>
> - *
> - * @param array1 the first array, may be {@code null}
> - * @param array2 the second array, may be {@code null}
> - * @return {@code true} if length of arrays matches, treating
> - * {@code null} as an empty array
> - */
> - public static boolean isSameLength(final int[] array1, final int[]
> array2) {
> - return getLength(array1) == getLength(array2);
> - }
> -
> - /**
> - * <p>Checks whether two arrays are the same length, treating
> - * {@code null} arrays as length {@code 0}.</p>
> - *
> - * @param array1 the first array, may be {@code null}
> - * @param array2 the second array, may be {@code null}
> - * @return {@code true} if length of arrays matches, treating
> - * {@code null} as an empty array
> - */
> - public static boolean isSameLength(final short[] array1, final
> short[] array2) {
> - return getLength(array1) == getLength(array2);
> - }
> -
> - /**
> - * <p>Checks whether two arrays are the same length, treating
> - * {@code null} arrays as length {@code 0}.</p>
> - *
> - * @param array1 the first array, may be {@code null}
> - * @param array2 the second array, may be {@code null}
> - * @return {@code true} if length of arrays matches, treating
> - * {@code null} as an empty array
> - */
> - public static boolean isSameLength(final char[] array1, final char[]
> array2) {
> - return getLength(array1) == getLength(array2);
> - }
> -
> - /**
> - * <p>Checks whether two arrays are the same length, treating
> - * {@code null} arrays as length {@code 0}.</p>
> - *
> - * @param array1 the first array, may be {@code null}
> - * @param array2 the second array, may be {@code null}
> - * @return {@code true} if length of arrays matches, treating
> - * {@code null} as an empty array
> - */
> - public static boolean isSameLength(final byte[] array1, final byte[]
> array2) {
> - return getLength(array1) == getLength(array2);
> - }
> -
> - /**
> - * <p>Checks whether two arrays are the same length, treating
> - * {@code null} arrays as length {@code 0}.</p>
> - *
> - * @param array1 the first array, may be {@code null}
> - * @param array2 the second array, may be {@code null}
> - * @return {@code true} if length of arrays matches, treating
> - * {@code null} as an empty array
> - */
> - public static boolean isSameLength(final double[] array1, final
> double[] array2) {
> - return getLength(array1) == getLength(array2);
> - }
> -
> - /**
> - * <p>Checks whether two arrays are the same length, treating
> - * {@code null} arrays as length {@code 0}.</p>
> - *
> - * @param array1 the first array, may be {@code null}
> - * @param array2 the second array, may be {@code null}
> - * @return {@code true} if length of arrays matches, treating
> - * {@code null} as an empty array
> - */
> - public static boolean isSameLength(final float[] array1, final
> float[] array2) {
> - return getLength(array1) == getLength(array2);
> - }
> -
> - /**
> - * <p>Checks whether two arrays are the same length, treating
> - * {@code null} arrays as length {@code 0}.</p>
> - *
> - * @param array1 the first array, may be {@code null}
> - * @param array2 the second array, may be {@code null}
> - * @return {@code true} if length of arrays matches, treating
> - * {@code null} as an empty array
> - */
> - public static boolean isSameLength(final boolean[] array1, final
> boolean[] array2) {
> - return getLength(array1) == getLength(array2);
> - }
> -
> -
> //-----------------------------------------------------------------------
> - /**
> - * <p>Returns the length of the specified array.
> - * This method can deal with {@code Object} arrays and with primitive
> arrays.</p>
> - *
> - * <p>If the input array is {@code null}, {@code 0} is returned.</p>
> - *
> - * <pre>
> - * ArrayUtils.getLength(null) = 0
> - * ArrayUtils.getLength([]) = 0
> - * ArrayUtils.getLength([null]) = 1
> - * ArrayUtils.getLength([true, false]) = 2
> - * ArrayUtils.getLength([1, 2, 3]) = 3
> - * ArrayUtils.getLength(["a", "b", "c"]) = 3
> - * </pre>
> - *
> - * @param array the array to retrieve the length from, may be null
> - * @return The length of the array, or {@code 0} if the array is
> {@code null}
> - * @throws IllegalArgumentException if the object argument is not an
> array.
> - * @since 2.1
> - */
> - public static int getLength(final Object array) {
> - if (array == null) {
> - return 0;
> - }
> - return Array.getLength(array);
> - }
> -
> - /**
> - * <p>Checks whether two arrays are the same type taking into account
> - * multi-dimensional arrays.</p>
> - *
> - * @param array1 the first array, must not be {@code null}
> - * @param array2 the second array, must not be {@code null}
> - * @return {@code true} if type of arrays matches
> - * @throws IllegalArgumentException if either array is {@code null}
> - */
> - public static boolean isSameType(final Object array1, final Object
> array2) {
> - if (array1 == null || array2 == null) {
> - throw new IllegalArgumentException("The Array must not be
> null");
> - }
> - return
> array1.getClass().getName().equals(array2.getClass().getName());
> - }
> -
> - // Reverse
> -
> //-----------------------------------------------------------------------
> - /**
> - * <p>Reverses the order of the given array.</p>
> - *
> - * <p>There is no special handling for multi-dimensional arrays.</p>
> - *
> - * <p>This method does nothing for a {@code null} input array.</p>
> - *
> - * @param array the array to reverse, may be {@code null}
> - */
> - public static void reverse(final Object[] array) {
> - if (array == null) {
> - return;
> - }
> - reverse(array, 0, array.length);
> - }
> -
> - /**
> - * <p>Reverses the order of the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} input array.</p>
> - *
> - * @param array the array to reverse, may be {@code null}
> - */
> - public static void reverse(final long[] array) {
> - if (array == null) {
> - return;
> - }
> - reverse(array, 0, array.length);
> - }
> -
> - /**
> - * <p>Reverses the order of the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} input array.</p>
> - *
> - * @param array the array to reverse, may be {@code null}
> - */
> - public static void reverse(final int[] array) {
> - if (array == null) {
> - return;
> - }
> - reverse(array, 0, array.length);
> - }
> -
> - /**
> - * <p>Reverses the order of the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} input array.</p>
> - *
> - * @param array the array to reverse, may be {@code null}
> - */
> - public static void reverse(final short[] array) {
> - if (array == null) {
> - return;
> - }
> - reverse(array, 0, array.length);
> - }
> -
> - /**
> - * <p>Reverses the order of the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} input array.</p>
> - *
> - * @param array the array to reverse, may be {@code null}
> - */
> - public static void reverse(final char[] array) {
> - if (array == null) {
> - return;
> - }
> - reverse(array, 0, array.length);
> - }
> -
> - /**
> - * <p>Reverses the order of the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} input array.</p>
> - *
> - * @param array the array to reverse, may be {@code null}
> - */
> - public static void reverse(final byte[] array) {
> - if (array == null) {
> - return;
> - }
> - reverse(array, 0, array.length);
> - }
> -
> - /**
> - * <p>Reverses the order of the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} input array.</p>
> - *
> - * @param array the array to reverse, may be {@code null}
> - */
> - public static void reverse(final double[] array) {
> - if (array == null) {
> - return;
> - }
> - reverse(array, 0, array.length);
> - }
> -
> - /**
> - * <p>Reverses the order of the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} input array.</p>
> - *
> - * @param array the array to reverse, may be {@code null}
> - */
> - public static void reverse(final float[] array) {
> - if (array == null) {
> - return;
> - }
> - reverse(array, 0, array.length);
> - }
> -
> - /**
> - * <p>Reverses the order of the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} input array.</p>
> - *
> - * @param array the array to reverse, may be {@code null}
> - */
> - public static void reverse(final boolean[] array) {
> - if (array == null) {
> - return;
> - }
> - reverse(array, 0, array.length);
> - }
> -
> - /**
> - * <p>
> - * Reverses the order of the given array in the given range.
> - * </p>
> - *
> - * <p>
> - * This method does nothing for a {@code null} input array.
> - * </p>
> - *
> - * @param array
> - * the array to reverse, may be {@code null}
> - * @param startIndexInclusive
> - * the starting index. Undervalue (<0) is promoted to
> 0, overvalue (>array.length) results in no
> - * change.
> - * @param endIndexExclusive
> - * elements up to endIndex-1 are reversed in the array.
> Undervalue (< start index) results in no
> - * change. Overvalue (>array.length) is demoted to
> array length.
> - * @since 3.2
> - */
> - public static void reverse(final boolean[] array, final int
> startIndexInclusive, final int endIndexExclusive) {
> - if (array == null) {
> - return;
> - }
> - int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
> - int j = Math.min(array.length, endIndexExclusive) - 1;
> - boolean tmp;
> - while (j > i) {
> - tmp = array[j];
> - array[j] = array[i];
> - array[i] = tmp;
> - j--;
> - i++;
> - }
> - }
> -
> - /**
> - * <p>
> - * Reverses the order of the given array in the given range.
> - * </p>
> - *
> - * <p>
> - * This method does nothing for a {@code null} input array.
> - * </p>
> - *
> - * @param array
> - * the array to reverse, may be {@code null}
> - * @param startIndexInclusive
> - * the starting index. Undervalue (<0) is promoted to
> 0, overvalue (>array.length) results in no
> - * change.
> - * @param endIndexExclusive
> - * elements up to endIndex-1 are reversed in the array.
> Undervalue (< start index) results in no
> - * change. Overvalue (>array.length) is demoted to
> array length.
> - * @since 3.2
> - */
> - public static void reverse(final byte[] array, final int
> startIndexInclusive, final int endIndexExclusive) {
> - if (array == null) {
> - return;
> - }
> - int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
> - int j = Math.min(array.length, endIndexExclusive) - 1;
> - byte tmp;
> - while (j > i) {
> - tmp = array[j];
> - array[j] = array[i];
> - array[i] = tmp;
> - j--;
> - i++;
> - }
> - }
> -
> - /**
> - * <p>
> - * Reverses the order of the given array in the given range.
> - * </p>
> - *
> - * <p>
> - * This method does nothing for a {@code null} input array.
> - * </p>
> - *
> - * @param array
> - * the array to reverse, may be {@code null}
> - * @param startIndexInclusive
> - * the starting index. Undervalue (<0) is promoted to
> 0, overvalue (>array.length) results in no
> - * change.
> - * @param endIndexExclusive
> - * elements up to endIndex-1 are reversed in the array.
> Undervalue (< start index) results in no
> - * change. Overvalue (>array.length) is demoted to
> array length.
> - * @since 3.2
> - */
> - public static void reverse(final char[] array, final int
> startIndexInclusive, final int endIndexExclusive) {
> - if (array == null) {
> - return;
> - }
> - int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
> - int j = Math.min(array.length, endIndexExclusive) - 1;
> - char tmp;
> - while (j > i) {
> - tmp = array[j];
> - array[j] = array[i];
> - array[i] = tmp;
> - j--;
> - i++;
> - }
> - }
> -
> - /**
> - * <p>
> - * Reverses the order of the given array in the given range.
> - * </p>
> - *
> - * <p>
> - * This method does nothing for a {@code null} input array.
> - * </p>
> - *
> - * @param array
> - * the array to reverse, may be {@code null}
> - * @param startIndexInclusive
> - * the starting index. Undervalue (<0) is promoted to
> 0, overvalue (>array.length) results in no
> - * change.
> - * @param endIndexExclusive
> - * elements up to endIndex-1 are reversed in the array.
> Undervalue (< start index) results in no
> - * change. Overvalue (>array.length) is demoted to
> array length.
> - * @since 3.2
> - */
> - public static void reverse(final double[] array, final int
> startIndexInclusive, final int endIndexExclusive) {
> - if (array == null) {
> - return;
> - }
> - int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
> - int j = Math.min(array.length, endIndexExclusive) - 1;
> - double tmp;
> - while (j > i) {
> - tmp = array[j];
> - array[j] = array[i];
> - array[i] = tmp;
> - j--;
> - i++;
> - }
> - }
> -
> - /**
> - * <p>
> - * Reverses the order of the given array in the given range.
> - * </p>
> - *
> - * <p>
> - * This method does nothing for a {@code null} input array.
> - * </p>
> - *
> - * @param array
> - * the array to reverse, may be {@code null}
> - * @param startIndexInclusive
> - * the starting index. Undervalue (<0) is promoted to
> 0, overvalue (>array.length) results in no
> - * change.
> - * @param endIndexExclusive
> - * elements up to endIndex-1 are reversed in the array.
> Undervalue (< start index) results in no
> - * change. Overvalue (>array.length) is demoted to
> array length.
> - * @since 3.2
> - */
> - public static void reverse(final float[] array, final int
> startIndexInclusive, final int endIndexExclusive) {
> - if (array == null) {
> - return;
> - }
> - int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
> - int j = Math.min(array.length, endIndexExclusive) - 1;
> - float tmp;
> - while (j > i) {
> - tmp = array[j];
> - array[j] = array[i];
> - array[i] = tmp;
> - j--;
> - i++;
> - }
> - }
> -
> - /**
> - * <p>
> - * Reverses the order of the given array in the given range.
> - * </p>
> - *
> - * <p>
> - * This method does nothing for a {@code null} input array.
> - * </p>
> - *
> - * @param array
> - * the array to reverse, may be {@code null}
> - * @param startIndexInclusive
> - * the starting index. Undervalue (<0) is promoted to
> 0, overvalue (>array.length) results in no
> - * change.
> - * @param endIndexExclusive
> - * elements up to endIndex-1 are reversed in the array.
> Undervalue (< start index) results in no
> - * change. Overvalue (>array.length) is demoted to
> array length.
> - * @since 3.2
> - */
> - public static void reverse(final int[] array, final int
> startIndexInclusive, final int endIndexExclusive) {
> - if (array == null) {
> - return;
> - }
> - int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
> - int j = Math.min(array.length, endIndexExclusive) - 1;
> - int tmp;
> - while (j > i) {
> - tmp = array[j];
> - array[j] = array[i];
> - array[i] = tmp;
> - j--;
> - i++;
> - }
> - }
> -
> - /**
> - * <p>
> - * Reverses the order of the given array in the given range.
> - * </p>
> - *
> - * <p>
> - * This method does nothing for a {@code null} input array.
> - * </p>
> - *
> - * @param array
> - * the array to reverse, may be {@code null}
> - * @param startIndexInclusive
> - * the starting index. Undervalue (<0) is promoted to
> 0, overvalue (>array.length) results in no
> - * change.
> - * @param endIndexExclusive
> - * elements up to endIndex-1 are reversed in the array.
> Undervalue (< start index) results in no
> - * change. Overvalue (>array.length) is demoted to
> array length.
> - * @since 3.2
> - */
> - public static void reverse(final long[] array, final int
> startIndexInclusive, final int endIndexExclusive) {
> - if (array == null) {
> - return;
> - }
> - int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
> - int j = Math.min(array.length, endIndexExclusive) - 1;
> - long tmp;
> - while (j > i) {
> - tmp = array[j];
> - array[j] = array[i];
> - array[i] = tmp;
> - j--;
> - i++;
> - }
> - }
> -
> - /**
> - * <p>
> - * Reverses the order of the given array in the given range.
> - * </p>
> - *
> - * <p>
> - * This method does nothing for a {@code null} input array.
> - * </p>
> - *
> - * @param array
> - * the array to reverse, may be {@code null}
> - * @param startIndexInclusive
> - * the starting index. Undervalue (<0) is promoted to
> 0, overvalue (>array.length) results in no
> - * change.
> - * @param endIndexExclusive
> - * elements up to endIndex-1 are reversed in the array.
> Undervalue (< start index) results in no
> - * change. Overvalue (>array.length) is demoted to
> array length.
> - * @since 3.2
> - */
> - public static void reverse(final Object[] array, final int
> startIndexInclusive, final int endIndexExclusive) {
> - if (array == null) {
> - return;
> - }
> - int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
> - int j = Math.min(array.length, endIndexExclusive) - 1;
> - Object tmp;
> - while (j > i) {
> - tmp = array[j];
> - array[j] = array[i];
> - array[i] = tmp;
> - j--;
> - i++;
> - }
> - }
> -
> - /**
> - * <p>
> - * Reverses the order of the given array in the given range.
> - * </p>
> - *
> - * <p>
> - * This method does nothing for a {@code null} input array.
> - * </p>
> - *
> - * @param array
> - * the array to reverse, may be {@code null}
> - * @param startIndexInclusive
> - * the starting index. Undervalue (<0) is promoted to
> 0, overvalue (>array.length) results in no
> - * change.
> - * @param endIndexExclusive
> - * elements up to endIndex-1 are reversed in the array.
> Undervalue (< start index) results in no
> - * change. Overvalue (>array.length) is demoted to
> array length.
> - * @since 3.2
> - */
> - public static void reverse(final short[] array, final int
> startIndexInclusive, final int endIndexExclusive) {
> - if (array == null) {
> - return;
> - }
> - int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;
> - int j = Math.min(array.length, endIndexExclusive) - 1;
> - short tmp;
> - while (j > i) {
> - tmp = array[j];
> - array[j] = array[i];
> - array[i] = tmp;
> - j--;
> - i++;
> - }
> - }
> -
> - // Swap
> -
> //-----------------------------------------------------------------------
> - /**
> - * <p>Swaps two elements in the given array.</p>
> - *
> - * <p>There is no special handling for multi-dimensional arrays.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).</p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap(["1", "2", "3"], 0, 2) -> ["3", "2",
> "1"]</li>
> - * <li>ArrayUtils.swap(["1", "2", "3"], 0, 0) -> ["1", "2",
> "3"]</li>
> - * <li>ArrayUtils.swap(["1", "2", "3"], 1, 0) -> ["2", "1",
> "3"]</li>
> - * <li>ArrayUtils.swap(["1", "2", "3"], 0, 5) -> ["1", "2",
> "3"]</li>
> - * <li>ArrayUtils.swap(["1", "2", "3"], -1, 1) -> ["2", "1",
> "3"]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element to swap
> - * @param offset2 the index of the second element to swap
> - */
> - public static void swap(final Object[] array, int offset1, int
> offset2) {
> - if (array == null || array.length == 0) {
> - return;
> - }
> - swap(array, offset1, offset2, 1);
> - }
> -
> - /**
> - * <p>Swaps two elements in the given array.</p>
> - *
> - * <p>There is no special handling for multi-dimensional arrays.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).</p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([true, false, true], 0, 2) -> [true,
> false, true]</li>
> - * <li>ArrayUtils.swap([true, false, true], 0, 0) -> [true,
> false, true]</li>
> - * <li>ArrayUtils.swap([true, false, true], 1, 0) -> [false,
> true, true]</li>
> - * <li>ArrayUtils.swap([true, false, true], 0, 5) -> [true,
> false, true]</li>
> - * <li>ArrayUtils.swap([true, false, true], -1, 1) -> [false,
> true, true]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element to swap
> - * @param offset2 the index of the second element to swap
> - */
> - public static void swap(final long[] array, int offset1, int offset2)
> {
> - if (array == null || array.length == 0) {
> - return;
> - }
> - swap(array, offset1, offset2, 1);
> - }
> -
> - /**
> - * <p>Swaps two elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).</p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element to swap
> - * @param offset2 the index of the second element to swap
> - */
> - public static void swap(final int[] array, int offset1, int offset2) {
> - if (array == null || array.length == 0) {
> - return;
> - }
> - swap(array, offset1, offset2, 1);
> - }
> -
> - /**
> - * <p>Swaps two elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).</p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element to swap
> - * @param offset2 the index of the second element to swap
> - */
> - public static void swap(final short[] array, int offset1, int
> offset2) {
> - if (array == null || array.length == 0) {
> - return;
> - }
> - swap(array, offset1, offset2, 1);
> - }
> -
> - /**
> - * <p>Swaps two elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).</p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element to swap
> - * @param offset2 the index of the second element to swap
> - */
> - public static void swap(final char[] array, int offset1, int offset2)
> {
> - if (array == null || array.length == 0) {
> - return;
> - }
> - swap(array, offset1, offset2, 1);
> - }
> -
> - /**
> - * <p>Swaps two elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).</p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element to swap
> - * @param offset2 the index of the second element to swap
> - */
> - public static void swap(final byte[] array, int offset1, int offset2)
> {
> - if (array == null || array.length == 0) {
> - return;
> - }
> - swap(array, offset1, offset2, 1);
> - }
> -
> - /**
> - * <p>Swaps two elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).</p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element to swap
> - * @param offset2 the index of the second element to swap
> - */
> - public static void swap(final double[] array, int offset1, int
> offset2) {
> - if (array == null || array.length == 0) {
> - return;
> - }
> - swap(array, offset1, offset2, 1);
> - }
> -
> - /**
> - * <p>Swaps two elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).</p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element to swap
> - * @param offset2 the index of the second element to swap
> - */
> - public static void swap(final float[] array, int offset1, int
> offset2) {
> - if (array == null || array.length == 0) {
> - return;
> - }
> - swap(array, offset1, offset2, 1);
> - }
> -
> - /**
> - * <p>Swaps two elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).</p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]</li>
> - * <li>ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element to swap
> - * @param offset2 the index of the second element to swap
> - */
> - public static void swap(final boolean[] array, int offset1, int
> offset2) {
> - if (array == null || array.length == 0) {
> - return;
> - }
> - swap(array, offset1, offset2, 1);
> - }
> -
> - /**
> - * <p>Swaps a series of elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).
> - * If any of the sub-arrays to swap falls outside of the given array,
> - * then the swap is stopped at the end of the array and as many as
> possible elements are swapped.
> - * </p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([true, false, true, false], 0, 2, 1)
> -> [true, false, true, false]</li>
> - * <li>ArrayUtils.swap([true, false, true, false], 0, 0, 1)
> -> [true, false, true, false]</li>
> - * <li>ArrayUtils.swap([true, false, true, false], 0, 2, 2)
> -> [true, false, true, false]</li>
> - * <li>ArrayUtils.swap([true, false, true, false], -3, 2, 2)
> -> [true, false, true, false]</li>
> - * <li>ArrayUtils.swap([true, false, true, false], 0, 3, 3)
> -> [false, false, true, true]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element in the series to swap
> - * @param offset2 the index of the second element in the series to
> swap
> - * @param len the number of elements to swap starting with the given
> indices
> - */
> - public static void swap(final boolean[] array, int offset1, int
> offset2, int len) {
> - if (array == null || array.length == 0 || offset1 >= array.length
> || offset2 >= array.length) {
> - return;
> - }
> - if (offset1 < 0) {
> - offset1 = 0;
> - }
> - if (offset2 < 0) {
> - offset2 = 0;
> - }
> - len = Math.min(Math.min(len, array.length - offset1),
> array.length - offset2);
> - for (int i = 0; i < len; i++, offset1++, offset2++) {
> - boolean aux = array[offset1];
> - array[offset1] = array[offset2];
> - array[offset2] = aux;
> - }
> - }
> -
> - /**
> - * <p>Swaps a series of elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).
> - * If any of the sub-arrays to swap falls outside of the given array,
> - * then the swap is stopped at the end of the array and as many as
> possible elements are swapped.
> - * </p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1,
> 4]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3,
> 4]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1,
> 2]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1,
> 2]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3,
> 1]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element in the series to swap
> - * @param offset2 the index of the second element in the series to
> swap
> - * @param len the number of elements to swap starting with the given
> indices
> - */
> -
> - public static void swap(final byte[] array, int offset1, int
> offset2, int len) {
> - if (array == null || array.length == 0 || offset1 >= array.length
> || offset2 >= array.length) {
> - return;
> - }
> - if (offset1 < 0) {
> - offset1 = 0;
> - }
> - if (offset2 < 0) {
> - offset2 = 0;
> - }
> - len = Math.min(Math.min(len, array.length - offset1),
> array.length - offset2);
> - for (int i = 0; i < len; i++, offset1++, offset2++) {
> - byte aux = array[offset1];
> - array[offset1] = array[offset2];
> - array[offset2] = aux;
> - }
> - }
> -
> - /**
> - * <p>Swaps a series of elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).
> - * If any of the sub-arrays to swap falls outside of the given array,
> - * then the swap is stopped at the end of the array and as many as
> possible elements are swapped.
> - * </p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1,
> 4]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3,
> 4]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1,
> 2]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1,
> 2]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3,
> 1]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element in the series to swap
> - * @param offset2 the index of the second element in the series to
> swap
> - * @param len the number of elements to swap starting with the given
> indices
> - */
> - public static void swap(final char[] array, int offset1, int
> offset2, int len) {
> - if (array == null || array.length == 0 || offset1 >= array.length
> || offset2 >= array.length) {
> - return;
> - }
> - if (offset1 < 0) {
> - offset1 = 0;
> - }
> - if (offset2 < 0) {
> - offset2 = 0;
> - }
> - len = Math.min(Math.min(len, array.length - offset1),
> array.length - offset2);
> - for (int i = 0; i < len; i++, offset1++, offset2++) {
> - char aux = array[offset1];
> - array[offset1] = array[offset2];
> - array[offset2] = aux;
> - }
> - }
> -
> - /**
> - * <p>Swaps a series of elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).
> - * If any of the sub-arrays to swap falls outside of the given array,
> - * then the swap is stopped at the end of the array and as many as
> possible elements are swapped.
> - * </p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1,
> 4]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3,
> 4]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1,
> 2]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1,
> 2]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3,
> 1]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element in the series to swap
> - * @param offset2 the index of the second element in the series to
> swap
> - * @param len the number of elements to swap starting with the given
> indices
> - */
> - public static void swap(final double[] array, int offset1, int
> offset2, int len) {
> - if (array == null || array.length == 0 || offset1 >= array.length
> || offset2 >= array.length) {
> - return;
> - }
> - if (offset1 < 0) {
> - offset1 = 0;
> - }
> - if (offset2 < 0) {
> - offset2 = 0;
> - }
> - len = Math.min(Math.min(len, array.length - offset1),
> array.length - offset2);
> - for (int i = 0; i < len; i++, offset1++, offset2++) {
> - double aux = array[offset1];
> - array[offset1] = array[offset2];
> - array[offset2] = aux;
> - }
> - }
> -
> - /**
> - * <p>Swaps a series of elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).
> - * If any of the sub-arrays to swap falls outside of the given array,
> - * then the swap is stopped at the end of the array and as many as
> possible elements are swapped.
> - * </p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1,
> 4]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3,
> 4]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1,
> 2]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1,
> 2]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3,
> 1]</li>
> - * </ul>
> - * </p>
> - *
> - * @param array the array to swap, may be {@code null}
> - * @param offset1 the index of the first element in the series to swap
> - * @param offset2 the index of the second element in the series to
> swap
> - * @param len the number of elements to swap starting with the given
> indices
> - */
> - public static void swap(final float[] array, int offset1, int
> offset2, int len) {
> - if (array == null || array.length == 0 || offset1 >= array.length
> || offset2 >= array.length) {
> - return;
> - }
> - if (offset1 < 0) {
> - offset1 = 0;
> - }
> - if (offset2 < 0) {
> - offset2 = 0;
> - }
> - len = Math.min(Math.min(len, array.length - offset1),
> array.length - offset2);
> - for (int i = 0; i < len; i++, offset1++, offset2++) {
> - float aux = array[offset1];
> - array[offset1] = array[offset2];
> - array[offset2] = aux;
> - }
> -
> - }
> -
> - /**
> - * <p>Swaps a series of elements in the given array.</p>
> - *
> - * <p>This method does nothing for a {@code null} or empty input
> array or for overflow indices.
> - * Negative indices are promoted to 0(zero).
> - * If any of the sub-arrays to swap falls outside of the given array,
> - * then the swap is stopped at the end of the array and as many as
> possible elements are swapped.
> - * </p>
> - *
> - * <p>Examples:
> - * <ul>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1,
> 4]</li>
> - * <li>ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1
>
> <TRUNCATED>
>
--
http://people.apache.org/~britter/
http://www.systemoutprintln.de/
http://twitter.com/BenediktRitter
http://github.com/britter