Here you can find the source of removeElement(boolean[] array, boolean element)
Removes the first occurrence of the specified element from the specified array.
| Parameter | Description |
|---|---|
| array | the array to remove the element from, may be <code>null</code> |
| element | the element to be removed |
public static boolean[] removeElement(boolean[] array, boolean element)
/*/*w w w . jav a2 s .com*/ * 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. */ import java.lang.reflect.Array; import java.util.HashMap; import java.util.Map; public class Main{ /** * The index value when an element is not found in a list or array: <code>-1</code>. * 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>Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn't contains * such an element, no elements are removed from the array.</p> * * <p>This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.</p> * * <pre> * ArrayUtils.removeElement(null, "a") = null * ArrayUtils.removeElement([], "a") = [] * ArrayUtils.removeElement(["a"], "b") = ["a"] * ArrayUtils.removeElement(["a", "b"], "a") = ["b"] * ArrayUtils.removeElement(["a", "b", "a"], "a") = ["b", "a"] * </pre> * * @param array the array to remove the element from, may be <code>null</code> * @param element the element to be removed * @return A new array containing the existing elements except the first * occurrence of the specified element. * @since 2.1 */ public static <T> T[] removeElement(T[] array, Object element) { int index = indexOf(array, element); if (index == INDEX_NOT_FOUND) { return clone(array); } return remove(array, index); } /** * <p>Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn't contains * such an element, no elements are removed from the array.</p> * * <p>This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.</p> * * <pre> * ArrayUtils.removeElement(null, true) = null * ArrayUtils.removeElement([], true) = [] * ArrayUtils.removeElement([true], false) = [true] * ArrayUtils.removeElement([true, false], false) = [true] * ArrayUtils.removeElement([true, false, true], true) = [false, true] * </pre> * * @param array the array to remove the element from, may be <code>null</code> * @param element the element to be removed * @return A new array containing the existing elements except the first * occurrence of the specified element. * @since 2.1 */ public static boolean[] removeElement(boolean[] array, boolean element) { int index = indexOf(array, element); if (index == INDEX_NOT_FOUND) { return clone(array); } return remove(array, index); } /** * <p>Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn't contains * such an element, no elements are removed from the array.</p> * * <p>This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.</p> * * <pre> * ArrayUtils.removeElement(null, 1) = null * ArrayUtils.removeElement([], 1) = [] * ArrayUtils.removeElement([1], 0) = [1] * ArrayUtils.removeElement([1, 0], 0) = [1] * ArrayUtils.removeElement([1, 0, 1], 1) = [0, 1] * </pre> * * @param array the array to remove the element from, may be <code>null</code> * @param element the element to be removed * @return A new array containing the existing elements except the first * occurrence of the specified element. * @since 2.1 */ public static byte[] removeElement(byte[] array, byte element) { int index = indexOf(array, element); if (index == INDEX_NOT_FOUND) { return clone(array); } return remove(array, index); } /** * <p>Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn't contains * such an element, no elements are removed from the array.</p> * * <p>This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.</p> * * <pre> * ArrayUtils.removeElement(null, 'a') = null * ArrayUtils.removeElement([], 'a') = [] * ArrayUtils.removeElement(['a'], 'b') = ['a'] * ArrayUtils.removeElement(['a', 'b'], 'a') = ['b'] * ArrayUtils.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a'] * </pre> * * @param array the array to remove the element from, may be <code>null</code> * @param element the element to be removed * @return A new array containing the existing elements except the first * occurrence of the specified element. * @since 2.1 */ public static char[] removeElement(char[] array, char element) { int index = indexOf(array, element); if (index == INDEX_NOT_FOUND) { return clone(array); } return remove(array, index); } /** * <p>Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn't contains * such an element, no elements are removed from the array.</p> * * <p>This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.</p> * * <pre> * ArrayUtils.removeElement(null, 1.1) = null * ArrayUtils.removeElement([], 1.1) = [] * ArrayUtils.removeElement([1.1], 1.2) = [1.1] * ArrayUtils.removeElement([1.1, 2.3], 1.1) = [2.3] * ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1] * </pre> * * @param array the array to remove the element from, may be <code>null</code> * @param element the element to be removed * @return A new array containing the existing elements except the first * occurrence of the specified element. * @since 2.1 */ public static double[] removeElement(double[] array, double element) { int index = indexOf(array, element); if (index == INDEX_NOT_FOUND) { return clone(array); } return remove(array, index); } /** * <p>Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn't contains * such an element, no elements are removed from the array.</p> * * <p>This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.</p> * * <pre> * ArrayUtils.removeElement(null, 1.1) = null * ArrayUtils.removeElement([], 1.1) = [] * ArrayUtils.removeElement([1.1], 1.2) = [1.1] * ArrayUtils.removeElement([1.1, 2.3], 1.1) = [2.3] * ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1] * </pre> * * @param array the array to remove the element from, may be <code>null</code> * @param element the element to be removed * @return A new array containing the existing elements except the first * occurrence of the specified element. * @since 2.1 */ public static float[] removeElement(float[] array, float element) { int index = indexOf(array, element); if (index == INDEX_NOT_FOUND) { return clone(array); } return remove(array, index); } /** * <p>Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn't contains * such an element, no elements are removed from the array.</p> * * <p>This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.</p> * * <pre> * ArrayUtils.removeElement(null, 1) = null * ArrayUtils.removeElement([], 1) = [] * ArrayUtils.removeElement([1], 2) = [1] * ArrayUtils.removeElement([1, 3], 1) = [3] * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1] * </pre> * * @param array the array to remove the element from, may be <code>null</code> * @param element the element to be removed * @return A new array containing the existing elements except the first * occurrence of the specified element. * @since 2.1 */ public static int[] removeElement(int[] array, int element) { int index = indexOf(array, element); if (index == INDEX_NOT_FOUND) { return clone(array); } return remove(array, index); } /** * <p>Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn't contains * such an element, no elements are removed from the array.</p> * * <p>This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.</p> * * <pre> * ArrayUtils.removeElement(null, 1) = null * ArrayUtils.removeElement([], 1) = [] * ArrayUtils.removeElement([1], 2) = [1] * ArrayUtils.removeElement([1, 3], 1) = [3] * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1] * </pre> * * @param array the array to remove the element from, may be <code>null</code> * @param element the element to be removed * @return A new array containing the existing elements except the first * occurrence of the specified element. * @since 2.1 */ public static long[] removeElement(long[] array, long element) { int index = indexOf(array, element); if (index == INDEX_NOT_FOUND) { return clone(array); } return remove(array, index); } /** * <p>Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn't contains * such an element, no elements are removed from the array.</p> * * <p>This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.</p> * * <pre> * ArrayUtils.removeElement(null, 1) = null * ArrayUtils.removeElement([], 1) = [] * ArrayUtils.removeElement([1], 2) = [1] * ArrayUtils.removeElement([1, 3], 1) = [3] * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1] * </pre> * * @param array the array to remove the element from, may be <code>null</code> * @param element the element to be removed * @return A new array containing the existing elements except the first * occurrence of the specified element. * @since 2.1 */ public static short[] removeElement(short[] array, short element) { int index = indexOf(array, element); if (index == INDEX_NOT_FOUND) { return clone(array); } return remove(array, index); } /** * <p>Finds the index of the given object in the array.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * @param array the array to search through for the object, may be <code>null</code> * @param objectToFind the object to find, may be <code>null</code> * @return the index of the object within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(Object[] array, Object objectToFind) { return indexOf(array, objectToFind, 0); } /** * <p>Finds the index of the given object in the array starting at the given index.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * <p>A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> * * @param array the array to search through for the object, may be <code>null</code> * @param objectToFind the object to find, may be <code>null</code> * @param startIndex the index to start searching at * @return the index of the object within the array starting at the index, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(Object[] array, Object objectToFind, int startIndex) { if (array == null) { return INDEX_NOT_FOUND; } if (startIndex < 0) { startIndex = 0; } if (objectToFind == null) { for (int i = startIndex; i < array.length; i++) { if (array[i] == null) { return i; } } } else if (array.getClass().getComponentType() .isInstance(objectToFind)) { for (int i = startIndex; i < array.length; i++) { if (objectToFind.equals(array[i])) { return i; } } } return INDEX_NOT_FOUND; } /** * <p>Finds the index of the given value in the array.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(long[] array, long valueToFind) { return indexOf(array, valueToFind, 0); } /** * <p>Finds the index of the given value in the array starting at the given index.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * <p>A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @param startIndex the index to start searching at * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(long[] array, long valueToFind, int startIndex) { if (array == null) { return INDEX_NOT_FOUND; } if (startIndex < 0) { startIndex = 0; } for (int i = startIndex; i < array.length; i++) { if (valueToFind == array[i]) { return i; } } return INDEX_NOT_FOUND; } /** * <p>Finds the index of the given value in the array.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(int[] array, int valueToFind) { return indexOf(array, valueToFind, 0); } /** * <p>Finds the index of the given value in the array starting at the given index.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * <p>A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @param startIndex the index to start searching at * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(int[] array, int valueToFind, int startIndex) { if (array == null) { return INDEX_NOT_FOUND; } if (startIndex < 0) { startIndex = 0; } for (int i = startIndex; i < array.length; i++) { if (valueToFind == array[i]) { return i; } } return INDEX_NOT_FOUND; } /** * <p>Finds the index of the given value in the array.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(short[] array, short valueToFind) { return indexOf(array, valueToFind, 0); } /** * <p>Finds the index of the given value in the array starting at the given index.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * <p>A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @param startIndex the index to start searching at * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(short[] array, short valueToFind, int startIndex) { if (array == null) { return INDEX_NOT_FOUND; } if (startIndex < 0) { startIndex = 0; } for (int i = startIndex; i < array.length; i++) { if (valueToFind == array[i]) { return i; } } return INDEX_NOT_FOUND; } /** * <p>Finds the index of the given value in the array.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input * @since 2.1 */ public static int indexOf(char[] array, char valueToFind) { return indexOf(array, valueToFind, 0); } /** * <p>Finds the index of the given value in the array starting at the given index.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * <p>A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @param startIndex the index to start searching at * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input * @since 2.1 */ public static int indexOf(char[] array, char valueToFind, int startIndex) { if (array == null) { return INDEX_NOT_FOUND; } if (startIndex < 0) { startIndex = 0; } for (int i = startIndex; i < array.length; i++) { if (valueToFind == array[i]) { return i; } } return INDEX_NOT_FOUND; } /** * <p>Finds the index of the given value in the array.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(byte[] array, byte valueToFind) { return indexOf(array, valueToFind, 0); } /** * <p>Finds the index of the given value in the array starting at the given index.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * <p>A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @param startIndex the index to start searching at * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(byte[] array, byte valueToFind, int startIndex) { if (array == null) { return INDEX_NOT_FOUND; } if (startIndex < 0) { startIndex = 0; } for (int i = startIndex; i < array.length; i++) { if (valueToFind == array[i]) { return i; } } return INDEX_NOT_FOUND; } /** * <p>Finds the index of the given value in the array.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(double[] array, double valueToFind) { return indexOf(array, valueToFind, 0); } /** * <p>Finds the index of the given value within a given tolerance in the array. * This method will return the index of the first value which falls between the region * defined by valueToFind - tolerance and valueToFind + tolerance.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @param tolerance tolerance of the search * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(double[] array, double valueToFind, double tolerance) { return indexOf(array, valueToFind, 0, tolerance); } /** * <p>Finds the index of the given value in the array starting at the given index.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * <p>A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @param startIndex the index to start searching at * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(double[] array, double valueToFind, int startIndex) { if (ArrayUtils.isEmpty(array)) { return INDEX_NOT_FOUND; } if (startIndex < 0) { startIndex = 0; } for (int i = startIndex; i < array.length; i++) { if (valueToFind == array[i]) { return i; } } return INDEX_NOT_FOUND; } /** * <p>Finds the index of the given value in the array starting at the given index. * This method will return the index of the first value which falls between the region * defined by valueToFind - tolerance and valueToFind + tolerance.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * <p>A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @param startIndex the index to start searching at * @param tolerance tolerance of the search * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(double[] array, double valueToFind, int startIndex, double tolerance) { if (ArrayUtils.isEmpty(array)) { return INDEX_NOT_FOUND; } if (startIndex < 0) { startIndex = 0; } double min = valueToFind - tolerance; double max = valueToFind + tolerance; for (int i = startIndex; i < array.length; i++) { if (array[i] >= min && array[i] <= max) { return i; } } return INDEX_NOT_FOUND; } /** * <p>Finds the index of the given value in the array.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(float[] array, float valueToFind) { return indexOf(array, valueToFind, 0); } /** * <p>Finds the index of the given value in the array starting at the given index.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * <p>A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @param startIndex the index to start searching at * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(float[] array, float valueToFind, int startIndex) { if (ArrayUtils.isEmpty(array)) { return INDEX_NOT_FOUND; } if (startIndex < 0) { startIndex = 0; } for (int i = startIndex; i < array.length; i++) { if (valueToFind == array[i]) { return i; } } return INDEX_NOT_FOUND; } /** * <p>Finds the index of the given value in the array.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input */ public static int indexOf(boolean[] array, boolean valueToFind) { return indexOf(array, valueToFind, 0); } /** * <p>Finds the index of the given value in the array starting at the given index.</p> * * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> * * <p>A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> * * @param array the array to search through for the object, may be <code>null</code> * @param valueToFind the value to find * @param startIndex the index to start searching at * @return the index of the value within the array, * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> * array input */ public static int indexOf(boolean[] array, boolean valueToFind, int startIndex) { if (ArrayUtils.isEmpty(array)) { return INDEX_NOT_FOUND; } if (startIndex < 0) { startIndex = 0; } for (int i = startIndex; i < array.length; i++) { if (valueToFind == array[i]) { return i; } } return INDEX_NOT_FOUND; } /** * <p>Shallow clones an array returning a typecast result and handling * <code>null</code>.</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</code> for a <code>null</code> input array.</p> * * @param array the array to shallow clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static <T> T[] clone(T[] array) { if (array == null) { return null; } return array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static long[] clone(long[] array) { if (array == null) { return null; } return array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static int[] clone(int[] array) { if (array == null) { return null; } return array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static short[] clone(short[] array) { if (array == null) { return null; } return array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static char[] clone(char[] array) { if (array == null) { return null; } return array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static byte[] clone(byte[] array) { if (array == null) { return null; } return array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static double[] clone(double[] array) { if (array == null) { return null; } return array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static float[] clone(float[] array) { if (array == null) { return null; } return array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static boolean[] clone(boolean[] array) { if (array == null) { return null; } return array.clone(); } /** * <p>Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).</p> * * <p>This method returns a new array with the same elements of the input * array except the element on the specified position. The component * type of the returned array is always the same as that of the input * array.</p> * * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.</p> * * <pre> * ArrayUtils.remove(["a"], 0) = [] * ArrayUtils.remove(["a", "b"], 0) = ["b"] * ArrayUtils.remove(["a", "b"], 1) = ["a"] * ArrayUtils.remove(["a", "b", "c"], 1) = ["a", "c"] * </pre> * * @param array the array to remove the element from, may not be <code>null</code> * @param index the position of the element to be removed * @return A new array containing the existing elements except the element * at the specified position. * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index >= array.length), or if the array is <code>null</code>. * @since 2.1 */ @SuppressWarnings("unchecked") // remove() always creates an array of the same type as its input public static <T> T[] remove(T[] array, int index) { return (T[]) remove((Object) array, index); } /** * <p>Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).</p> * * <p>This method returns a new array with the same elements of the input * array except the element on the specified position. The component * type of the returned array is always the same as that of the input * array.</p> * * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.</p> * * <pre> * ArrayUtils.remove([true], 0) = [] * ArrayUtils.remove([true, false], 0) = [false] * ArrayUtils.remove([true, false], 1) = [true] * ArrayUtils.remove([true, true, false], 1) = [true, false] * </pre> * * @param array the array to remove the element from, may not be <code>null</code> * @param index the position of the element to be removed * @return A new array containing the existing elements except the element * at the specified position. * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index >= array.length), or if the array is <code>null</code>. * @since 2.1 */ public static boolean[] remove(boolean[] array, int index) { return (boolean[]) remove((Object) array, index); } /** * <p>Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).</p> * * <p>This method returns a new array with the same elements of the input * array except the element on the specified position. The component * type of the returned array is always the same as that of the input * array.</p> * * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.</p> * * <pre> * ArrayUtils.remove([1], 0) = [] * ArrayUtils.remove([1, 0], 0) = [0] * ArrayUtils.remove([1, 0], 1) = [1] * ArrayUtils.remove([1, 0, 1], 1) = [1, 1] * </pre> * * @param array the array to remove the element from, may not be <code>null</code> * @param index the position of the element to be removed * @return A new array containing the existing elements except the element * at the specified position. * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index >= array.length), or if the array is <code>null</code>. * @since 2.1 */ public static byte[] remove(byte[] array, int index) { return (byte[]) remove((Object) array, index); } /** * <p>Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).</p> * * <p>This method returns a new array with the same elements of the input * array except the element on the specified position. The component * type of the returned array is always the same as that of the input * array.</p> * * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.</p> * * <pre> * ArrayUtils.remove(['a'], 0) = [] * ArrayUtils.remove(['a', 'b'], 0) = ['b'] * ArrayUtils.remove(['a', 'b'], 1) = ['a'] * ArrayUtils.remove(['a', 'b', 'c'], 1) = ['a', 'c'] * </pre> * * @param array the array to remove the element from, may not be <code>null</code> * @param index the position of the element to be removed * @return A new array containing the existing elements except the element * at the specified position. * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index >= array.length), or if the array is <code>null</code>. * @since 2.1 */ public static char[] remove(char[] array, int index) { return (char[]) remove((Object) array, index); } /** * <p>Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).</p> * * <p>This method returns a new array with the same elements of the input * array except the element on the specified position. The component * type of the returned array is always the same as that of the input * array.</p> * * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.</p> * * <pre> * ArrayUtils.remove([1.1], 0) = [] * ArrayUtils.remove([2.5, 6.0], 0) = [6.0] * ArrayUtils.remove([2.5, 6.0], 1) = [2.5] * ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8] * </pre> * * @param array the array to remove the element from, may not be <code>null</code> * @param index the position of the element to be removed * @return A new array containing the existing elements except the element * at the specified position. * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index >= array.length), or if the array is <code>null</code>. * @since 2.1 */ public static double[] remove(double[] array, int index) { return (double[]) remove((Object) array, index); } /** * <p>Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).</p> * * <p>This method returns a new array with the same elements of the input * array except the element on the specified position. The component * type of the returned array is always the same as that of the input * array.</p> * * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.</p> * * <pre> * ArrayUtils.remove([1.1], 0) = [] * ArrayUtils.remove([2.5, 6.0], 0) = [6.0] * ArrayUtils.remove([2.5, 6.0], 1) = [2.5] * ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8] * </pre> * * @param array the array to remove the element from, may not be <code>null</code> * @param index the position of the element to be removed * @return A new array containing the existing elements except the element * at the specified position. * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index >= array.length), or if the array is <code>null</code>. * @since 2.1 */ public static float[] remove(float[] array, int index) { return (float[]) remove((Object) array, index); } /** * <p>Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).</p> * * <p>This method returns a new array with the same elements of the input * array except the element on the specified position. The component * type of the returned array is always the same as that of the input * array.</p> * * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.</p> * * <pre> * ArrayUtils.remove([1], 0) = [] * ArrayUtils.remove([2, 6], 0) = [6] * ArrayUtils.remove([2, 6], 1) = [2] * ArrayUtils.remove([2, 6, 3], 1) = [2, 3] * </pre> * * @param array the array to remove the element from, may not be <code>null</code> * @param index the position of the element to be removed * @return A new array containing the existing elements except the element * at the specified position. * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index >= array.length), or if the array is <code>null</code>. * @since 2.1 */ public static int[] remove(int[] array, int index) { return (int[]) remove((Object) array, index); } /** * <p>Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).</p> * * <p>This method returns a new array with the same elements of the input * array except the element on the specified position. The component * type of the returned array is always the same as that of the input * array.</p> * * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.</p> * * <pre> * ArrayUtils.remove([1], 0) = [] * ArrayUtils.remove([2, 6], 0) = [6] * ArrayUtils.remove([2, 6], 1) = [2] * ArrayUtils.remove([2, 6, 3], 1) = [2, 3] * </pre> * * @param array the array to remove the element from, may not be <code>null</code> * @param index the position of the element to be removed * @return A new array containing the existing elements except the element * at the specified position. * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index >= array.length), or if the array is <code>null</code>. * @since 2.1 */ public static long[] remove(long[] array, int index) { return (long[]) remove((Object) array, index); } /** * <p>Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).</p> * * <p>This method returns a new array with the same elements of the input * array except the element on the specified position. The component * type of the returned array is always the same as that of the input * array.</p> * * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.</p> * * <pre> * ArrayUtils.remove([1], 0) = [] * ArrayUtils.remove([2, 6], 0) = [6] * ArrayUtils.remove([2, 6], 1) = [2] * ArrayUtils.remove([2, 6, 3], 1) = [2, 3] * </pre> * * @param array the array to remove the element from, may not be <code>null</code> * @param index the position of the element to be removed * @return A new array containing the existing elements except the element * at the specified position. * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index >= array.length), or if the array is <code>null</code>. * @since 2.1 */ public static short[] remove(short[] array, int index) { return (short[]) remove((Object) array, index); } /** * <p>Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).</p> * * <p>This method returns a new array with the same elements of the input * array except the element on the specified position. The component * type of the returned array is always the same as that of the input * array.</p> * * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.</p> * * @param array the array to remove the element from, may not be <code>null</code> * @param index the position of the element to be removed * @return A new array containing the existing elements except the element * at the specified position. * @throws IndexOutOfBoundsException if the index is out of range * (index < 0 || index >= array.length), or if the array is <code>null</code>. * @since 2.1 */ private static Object remove(Object array, int index) { int length = getLength(array); if (index < 0 || index >= length) { throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length); } Object result = Array.newInstance(array.getClass() .getComponentType(), length - 1); System.arraycopy(array, 0, result, 0, index); if (index < length - 1) { System.arraycopy(array, index + 1, result, index, length - index - 1); } return result; } /** * <p>Checks if an array of Objects is empty or <code>null</code>.</p> * * @param array the array to test * @return <code>true</code> if the array is empty or <code>null</code> * @since 2.1 */ public static boolean isEmpty(Object[] array) { return array == null || array.length == 0; } /** * <p>Checks if an array of primitive longs is empty or <code>null</code>.</p> * * @param array the array to test * @return <code>true</code> if the array is empty or <code>null</code> * @since 2.1 */ public static boolean isEmpty(long[] array) { return array == null || array.length == 0; } /** * <p>Checks if an array of primitive ints is empty or <code>null</code>.</p> * * @param array the array to test * @return <code>true</code> if the array is empty or <code>null</code> * @since 2.1 */ public static boolean isEmpty(int[] array) { return array == null || array.length == 0; } /** * <p>Checks if an array of primitive shorts is empty or <code>null</code>.</p> * * @param array the array to test * @return <code>true</code> if the array is empty or <code>null</code> * @since 2.1 */ public static boolean isEmpty(short[] array) { return array == null || array.length == 0; } /** * <p>Checks if an array of primitive chars is empty or <code>null</code>.</p> * * @param array the array to test * @return <code>true</code> if the array is empty or <code>null</code> * @since 2.1 */ public static boolean isEmpty(char[] array) { return array == null || array.length == 0; } /** * <p>Checks if an array of primitive bytes is empty or <code>null</code>.</p> * * @param array the array to test * @return <code>true</code> if the array is empty or <code>null</code> * @since 2.1 */ public static boolean isEmpty(byte[] array) { return array == null || array.length == 0; } /** * <p>Checks if an array of primitive doubles is empty or <code>null</code>.</p> * * @param array the array to test * @return <code>true</code> if the array is empty or <code>null</code> * @since 2.1 */ public static boolean isEmpty(double[] array) { return array == null || array.length == 0; } /** * <p>Checks if an array of primitive floats is empty or <code>null</code>.</p> * * @param array the array to test * @return <code>true</code> if the array is empty or <code>null</code> * @since 2.1 */ public static boolean isEmpty(float[] array) { return array == null || array.length == 0; } /** * <p>Checks if an array of primitive booleans is empty or <code>null</code>.</p> * * @param array the array to test * @return <code>true</code> if the array is empty or <code>null</code> * @since 2.1 */ public static boolean isEmpty(boolean[] array) { return array == null || array.length == 0; } /** * <p>Returns the length of the specified array. * This method can deal with <code>Object</code> arrays and with primitive arrays.</p> * * <p>If the input array is <code>null</code>, <code>0</code> 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</code> if the array is <code>null</code> * @throws IllegalArgumentException if the object arguement is not an array. * @since 2.1 */ public static int getLength(Object array) { if (array == null) { return 0; } return Array.getLength(array); } }