更新日期：2010年9月4日
ArrayUtils类概述
数组是我们经常需要使用到的一种数据结构，但是由于Java本身并没有提供很好的API支持，使得很多操作实际上做起来相当繁琐，以至于我们实际编码中甚至
会不惜牺牲性能去使用Collections
API，用Collection当然能够很方便的解决我们的问题，但是我们一定要以性能为代价吗？ArrayUtils帮我们解决了处理类似情况的大部分问题。
代码版本：apache.commons.lang3.0
1 add()
2.1 添加一个基本数据类型的数据到数组最后
boolean[] add(boolean[] array, boolean element)
byte[] add(byte[] array, byte element)
char[] add(char[] array, char element)
double[] add(double[] array, double element)
float[] add(float[] array, float element)
int[] add(int[] array, int element)
long[] add(long[] array, long element)
short[] add(short[] array, short element)
功能：添加一个元素到数组，所有元素必须是同一类型
生成一个新的数组，将新元素添加到数组的最后，而不改变原来数组的长度
代码精解
Object copyArrayGrow1(Object array, Class newArrayComponentType)函数
if (array != null) {
int arrayLength = Array.getLength(array);//获取数组长度
//创建一个新数组，并设置数组的类型和长度
Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
//将数组的内容复制到新数组中
System.arraycopy(array, 0, newArray, 0, arrayLength);
return newArray;
}
//如果数组为null，则需要外部传递元素类型，并将长度设置为1
return Array.newInstance(newArrayComponentType, 1);
add函数
int[] newArray = (int[])copyArrayGrow1(array, Integer.TYPE);//传递数组引用和元素类型
newArray[newArray.length - 1] = element;//将新元素直接赋值到最后一个
例：
ArrayUtils.add(null, '0') 结果为 ['0']
ArrayUtils.add(['1'], '0') 结果为 ['1', '0']
ArrayUtils.add(['1', '0'], '1') 结果为 ['1', '0', '1']
2.2 添加一个对象到数组最后
T[] add(T[] array, T element)
功能：复制给定的数组中所有的元素，并将新元素插入到新数组的最后
所有的元素必须是同一类型
生成一个新的数组，将新元素添加到数组的最后，而不改变原来数组的长度
代码精解
Class type;
if (array != null){
type = array.getClass(); //如果数组不为null，获取数组中的元素类型
} else if (element != null) {
type = element.getClass(); //如果数组为空但元素不为null，获取元素类型
}
T[] newArray = (T[]) copyArrayGrow1(array, type);
例：
ArrayUtils.add(null, null) 结果为 [null]
ArrayUtils.add(null, "a") 结果为 ["a"]
ArrayUtils.add(["a"], null) 结果为 ["a", null]
ArrayUtils.add(["a"], "b") 结果为 ["a", "b"]
ArrayUtils.add(["a", "b"], "c")结果为 ["a", "b", "c"]
2.3 添加一个基本数据元素到数组中的指定位置
char[] add(char[] array, int index, char element)
boolean[] add(boolean[] array, int index, boolean element)
byte[] add(byte[] array, int index, byte element
short[] add(short[] array, int index, short element)
int[] add(int[] array, int index, int element)
long[] add(long[] array, int index, long element)
float[] add(float[] array, int index, float element)
double[] add(double[] array, int index, double element)
功能：添加一个基本类型的数据到数组中指定位置
生成一个新的数组，将新元素添加到数组的指定位置，而不改变原来数组的长度
代码精解
return (int[]) add(array, index, Integer.valueOf(element), Integer.TYPE);
Object add(Object array, int index, Object element, Class clss)
int length = Array.getLength(array); //获取数组长度
if (index > length || index < 0) { //如果指定位置错误，则抛出异常
throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
}
Object result = Array.newInstance(clss, length + 1);//创建一个新数组，长度比旧的多一个
System.arraycopy(array, 0, result, 0, index); //将数组中所有元素复制到新数组中
Array.set(result, index, element); //将指定元素赋值给到新数组的指定位置，实际上覆盖了一个数据
if (index < length) {
//重新将数组中index之后的数据复制到新数组的index+1
System.arraycopy(array, index, result, index + 1, length - index);
}
例：
ArrayUtils.add([1], 0, 2) 结果为 [2, 1]
ArrayUtils.add([2, 6], 2, 10) 结果为 [2, 6, 10]
ArrayUtils.add([2, 6], 0, -4) 结果为 [-4, 2, 6]
ArrayUtils.add([2, 6, 3], 2, 1) 结果为 [2, 6, 1, 3]
2.4 添加一个对象到数组中的指定位置
T[] add(T[] array, int index, T element)
功能：添加一个对象到数组中指定位置
生成一个新的数组，将新元素添加到数组的指定位置，而不改变原来数组的长度
代码精解
Class clss = null;
if (array != null) {
clss = array.getClass().getComponentType();//如果数组不为空，获取数组中的元素类型
} else if (element != null) {
clss = element.getClass();//如果数组为空但元素为空，则获取插入元素的类型
}
final T[] newArray = (T[]) add(array, index, element, clss);
例：
ArrayUtils.add(null, 0, null) = [null]
ArrayUtils.add(null, 0, "a") = ["a"]
ArrayUtils.add(["a"], 1, null) = ["a", null]
ArrayUtils.add(["a"], 1, "b") = ["a", "b"]
ArrayUtils.add(["a", "b"], 3, "c") = ["a", "b", "c"]
注意：
1.元素类型的参数类型用Class表示
2.System.arraycopy的速度比直接赋值的速度快，复制的内容越多，就越多，详见http://www.blogjava.net/needjava/archive/2007/09/16/145513.html
2.addAll
2.1 合并以基本类型为元素的数组
格式
boolean[] addAll(boolean[] array1, boolean... array2)
char[] addAll(char[] array1, char... array2)
byte[] addAll(byte[] array1, byte... array2)
short[] addAll(short[] array1, short... array2)
int[] addAll(int[] array1, int... array2)
long[] addAll(long[] array1, long... array2)
float[] addAll(float[] array1, float... array2)
double[] addAll(double[] array1, double... array2)
功能
合并两个数组，首先包含array1,再包含array2，返回的是新数组，不改变已有的两个数组
代码精解
if (array1 == null) {
return clone(array2); //array1为空，且直接复制array2
} else if (array2 == null) {
return clone(array1);//array2为空，且直接复制array1
}
//生成一个新数组
char[] joinedArray = new char[array1.length + array2.length];
分别将两个数组内容复制到新数组
System.arraycopy(array1, 0, joinedArray, 0, array1.length);
System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
例
ArrayUtils.addAll(array1, null) 结果为 cloned copy of array1
ArrayUtils.addAll(null, array2) 结果为 cloned copy of array2
ArrayUtils.addAll([], []) 结果为 []
2.2合并以对象为元素的数组
格式
T[] addAll(T[] array1, T... array2)
功能
合并两个数组，首先包含array1,再包含array2，返回的是新数组，不改变已有的两个数组
代码精解
//获取array1的类型
final Class type1 = array1.getClass().getComponentType();
@SuppressWarnings("unchecked") // 忽略类型检查
//创建一个新数组，分别复制两个数组的内容到新数组
T[] joinedArray = (T[]) Array.newInstance(type1, array1.length + array2.length);
System.arraycopy(array1, 0, joinedArray, 0, array1.length);
System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
3.ArrayUtils.clone
格式
T[] clone(T[] array)
long[] clone(long[] array)
int[] clone(int[] array)
short[] clone(short[] array)
char[] clone(char[] array)
byte[] clone(byte[] array)
double[] clone(double[] array)
float[] clone(float[] array)
boolean[] clone(boolean[] array)
功能
克隆一个数组，如果数组为空，则返回null
代码精解
if (array == null) {
return null;
}
return array.clone();
4.ArrayUtils.contains
格式
boolean contains(Object[] array, Object objectToFind)
boolean contains(long[] array, long valueToFind)
boolean contains(int[] array, int valueToFind)
boolean contains(short[] array, short valueToFind)
boolean contains(char[] array, char valueToFind)
boolean contains(byte[] array, byte valueToFind)
boolean contains(double[] array, double valueToFind)
boolean contains(float[] array, float valueToFind)
boolean contains(boolean[] array, boolean valueToFind)
功能
检查一个元素是否在array中
代码精解
return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
INDEX_NOT_FOUND的值为-1
return indexOf(array, objectToFind, 0);
int indexOf(Object[] array, Object objectToFind, int startIndex)
//如果数组的类型与objectToFind的类型相同
if (array.getClass().getComponentType().isInstance(objectToFind)) {
for (int i = startIndex; i < array.length; i++) {
if (objectToFind.equals(array[i])) {
return i;
}
}
}
5.ArrayUtils.indexOf
格式
int indexOf(int[] array, int valueToFind)
功能
从数组的第0位置开始，检查valueToFind相同值的第一个元素出现的位置，
代码精解
for (int i = startIndex; i < array.length; i++) {
if (valueToFind == array[i]) {
return i;
}
}
6.ArrayUtils.isEmpty
格式
boolean isEmpty(T[] array)
boolean isEmpty(long[] array)
boolean isEmpty(int[] array)
boolean isEmpty(short[] array)
boolean isEmpty(char[] array)
boolean isEmpty(byte[] array)
boolean isEmpty(double[] array)
boolean isEmpty(float[] array)
boolean isEmpty(boolean[] array)
功能
检查数组是否为空
代码精解
if (array == null || array.length == 0) {
return true;
}
return false;
7.ArrayUtils.isEquals
格式
boolean isEquals(Object array1, Object array2)
功能
比较两个数组是否相同
关键代码
return new EqualsBuilder().append(array1, array2).isEquals();
例：
Object[] array3 = new Object[]{new String(new char[]{'A', 'B'})};
Object[] array4 = new Object[]{"AB"};
assertEquals(true, ArrayUtils.isEquals(array3, array3));
assertEquals(true, ArrayUtils.isEquals(array3, array4));
8.ArrayUtils.isSameLength
格式
boolean isSameLength(Object[] array1, Object[] array2)
boolean isSameLength(long[] array1, long[] array2)
boolean isSameLength(int[] array1, int[] array2)
boolean isSameLength(short[] array1, short[] array2)
boolean isSameLength(char[] array1, char[] array2)
boolean isSameLength(byte[] array1, byte[] array2)
boolean isSameLength(double[] array1, double[] array2)
boolean isSameLength(float[] array1, float[] array2)
boolean isSameLength(boolean[] array1, boolean[] array2)
功能
比较两个数组长度是否相同
代码精解
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
9.ArrayUtils.lastIndexOf
格式
int lastIndexOf(Object[] array, Object objectToFind)
int lastIndexOf(boolean[] array, boolean valueToFind)
int lastIndexOf(long[] array, long valueToFind)
int lastIndexOf(int[] array, int valueToFind)
int lastIndexOf(short[] array, short valueToFind)
int lastIndexOf(char[] array, char valueToFind)
int lastIndexOf(byte[] array, byte valueToFind)
功能
获取给定元素在数组中的最后位置
代码精解
return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
Integer.MAX_VALUE：整数的最大值
int lastIndexOf(byte[] array, byte valueToFind, int startIndex) {
if (array == null) {
return INDEX_NOT_FOUND;
}
if (startIndex < 0) {
return INDEX_NOT_FOUND;
} else if (startIndex >= array.length) {
startIndex = array.length - 1;//从数组的最后开始找
}
for (int i = startIndex; i >= 0; i--) {
if (valueToFind == array[i]) {
return i;
}
}
return INDEX_NOT_FOUND;
10.ArrayUtils.remove
格式
T[] remove(T[] array, int index)
boolean[] remove(boolean[] array, int index)
byte[] remove(byte[] array, int index)
char[] remove(char[] array, int index)
double[] remove(double[] array, int index)
float[] remove(float[] array, int index)
int[] remove(int[] array, int index)
long[] remove(long[] array, int index)
short[] remove(short[] array, int index)
功能
移除指定位置的元素
代码精解
//先将数组转换为Object类型
return (T[]) remove((Object) array, index);
return (char[]) remove((Object) array, index);
Object remove(Object array, int index)
int length = getLength(array);//获取数组长度
//创建一个新数组
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;
例
ArrayUtils.remove(["a"], 0) 的结果为 []
ArrayUtils.remove(["a", "b"], 0) 的结果为["b"]
ArrayUtils.remove(["a", "b"], 1) 的结果为 ["a"]
ArrayUtils.remove(["a", "b", "c"], 1) 的结果为 ["a", "c"]
11. 移除数组中的指定元素
格式
T[] removeElement(T[] array, Object element)
boolean[] removeElement(boolean[] array, boolean element)
byte[] removeElement(byte[] array, byte element)
char[] removeElement(char[] array, char element)
double[] removeElement(double[] array, double element)
float[] removeElement(float[] array, float element)
int[] removeElement(int[] array, int element)
long[] removeElement(long[] array, long element)
short[] removeElement(short[] array, short element)
功能
首先找到元素在数组中的第一个位置，在将这个元素移除，返回一个新数组
代码精解
int index = indexOf(array, element);
if (index == INDEX_NOT_FOUND) {
return clone(array);
}
return remove(array, index);
例
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"]
12.ArrayUtils.reverse
格式
void reverse(Object[] array)
void reverse(long[] array)
void reverse(int[] array)
void reverse(short[] array)
void reverse(char[] array)
void reverse(byte[] array)
void reverse(double[] array)
void reverse(float[] array)
void reverse(boolean[] array)
功能
颠倒数组，注意操作是在原数组上进行的
代码精解
int i = 0;
int j = array.length - 1;
Object tmp;
while (j > i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
13.ArrayUtils.subarray
13.1基本数组类型
格式
long[] subarray(long[] array, int startIndexInclusive, int endIndexExclusive)
int[] subarray(int[] array, int startIndexInclusive, int endIndexExclusive)
short[] subarray(short[] array, int startIndexInclusive, int endIndexExclusive)
char[] subarray(char[] array, int startIndexInclusive, int endIndexExclusive)
byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive)
double[] subarray(double[] array, int startIndexInclusive, int endIndexExclusive)
float[] subarray(float[] array, int startIndexInclusive, int endIndexExclusive)
boolean[] subarray(boolean[] array, int startIndexInclusive, int endIndexExclusive)
功能
根据起始位置和终止位置获取一个子数组，原数组不变，返回null，array[0]，array[n]
关键代码
int newSize = endIndexExclusive - startIndexInclusive; //获取新数组长度
if (newSize <= 0) {
return EMPTY_INT_ARRAY;
}
int[] subarray = new int[newSize];
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); //复制数组
return subarray;
13.2 对象数据类型
格式
T[] subarray(T[] array, int startIndexInclusive, int endIndexExclusive)
功能
根据起始位置和终止位置获取一个子数组，原数组不变，返回null，T[0]，T[n]
关键代码
int newSize = endIndexExclusive - startIndexInclusive;
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);//创建一个长度为0的对象数组
return emptyArray;
}
@SuppressWarnings("unchecked") // OK, because array is of type T
T[] subarray = (T[]) Array.newInstance(type, newSize);
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return subarray;
14.ArrayUtils.toMap
格式
Map toMap(Object[] array)
功能
将一个2维数组转换成Map，array至少是个二维数组
关键代码
//创新一个HashMap，长度为array.length的1.5倍？？
final Map map = new HashMap((int) (array.length * 1.5));
Object object = array[i];//获取一个数据，是一个长度为2的一维数组
if (object instanceof Map.Entry) { //如果可以转换为Entry
Map.Entry entry = (Map.Entry) object; //强制将一维数组转换为Map.Entry对象
map.put(entry.getKey(), entry.getValue());
}
例子：
Map map = ArrayUtils.toMap(new String[][] {{"foo", "bar"}, {"hello", "world"}});
map.get("foo")的值为bar
15.ArrayUtils.toString
格式
String toString(Object array)
String toString(Object array, String stringIfNull)
功能
将数组转换成字符串
关键代码
if (array == null) {
return stringIfNull;
}
return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
例
assertEquals("{}", ArrayUtils.toString(null));
assertEquals("{}", ArrayUtils.toString(new Object[0]));
assertEquals("{}", ArrayUtils.toString(new String[0]));
assertEquals("{pink,blue}", ArrayUtils.toString(new String[] {"pink","blue"}));
16.ArrayUtils.ToArray
格式
T[] toArray(final T... items)
功能
将多个参数转换成数组，参数的类型必须一致
关键代码
return items; //直接返回items，items就是数组
例
String[] array = ArrayUtils.toArray("foo", "bar");
阅读(2571) | 评论(0) | 转发(0) |
