static Integer[] box(int[] array) {
        int num = array.length;
        Integer[] boxed = new Integer[num];
        for (int ct=0; ct<num; ++ct) {
            boxed[ct] = Integer.valueOf(array[ct]);
        }
        return boxed;
    }

Of course, changes made to the new array will not be updated in the old one.

To box arrays automatically would be even more confusing than
autoboxing. Consider:

    Integer[] boxed = array;
    boxed[0] = -1;
    array[0] = 42;
    System.out.println(boxed[0]);

If we assume autoboxing of arrays and array is an int[], then the code
will print -1. If array were an Integer[], then the code would print 42.

Alternatively, I guess you could produce (or find) a List<Integer>
implementation that backs to an int[] (a little like
java.util.Arrays.asList).

Tom Hawtin

int[] myInts; // and assigned as req'd
Integer[] myIntegers = new Integer[myInts.length];
int i = 0;
for(int val : myInts) myIntegers[i++] = val;

--
Mike W

There's no magic that will do this.  Whether there should be, is a
matter for debate.   If you are doing this so often that it's a problem,
write a utility function.  If it's a performance issue, rethink your
design so that you don't have to do this expensive conversion.

Allocate a new array and convert each element in a loop. see
http://mindprod.com/applets/conversion.html

The other way is much more drastic.  Use a pure OO language where
there is no logical distinction between int and Integer and the
compiler does it as an optimisation.