Aşağıdaki kod parçası ile ilkel int [] tamsayı nesneleri içeren bir ArrayList dönüştürmek çalışıyorum, ama derleme zaman hatası atıyor. Java ile dönüştürmek mümkün mü?

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

Dönüştürebilirsiniz, ancak bunu otomatik olarak yapmak için yerleşik bir şey olduğunu düşünmüyorum:

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

( integersİçinde herhangi bir öğe varsa, bunun bir NullPointerException oluşturacağını unutmayın null.)

DÜZENLEME: Yorumlara göre, aşağıdaki gibi listelerle kötü maliyetlerden kaçınmak için liste yineleyicisini kullanmak isteyebilirsiniz 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;
}

Kullanıyorsanız Java-8 bunu yapmanın başka bir yolu daha var.

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

Yaptığı şey:

• Stream<Integer>listeden a almak
• Bir elde IntStreamkutusu açma, tek başına (bir kimlik fonksiyonu) her elemanın eşleyerek inther birinin değeri tutma Integernesnesi (Java 5 itibaren otomatik olarak yapılır)
• intarayarak dizi almaktoArray

Ayrıca intValuebir yöntem başvurusu aracılığıyla açıkça çağrı yapabilirsiniz , yani:

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

Listede NullPointerExceptionherhangi bir nullreferansınız varsa , alabileceğinizi de belirtmek gerekir . Akış boru hattına aşağıdaki gibi bir filtreleme koşulu eklenerek bu kolayca önlenebilir:

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

Misal:

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 , bunu arayarak temiz bir yol sağlar Ints.toArray.

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

Apache Commons, tam olarak bunu yapan birPrimitive () yöntemine sahip bir ArrayUtils sınıfına sahiptir.

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

Ancak, Jon'un gösterdiği gibi, bunu harici kütüphaneler kullanmak yerine kendiniz yapmak oldukça kolaydır.

list.get(i)List uygulamasına bağlı olarak düşük performans gösterebileceğinden, List'in yineleyicisini kullanarak yinelemenin daha iyi bir fikir olduğuna inanıyorum :

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

Dolar kullanmak oldukça basit olmalı:

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

Ara toArray()çağrıyı kaldırmak için DSL'yi geliştirmeyi planlıyorum

Bu benim için iyi çalışıyor :)

Https://www.techiedelight.com/convert-list-integer-array-int/ adresinde bulundu

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

Apache Commons gibi mükemmel, iyi kullanılmış bir kütüphane sorunu zaten çözdüğünde, bir kereye mahsus özel yöntemleri teşvik ettiğimizi şaşırtıyor. Çözüm saçma olmasa bile önemsiz olsa da, uzun süreli bakım ve erişilebilirlik nedeniyle böyle bir davranışı teşvik etmek sorumsuzdur.

Sadece Apache Commons ile git

Eğer kullanıyorsanız Eclipse Koleksiyonlar , kullanabileceğiniz collectInt()ilkel int kaba bir nesne kaptan anahtara yöntemi.

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

İstemiyorsun, mutfakta annene dönüştürebilirsiniz Eğer ArrayListbir etmek FastList, bağdaştırıcı kurtulabilirsiniz.

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

Not: Eclipse koleksiyonları için bir komisyoncuyum.

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

Çıktı:

İlkel int dizisi: [7, 9, 13]

Bir dizi için aynı işleri longveya doubledeğil diziler için boolean, char, byte, shortveya float. Gerçekten çok büyük bir listeniz parallelSetAllvarsa, bunun yerine kullanabileceğiniz bir yöntem bile vardır .

Bana göre bu, harici bir kütüphane almak ya da bunun için akış kullanmak istemeyeceğim kadar iyi ve elverişlidir.

Dokümantasyon bağlantısı: Arrays.setAll(int[], IntUnaryOperator)

Basitçe bir diziye kopyalayabilirsiniz:

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

Çok süslü değil; ama, hey, işe yarıyor ...

Çok basit bir tek satırlık çözüm:

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

Bu kod segmenti benim için çalışıyor, şunu deneyin:

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

Bahsetmeye değer ArrayList şöyle beyan edilmelidir:

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()]);

arrnormal erişim int[].