int[] ints = {5,4,3,2,1};
ints.sort(); // instead of Arrays.sort(ints);
int pos = ints.indexOf(5); // instead of Arrays.asList(ints).indexOf(5); or ArraysUtils.indexOf(ints, 5);
ints.reverse(); // instead of Arrays.reverse(ints);
Array array = ints; // cast to super class.
int length = array.getLength(); // instead of Array.getLength(array);
Object n = array.get(3); // instead of Array.get(array, 3);
array.set(3, 7); // instead of Array.
Object obj = array;
System.out.println(obj); // prints [5,4,7,2,1] instead of having to if (obj instanceof int[]) System.out.println(Array.toString((int[]) obj)); else if (....)

int[] ints = {5,4,3,2,1};
int[] ints2 = ints.copyOf(2);
int[] ints3 = ints.subArray(2,4);
ints.sort(myComparator);
List<Integer> list = ints.asList();
Set<Integer> set = ints.asSet();
long total = ints.sum();
double avg = int.average();
int max = ints.max();
int max2 = ints.max(myComparator);
http://commons.apache.org/lang/api/org/apache/commons/lang/ArrayUtils.html
int[] onemore = ints.add(8); // instead of ArrayUtils.add(ints, 8);
int[] moreInts = ints.addAll(ints2); // instead of ArraysUtils.addAll(ints, ints2);
int[] oneless = int.remove(3); // instead of ArrayUtils.remove(ints, 3);
Integer[] integers = int.toObject();
int[] intsAgain = integers.toPrimitive();

int[] ints = {5, 4, 3, 2, 1};
System.out.println("ints= "+ints);
ints.sort_();
System.out.println("after sort() ints= "+ints);
ints = ints.add_(6);
System.out.println("after add(6) ints= "+ints);

ints= [5, 4, 3, 2, 1]
after sort() ints= [1, 2, 3, 4, 5]
after add(6) ints= [1, 2, 3, 4, 5, 6]

//// These method should be refactoring into an Array super class for arrays. ////
//// This is required to avoid poluting the name space of the Object class ////
//// Ideally, each primitive array type would have its own class to avoid the long instanceof chains ////
public String toString() {
    if (this instanceof boolean[])
        return Arrays.toString((boolean[]) this);
    if (this instanceof byte[])
        return Arrays.toString((byte[]) this);
    if (this instanceof short[])
        return Arrays.toString((short[]) this);
    if (this instanceof char[])
        return Arrays.toString((char[]) this);
    if (this instanceof int[])
        return Arrays.toString((int[]) this);
    if (this instanceof float[])
        return Arrays.toString((float[]) this);
    if (this instanceof long[])
        return Arrays.toString((long[]) this);
    if (this instanceof double[])
        return Arrays.toString((double[]) this);
    if (this instanceof Object[])
        return Arrays.toString((Object[]) this);
    return getClass().getName() + '@' + Integer.toHexString(hashCode());
}

public void sort_() {
    if (this instanceof byte[])
        Arrays.sort((byte[]) this);
    else if (this instanceof short[])
        Arrays.sort((short[]) this);
    else if (this instanceof char[])
        Arrays.sort((char[]) this);
    else if (this instanceof int[])
        Arrays.sort((int[]) this);
    else if (this instanceof float[])
        Arrays.sort((float[]) this);
    else if (this instanceof long[])
        Arrays.sort((long[]) this);
    else if (this instanceof double[])
        Arrays.sort((double[]) this);
    else if (this instanceof Object[])
        Arrays.sort((Object[]) this);
    else
        throw new AssertionError();
}

public <ArrayType, Element> ArrayType add_(Element element) {
    int length = Array.getLength(this);
    ArrayType array2 = (ArrayType) Array.newInstance(getClass().getComponentType(), length + 1);
    System.arraycopy(this, 0, array2, 0, length);
    Array.set(array2, length, element);
    return array2;
}

    public <ArrayType> void arraycopy(int  srcPos, ArrayType dest, int destPos, int length) {
        System.arraycopy(this, srcPos, dest, destPos, length);
    }

    /**
     * @return For arrays this is never null.
     */
    public Class<?> getComponentType() {
        return getClass().getComponentType();
    }

    /**
     * @return length of the array.
     */
    public int getLength() {
        return Array.getLength(this);
    }

    public <Element> Element get(int index) {
        return (Element) Array.get(this, index);
    }

    public <Element> void set(int index, Element element) {
        Array.set(this, index, element);
    }

    public <ArrayType, Element> ArrayType add(Element element) {
        int length = getLength();
        ArrayType array2 = (ArrayType) Array.newInstance(getComponentType(), length + 1);
        arraycopy(0, array2, 0, length);
        Array.set(array2, length, element);
        return array2;
    }

    public <ArrayType, Element> ArrayType addAll(Element... elements) {
        int length = getLength();
        ArrayType array2 = (ArrayType) Array.newInstance(getComponentType(), length + elements.length);
        arraycopy(0, array2, 0, length);
        System.arraycopy(elements, length, array2, length, elements.length);
        return array2;
    }

    public <Element> int indexOf(Element element) {
        int length = getLength();
        if (element == null)
            for (int i = 0; i < length; i++) {
                Object value = Array.get(this, i);
                if (value == null)
                    return i;
            }
        else
            for (int i = 0; i < length; i++) {
                Object value = Array.get(this, i);
                if (element.equals(value))
                    return i;
            }
        return -1;
    }

    public <ArrayType> ArrayType remove(int index) {
        int length = getLength();
        ArrayType array2 = (ArrayType) Array.newInstance(getComponentType(), length - 1);
        arraycopy(0, array2, 0, index);
        arraycopy(index+1, array2, index, length-index-1);
        return array2;
    }

    public <ArrayType, Element> ArrayType removeElement(Element element) {
        int index = indexOf(element);
        if (index < 0)
            return (ArrayType) this;
        return (ArrayType) remove(index);
    }