/*
* Copyright 2002-2013 the original author or authors.
*
* Licensed 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.springframework.data.gemfire.util;
import java.lang.reflect.Array;
import java.util.Arrays;
import org.springframework.util.ObjectUtils;
/**
* The ArrayUtils class is a utility class for working with Object arrays.
*
* @author David Turanski
* @author John Blum
* @see java.lang.reflect.Array
* @see java.util.Arrays
*/
public abstract class ArrayUtils {
/**
* Returns the given varargs {@code element} as an array.
*
* @param <T> Class type of the elements.
* @param elements variable list of arguments to return as an array.
* @return an arry for the given varargs {@code elements}.
*/
@SafeVarargs
public static <T> T[] asArray(T... elements) {
return elements;
}
/**
* Returns the given {@code array} if not {@literal null} or empty, otherwise returns the {@code defaultArray}.
*
* @param <T> {@link Class} type of the array elements.
* @param array array to evaluate.
* @param defaultArray array to return if the given {@code array} is {@literal null} or empty.
* @return the given {@code array} if not {@literal null} or empty otherwise return the {@code defaultArray}.
*/
public static <T> T[] defaultIfEmpty(T[] array, T[] defaultArray) {
return (!ObjectUtils.isEmpty(array) ? array : defaultArray);
}
/**
* Null-safe method to return the first element in the array or {@literal null}
* if the array is {@literal null} or empty.
*
* @param <T> Class type of the array elements.
* @param array the array from which to extract the first element.
* @return the first element in the array or {@literal null} if the array is null or empty.
* @see #getFirst(Object[], Object)
*/
public static <T> T getFirst(T[] array) {
return getFirst(array, null);
}
/**
* Null-safe method to return the first element in the array or the {@code defaultValue}
* if the array is {@literal null} or empty.
*
* @param <T> Class type of the array elements.
* @param array the array from which to extract the first element.
* @param defaultValue value to return if the array is {@literal null} or empty.
* @return the first element in the array or {@code defaultValue} if the array is {@literal null} or empty.
* @see #getFirst(Object[], Object)
*/
public static <T> T getFirst(T[] array, T defaultValue) {
return (isEmpty(array) ? defaultValue : array[0]);
}
/**
* Insert an element into the given array at position (index). The element is inserted at the given position
* and all elements afterwards are moved to the right.
*
* @param originalArray the array in which to insert the element.
* @param position an integer index (position) at which to insert the element in the array.
* @param element the element to insert into the array.
* @return a new array with the element inserted at position.
* @see java.lang.System#arraycopy(Object, int, Object, int, int)
* @see java.lang.reflect.Array#newInstance(Class, int)
*/
public static Object[] insert(Object[] originalArray, int position, Object element) {
Object[] newArray = (Object[]) Array.newInstance(originalArray.getClass().getComponentType(),
originalArray.length + 1);
// copy all elements before the given position (here, position refers to the length, or number of elements
// to be copied, excluding the element at originalArray[position]
if (position > 0) {
System.arraycopy(originalArray, 0, newArray, 0, position);
}
// insert
newArray[position] = element;
// copy remaining elements from originalArray, starting at position, to new array
if (position < originalArray.length) {
System.arraycopy(originalArray, position, newArray, position + 1, originalArray.length - position);
}
return newArray;
}
/**
* Determines whether the given array is empty or not.
*
* @param array the array to evaluate for emptiness.
* @return a boolean value indicating whether the given array is empty.
* @see #length(Object...)
*/
public static boolean isEmpty(Object[] array) {
return (length(array) == 0);
}
/**
* Null-safe operation to determine an array's length.
*
* @param array the array to determine it's length.
* @return the length of the given array or 0 if the array reference is null.
*/
public static int length(Object[] array) {
return (array != null ? array.length : 0);
}
/**
* Null-safe, empty array operation returning the given object array if not null or an empty object array
* if the array argument is null.
*
* @param <T> Class type of the array elements.
* @param array array of objects on which a null check is performed.
* @param componentType Class type of the array elements.
* @return the given object array if not null, otherwise return an empty object array.
* @see java.lang.reflect.Array#newInstance(Class, int)
*/
@SuppressWarnings("unchecked")
public static <T> T[] nullSafeArray(T[] array, Class<T> componentType) {
return (array != null ? array : (T[]) Array.newInstance(componentType, 0));
}
/**
* Remove an element from the given array at position (index). The element is removed at the specified position
* and all remaining elements are shifted to the left.
*
* @param originalArray the array from which to remove the element.
* @param position the integer index (position) indicating the element to remove from the array.
* @return a new array with the element at position in the originalArray removed.
* @see java.lang.System#arraycopy(Object, int, Object, int, int)
* @see java.lang.reflect.Array#newInstance(Class, int)
*/
public static Object[] remove(Object[] originalArray, int position) {
Object[] newArray = (Object[]) Array.newInstance(originalArray.getClass().getComponentType(),
originalArray.length - 1);
// copy all elements before position (here, position refers to the length, or number of elements to be copied
if (position > 0) {
System.arraycopy(originalArray, 0, newArray, 0, position);
}
// copy remaining elements after position from the originalArray
if (position < originalArray.length - 1) {
System.arraycopy(originalArray, position + 1, newArray, position, originalArray.length - 1 - position);
}
return newArray;
}
/**
* Sort the array of elements according to the elements natural ordering.
*
* @param <T> {@link Comparable} class type of the array elements.
* @param array array of elements to sort.
* @return the sorted array of elements.
* @see java.util.Arrays#sort(Object[])
*/
public static <T extends Comparable<T>> T[] sort(T[] array) {
Arrays.sort(array);
return array;
}
}