ArrayList<Integer> integersList = new ArrayList<>(Arrays.asList(1,2,3)); 
// 1、toArray()方法
Integer[] integersArrau = integersList.toArray(new Integer[integersList.size()]);

ArrayList<Integer> integersList = new ArrayList<>(Arrays.asList(1,2,3));
// 2、Stream流的toArray()方法
Integer[] integersArray2 = integersList.stream().toArray(Integer[]::new);

/**
 * Returns an array containing the elements of this stream, using the
 * provided {@code generator} function to allocate the returned array, as
 * well as any additional arrays that might be required for a partitioned
 * execution or for resizing.
 *
 * <p>This is a <a href="package-summary.html#StreamOps" rel="external nofollow" >terminal
 * operation</a>.
 *
 * @apiNote
 * The generator function takes an integer, which is the size of the
 * desired array, and produces an array of the desired size.  This can be
 * concisely expressed with an array constructor reference:
 * <pre>{@code
 *     Person[] men = people.stream()
 *                          .filter(p -> p.getGender() == MALE)
 *                          .toArray(Person[]::new);
 * }</pre>
 *
 * @param <A> the element type of the resulting array
 * @param generator a function which produces a new array of the desired
 *                  type and the provided length
 * @return an array containing the elements in this stream
 * @throws ArrayStoreException if the runtime type of the array returned
 * from the array generator is not a supertype of the runtime type of every
 * element in this stream
 */
<A> A[] toArray(IntFunction<A[]> generator);

Integer[] integersArray = {1, 2, 3};
// 1、使用Arrays.asList()
List<Integer> integersList = Arrays.asList(integersArray);

/**
 * Returns a fixed-size list backed by the specified array.  (Changes to
 * the returned list "write through" to the array.)  This method acts
 * as bridge between array-based and collection-based APIs, in
 * combination with {@link Collection#toArray}.  The returned list is
 * serializable and implements {@link RandomAccess}.
 *
 * <p>This method also provides a convenient way to create a fixed-size
 * list initialized to contain several elements:
 * <pre>
 *     List&lt;String&gt; stooges = Arrays.asList("Larry", "Moe", "Curly");
 * </pre>
 *
 * @param <T> the class of the objects in the array
 * @param a the array by which the list will be backed
 * @return a list view of the specified array
 */
@SafeVarargs
@SuppressWarnings("varargs")
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

Integer[] integersArray = {1, 2, 3};
// 2、使用Collections.addAll()
ArrayList<Integer> integersList2 = new ArrayList<>();
Collections.addAll(integersList2,integersArray);

Integer[] integersArray = {1, 2, 3};
// 3、使用Stream中的Collector
List<Integer> integersList3 = Arrays.stream(integersArray).collect(Collectors.toList());

ArrayList<Integer> integersList = new ArrayList<>(Arrays.asList(1,2,3));
// 1、Stream流執(zhí)行轉(zhuǎn)換
// 方法引用
int[] arrays1 = integersList.stream().mapToInt(Integer::intValue).toArray();
// lambda表達(dá)式
int[] arrays2 = integersList.stream().mapToInt(i -> i).toArray();

int[] integersArray = {1, 2, 3};
// 1、Stream流轉(zhuǎn)換
List<Integer> integersList = Arrays.stream(integersArray).mapToObj(Integer::new).collect(Collectors.toList());