List lst = new ArrayList();

    lst.add(new Integer(37));

    import java.util.Arrays;

    public class ArrayDemo1 {
        public static void main(String args[]) {
            int vec[] = {37, 47, 23, -5, 19, 56};
            Arrays.sort(vec);
            for (int i = 0; i < vec.length; i++) {
                System.out.println(vec[i]);
            }
        }
    }

    import java.util.Arrays;

    public class ArrayDemo2 {
        public static void main(String args[]) {
            int vec[] = {-5, 19, 23, 37, 47, 56};
            int slot = Arrays.binarySearch(vec, 35);
            slot = -(slot + 1);
            System.out.println("insertion point = " + slot);
        }
    }

    import java.util.Arrays;
    import java.lang.reflect.Array;
    
    public class ArrayDemo3 {
    
        // if input is a single-dimension primitive array,
        // return a new array consisting of wrapped elements,
        // else just return input argument
    
        public static Object toArray(Object vec) {
    
            // if null, return
    
            if (vec == null) {
                return vec;
            }
    
            // if not an array or elements not primitive, return
    
            Class cls = vec.getClass();
            if (!cls.isArray()) {
                return vec;
            }
            if (!cls.getComponentType().isPrimitive()) {
                return vec;
            }
    
            // get array length and create Object output array
    
            int length = Array.getLength(vec);
            Object newvec[] = new Object[length];
    
            // wrap and copy elements
    
            for (int i = 0; i < length; i++) {
                newvec[i] = Array.get(vec, i);
            }
    
            return newvec;
        }
    
        public static void main(String args[]) {
    
            // create a primitive array
    
            int vec[] = new int[]{1, 2, 3};
    
            // wrap it
    
            Object wrappedvec[] = (Object[])toArray(vec);
    
            // display result
    
            for (int i = 0; i < wrappedvec.length; i++) {
                System.out.println(wrappedvec[i]);
            }
        }
    }

    import java.util.Arrays;
    import java.util.List;

    public class ArrayDemo4 {
        public static void main(String args[]) {
            Object vec[] = {new Integer(37), new Integer(47)};
            List lst = Arrays.asList(vec);
            lst.set(1, new Integer(57));
            for (int i = 0; i < vec.length; i++) {
                System.out.println(vec[i]);
            }
        }
    }

在这个程序中，vec是一个对象数组，包含Integer(37)和Integer(47)，然后Arrays.asList被调用。它返回一个集合(List接口类型)，使用数组作为集合的后台存储。换言之，ArrayList这样的集合类型在它内部有某种存储类型去存储集合元素。在这个例子中，使用的存储类型是作为参数传递到Arrays.asList的数组。这意味着集合方法所做的改变会被反射到底层的数组。

修改集合中的元素1导致底层的数组也改变，程序的输出是：

37
57

因此如果你有一个对象数组，你可以在它上面使用集合特性，数组自身作为底层存储。

我们也可以将集合转换为一个对象数组，例如：

Object vec[] = lst.toArray();

摘自:http://www.javaresearch.org/article/showarticle.jsp?column=1&thread=2994