这两天刚好在等待分配的过程中想着创建自己的代码库的，但是后来想想世界如此之大，咱想到的东东各位大牛基本上都免费提供了，为哈不双手接上呢，鼓掌，感谢！
好了，先说个 ArrayUtils 的大概吧：
顾名思义，这货就是用来进行 array 操作的哦。不过这个工具类很大有6000行左右的说，提供的功能也就相对来说比较完备的。大概有以下几大类方法(其实一般都是 overloading)：
- EMPTY_… 数组
这一类型的属性是不太会直接使用，一般会作为以下方法中的返回值
- toString
在操作数组的时候，往往我们会需要查看数组的具体值，尤其是在调试的时候，自己在进行相应的查看操作时通常会比较麻烦的。
下面代码使用的是 JDK 自带的工具方法，也是不错的选择，不过呢在 ArrayUtils 对于 null 值是可以指定替代的值。
System.out.println(Arrays.deepToString(array))- hashcode
生成一个数组的 hashCode，尤其是多维的数组哦
- toMap
这个应该算是创建 Map 的一个简便方案，主要是将二维数组转换为 Map，当然第二维需要有两位元素，分别作为 Map 的 key 和 value
- toArray
当我们有不定数量的同类型元素时便可以使用此方法，它为我们将提供的元素放入到数组中，然后返回，很大方有么有
- clone
对于数组的复制来说，使用这个方法最好不过了，首先 ArrayUtils 对其做了充分的 overloading，其次它的实现方式是调用数组类型本身的方法 clone()，要知道这个底层的实现是 native 方式的，那个速度可想而知了。
当然其实比较明显的是既然 ArrayUtils 自己都调用的是数组的内置方法为啥我们还要多此一举呢？确实这里边的差距不大，但是，如果需要克隆的 array 是个 null 呢？所以呢，ArrayUtils 还是为咱们省了点事儿的，不是说优秀的程序员都爱偷懒儿么：）
- nullToEmpty
想起第一个属性没？它就起到作用啦，只要 array 是 null 或者 array.length() == 0 那么你就会得到这个 Empty 数组，只是它是不可更改的单元素数组罢了，可以作为一个标志来使用
- subArray
同样，这个方法确实我们自己实现起来也不难，不过它做了大量的判断，最后通过调用 native 方法来提升元素复制的效率
- isSameLength
同样，精简比较过程，能处理 array 为 null 的情形
- getLength
通过 native 方式获取长度
- reverse
overloading 了许多的反转数组的方法，而且也支持反转数组中的部分子元素
- indexOf
这个方法的实现其实是有超出我的猜测的。在没有看之前自己想想是不是用了什么神奇的方法呢？用的还是比较朴素的做法，逐个比对。不过呢，在其的 overloading 中有对一次性查询多个相同数据的优化方案，这个会结合最后的方法进行解释的。
- lastIndexOf
和上一个类似，只是顺序调了个头。
- contains
这个的实现方式也有点出乎我的意料，原来是调用 indexOf 来判断的。
- toPrimitive
将数组元素统统转换为基本类型，当数组中存在 null 时一定要指定替换的值，否则不包含替代值的方法的调用会报错的，毕竟 null 与任意基本类型都没有对应值，所以一定注意。
- toObject
与上面方法的功能相反
- isEmpty
简化了的数组判断方法
- addAll
绝对的将两个数组进行合并哦，null数组也能搞定，只要给它，它就能帮你把它们给结合咯
- copyArrayGrow1
有没有觉得这个方法的名字高大上，非常清楚以至于我差点不相信自己的眼睛了。。说实话我重来没有在方法名称上使用过阿拉伯数字的说。顾名思义，先 copy 再增大 1 个空间。当然真正实现中是先创建一个 length + 1 的新数组的，然后么在用 native 方法进行 copy。
- add
额，忘记说了，上边那个方法是 private 的，人家是为此方法服务的，有木有很方便，数组的第一印象应该就是长度的不可变性吧:) 可是人家 ArrayUtils 就不吃你这套，帮咱们实现了数组的加法。神奇吧，不过调用的方法就是上边的 copyArrayGrow1，是不是很坦率。
- remove
如同 add， remove 的就过也能让数组长度少 1，这与 add 刚好是反过来的哈
- removeElement
这个与上一个方法的区别在于，上一个是根据元素的 index 来删的，而下一个则是要先找到指定的数组元素时才进行删除
- removeAll
这个方法还是蛮有意思的，下边会有贴出源代码供共赏
- removeElements
此方法与上边类似，只不过参数已经是相应的 数组下标了
重点介绍 removeAll，它也是一个 overloading 型选手：
static Object removeAll(final Object array, final int... indices) {
final int length = getLength(array);
int diff = 0; // 需要移掉的元素数量
if (isNotEmpty(indices)) {
Arrays.sort(indices);//排序对于进行移除有关键性的作用，从小到大
int i = indices.length;//总共移除的数量
int prevIndex = length;//从数组最后开始计算
while (--i >= 0) {//这里所做移除元素合法性的验证，以及去除掉超出数组范围的下标，重复的下标
final int index = indices[i];
if (index < 0 || index >= length) {
throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
}
if (index >= prevIndex) {
continue;
}
diff++;//只要符合情况就增加 1
prevIndex = index;
}
}
final Object result = Array.newInstance(array.getClass().getComponentType(), length - diff);//表示最终形成的新数组的长度
if (diff < length) {//如果要移除的数量等于数组本身的长度，肯定是个空数组了
int end = length; // 当前原数组的剩余长度
int dest = length - diff; // 当前未填充目标数组长度
for (int i = indices.length - 1; i >= 0; i--) {
final int index = indices[i];//指向第 i 个需要移除的元素
if (end - index > 1) { // 等价于 (cp > 0)，end 只是长度
final int cp = end - index - 1;
dest -= cp;//目标数组接收元素的起始下标
System.arraycopy(array, index + 1, result, dest, cp);
// Afer this copy, we still have room for dest items.
}
end = index;
}
if (end > 0) {//只要移除的下标不是0时，就需要执行此 block
System.arraycopy(array, 0, result, 0, end);
}
}
return result;
}另外一种 removeAll 与上一个方法是类似的，就补贴代码了，而调用它的方法(overloading)中使用了一个比较有意思的算法，贴出来共赏：
public static boolean[] removeElements(final boolean[] array, final boolean... values) {
if (isEmpty(array) || isEmpty(values)) {
return clone(array);//clone原数组
}
final HashMap<Boolean, MutableInt> occurrences = new HashMap<Boolean, MutableInt>(2); // boolean 型也就只有两种了，true , false :)
for (final boolean v : values) { // 这里就是这个算法的预处理了，很重要的哦
final Boolean boxed = Boolean.valueOf(v);
final MutableInt count = occurrences.get(boxed);
if (count == null) {
occurrences.put(boxed, new MutableInt(1));
} else {
count.increment(); // 最终统计出 false, true 分别移除的数量
}
}
final BitSet toRemove = new BitSet();
//这里做一件比较有意思的事
//我们可以出这样一道题目，给出一个数组和一组需要在数组中进行查询的数集合，让找出各自所对应的下标，而且允许有重复对象存在
//最普通的做法是穷举需要查找的数，与数组中元素一一比较，这个基本上就是o(NM)的复杂度了
//但是这个算法就高端点了，能力有限，还不清楚这个复杂度要咋写-_-||，大神了解的还望指点指点，感激不尽啊:)
//不过其实本质和普通方法一样，但是呢减少了对于重复元素的穷举所消耗的时间
for (final Map.Entry<Boolean, MutableInt> e : occurrences.entrySet()) {
final Boolean v = e.getKey();
int found = 0;
// 根据重复的个数进行相应次数的查找
for (int i = 0, ct = e.getValue().intValue(); i < ct; i++) {
found = indexOf(array, v.booleanValue(), found);
if (found < 0) {
break;
}
toRemove.set(found++);
}
}
return (boolean[]) removeAll(array, toRemove);
}有错误之处还请指出，谢拉 :)