Próbuję przekonwertować ArrayList zawierającą obiekty Integer na pierwotne int [] za pomocą następującego fragmentu kodu, ale generuje błąd czasu kompilacji. Czy można konwertować w Javie?

List<Integer> x =  new ArrayList<Integer>();
int[] n = (int[])x.toArray(int[x.size()]);

Możesz konwertować, ale nie sądzę, że jest coś wbudowanego, aby to zrobić automatycznie:

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    for (int i=0; i < ret.length; i++)
    {
        ret[i] = integers.get(i).intValue();
    }
    return ret;
}

(Pamiętaj, że spowoduje to zgłoszenie wyjątku NullPointerException, jeśli jest w nim którykolwiek integerslub jakikolwiek element null.)

EDYCJA: Jak na komentarze, możesz użyć iteratora listy, aby uniknąć nieprzyjemnych kosztów z listami takimi jak LinkedList:

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    Iterator<Integer> iterator = integers.iterator();
    for (int i = 0; i < ret.length; i++)
    {
        ret[i] = iterator.next().intValue();
    }
    return ret;
}

Jeśli używasz java-8 jest też inny sposób, aby to zrobić.

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

Co to robi:

• uzyskiwanie Stream<Integer> z listy
• uzyskiwanie IntStreampoprzez mapowanie każdego elementu do siebie (funkcja tożsamości), rozpakowywanie intwartości przechowywanej przez każdy elementInteger obiekt (wykonywane automatycznie od Java 5)
• uzyskanie tablicy intprzez wywołanietoArray

Można również jawnie wywołać intValueza pomocą odwołania do metody, tj .:

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

Warto również wspomnieć, że możesz dostać, NullPointerExceptionjeśli masz jakieś nullodniesienia 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]

Google Guava

Google Guava zapewnia dobry sposób na to, dzwoniąc Ints.toArray.

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

Apache Commons ma klasę ArrayUtils, która ma metodę toPrimitive (), która właśnie to robi.

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, dość łatwo jest to zrobić samemu, zamiast korzystać z zewnętrznych bibliotek.

Uważam, że iterowanie przy użyciu iteratora listy jest lepszym pomysłem, ponieważ list.get(i)może mieć niską 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;
}

korzystanie z Dollara powinno być dość proste:

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

Planuję ulepszyć DSL, aby usunąć toArray()połączenie pośrednie

Działa mi to dobrze :)

Znalezione na https://www.techiedelight.com/convert-list-integer-array-int/

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

class ListUtil
{
    // Program to convert list of integer to array of int in Java
    public static void main(String args[])
    {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

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

        System.out.println(Arrays.toString(primitive));
    }
}

Zaskakuje 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 idź z Apache Commons

Jeśli używasz kolekcji Eclipse , możesz użyć tej collectInt()metody, aby przełączyć się z kontenera obiektów na pierwotny 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ć swój ArrayListna 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());

Uwaga: jestem osobą odpowiedzialną za kolekcje Eclipse.

Java 8:

int[] intArr = Arrays.stream(integerList).mapToInt(i->i).toArray();

Arrays.setAll ()

    List<Integer> x = new ArrayList<>(Arrays.asList(7, 9, 13));
    int[] n = new int[x.size()];
    Arrays.setAll(n, x::get);

    System.out.println("Array of primitive ints: " + Arrays.toString(n));

Wynik:

Tablica pierwotnych liczb całkowitych: [7, 9, 13]

Te same prace na tablicy longlub double, ale nie dla tablic boolean, char, byte, shortlub float. Jeśli masz naprawdę ogromną listę, istnieje nawet parallelSetAllmetoda, której możesz użyć zamiast tego.

Dla mnie jest to dobre i wystarczająco elokwentne, że nie chciałbym mieć biblioteki zewnętrznej ani używać do niej strumieni.

Link do dokumentacji: Arrays.setAll(int[], IntUnaryOperator)

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);
}

Niezbyt fantazyjne; ale hej, to działa ...

Bardzo proste jedno-liniowe rozwiązanie to:

Integer[] i = arrlist.stream().toArray(Integer[]::new);

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

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

Warto wspomnieć, że ArrayList należy zadeklarować w następujący sposób:

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

   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 arrjak zwykle int[].