Jeśli używasz java-8 istnieje również inny sposób, aby to zrobić.

int[] arr = list.stream().mapToInt(i -> i).toArray();

To co robi to:

• uzyskanie Stream<Integer> z listy
W przeciwieństwie do Javy, Java nie jest w stanie tworzyć żadnych elementów składowych, które nie są w stanie tworzyć żadnych elementów składowych.]}
• uzyskanie tablicy int przez wywołanie toArray

Można również jawnie wywołać intValue poprzez odniesienie do metody, i. E:

int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

Warto również wspomnieć, że możesz uzyskać NullPointerException, Jeśli masz jakieś null odniesienie na liście. Można tego łatwo uniknąć, dodając warunek filtrowania do potoku strumienia w następujący sposób:

                       //.filter(Objects::nonNull) also works
int[] arr = list.stream().filter(i -> i != null).mapToInt(i -> i).toArray();

Przykład:

List<Integer> list = Arrays.asList(1, 2, 3, 4);
int[] arr = list.stream().mapToInt(i -> i).toArray(); //[1, 2, 3, 4]

list.set(1, null); //[1, null, 3, 4]
arr = list.stream().filter(i -> i != null).mapToInt(i -> i).toArray(); //[1, 3, 4]

Apache Commons ma klasę ArrayUtils, która ma metodę toPrimitive (), która robi dokładnie to.

import org.apache.commons.lang.ArrayUtils;
...
    List<Integer> list = new ArrayList<Integer>();
    list.add(new Integer(1));
    list.add(new Integer(2));
    int[] intArray = ArrayUtils.toPrimitive(list.toArray(new Integer[0]));

Jednak, jak pokazał Jon, całkiem łatwo jest to zrobić samemu, zamiast korzystać z zewnętrznych bibliotek.

Google Guava

Google Guava zapewnia schludny sposób, aby to zrobić, dzwoniąc Ints.toArray.

List<Integer> list = ...;
int[] values = Ints.toArray(list);

Uważam, że iteracja przy użyciu iteratora listy jest lepszym pomysłem, ponieważ list.get(i) może mieć słabą wydajność w zależności od implementacji listy:

private int[] buildIntArray(List<Integer> integers) {
    int[] ints = new int[integers.size()];
    int i = 0;
    for (Integer n : integers) {
        ints[i++] = n;
    }
    return ints;
}

Użycie dolara powinno być dość proste:

List<Integer> list = $(5).toList(); // the list 0, 1, 2, 3, 4  
int[] array = $($(list).toArray()).toIntArray();

Planuję ulepszyć DSL w celu usunięcia pośredniego połączenia toArray()

Jeśli używasz kolekcji Eclipse , możesz użyć metody collectInt(), aby przełączyć się z kontenera obiektu na prymitywny kontener int.

List<Integer> integers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
MutableIntList intList =
  ListAdapter.adapt(integers).collectInt(i -> i);
Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intList.toArray());

Jeśli możesz przekonwertować ArrayList na FastList, możesz pozbyć się adaptera.

Assert.assertArrayEquals(
  new int[]{1, 2, 3, 4, 5},
  Lists.mutable.with(1, 2, 3, 4, 5)
    .collectInt(i -> i).toArray());

Notatka: jestem committerem Dla Kolekcji Eclipse.

Dziwi mnie, że zachęcamy do jednorazowych niestandardowych metod, gdy doskonale dobra, dobrze używana biblioteka, taka jak Apache Commons, już rozwiązała problem. Chociaż rozwiązanie jest trywialne, jeśli nie absurdalne, nieodpowiedzialne jest zachęcanie do takiego zachowania ze względu na długoterminową konserwację i dostępność.

Po prostu wybierz Apache Commons

Możesz po prostu skopiować go do tablicy:

int[] arr = new int[list.size()];
for(int i = 0; i < list.size(); i++) {
    arr[i] = list.get(i);
}

Ten segment kodu działa dla mnie, spróbuj tego

Integer[] arr = x.toArray(new Integer[x.size()]);

   List<Integer> list = new ArrayList<Integer>();

    list.add(1);
    list.add(2);

    int[] result = null;
    StringBuffer strBuffer = new StringBuffer();
    for (Object o : list) {
        strBuffer.append(o);
        result = new int[] { Integer.parseInt(strBuffer.toString()) };
        for (Integer i : result) {
            System.out.println(i);
        }
        strBuffer.delete(0, strBuffer.length());
    }

Integer[] arr = (Integer[]) x.toArray(new Integer[x.size()]);

Dostęp arr jak normalny int[].