不幸的是，由于Java处理原始类型、装箱、数组和泛型的本质，我不相信真的有更好的方法来做到这一点。特别是:

列表> < T。toArray不能工作，因为没有从Integer到int的转换 你不能使用int作为泛型的类型参数，所以它必须是一个特定于int的方法(或者使用反射来做讨厌的把戏)。

我相信有些库已经为所有的基本类型自动生成了这种方法的版本(也就是说，每个类型都复制了一个模板)。它很丑，但恐怕就是这样。

即使Arrays类出现在Java泛型出现之前，如果今天引入它(假设您想使用基本数组)，它仍然必须包含所有可怕的重载。

实际上没有办法“一行行”你正在尝试做的事情，因为toArray返回一个对象[]，你不能从Object[]转换为int[]或Integer[]转换为int[]。

最简单的方法是使用Apache Commons Lang。它有一个方便的ArrayUtils类，可以做任何您想做的事情。将toPrimitive方法与整数数组的重载一起使用。

List<Integer> myList;
 ... assign and fill the list
int[] intArray = ArrayUtils.toPrimitive(myList.toArray(new Integer[myList.size()]));

这样你就不用白费力气了。Commons Lang有很多Java遗漏的有用的东西。上面，我选择创建一个大小合适的Integer列表。你也可以使用一个0长度的静态Integer数组，让Java分配一个合适大小的数组:

static final Integer[] NO_INTS = new Integer[0];
   ....
int[] intArray2 = ArrayUtils.toPrimitive(myList.toArray(NO_INTS));

Use:

int[] toIntArray(List<Integer> list)  {
    int[] ret = new int[list.size()];
    int i = 0;
    for (Integer e : list)
        ret[i++] = e;
    return ret;
}

对代码的这一轻微更改是为了避免昂贵的列表索引(因为list不一定是ArrayList，但它可以是链表，对于链表，随机访问是昂贵的)。

除了Commons Lang，你还可以使用Guava的方法Ints。toArray(收集<整数>收集):

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

这使您不必自己进行Commons Lang对等物要求的中间数组转换。

也可以试试Dollar(检查这个修订版):

import static com.humaorie.dollar.Dollar.*
...

List<Integer> source = ...;
int[] ints = $(source).convert().toIntArray();

我建议您使用List<?来自Java集合API的>骨架实现。在这种特殊情况下，它似乎很有帮助:

package mypackage;

import java.util.AbstractList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test {

    // Helper method to convert int arrays into Lists
    static List<Integer> intArrayAsList(final int[] a) {
        if(a == null)
            throw new NullPointerException();
        return new AbstractList<Integer>() {

            @Override
            public Integer get(int i) {
                return a[i]; // Autoboxing
            }
            @Override
            public Integer set(int i, Integer val) {
                final int old = a[i];
                a[i] = val; // Auto-unboxing
                return old; // Autoboxing
            }
            @Override
            public int size() {
                return a.length;
            }
        };
    }

    public static void main(final String[] args) {
        int[] a = {1, 2, 3, 4, 5};
        Collections.reverse(intArrayAsList(a));
        System.out.println(Arrays.toString(a));
    }
}

小心装箱/拆箱的缺点。

int[] ret = new int[list.size()];       
Iterator<Integer> iter = list.iterator();
for (int i=0; iter.hasNext(); i++) {       
    ret[i] = iter.next();                
}                                        
return ret;                              

使用lambda你可以这样做(在JDK lambda中编译):

public static void main(String ars[]) {
    TransformService transformService = (inputs) -> {
        int[] ints = new int[inputs.size()];
        int i = 0;
        for (Integer element : inputs) {
            ints[ i++ ] = element;
        }
        return ints;
    };

    List<Integer> inputs = new ArrayList<Integer>(5) { {add(10); add(10);} };

    int[] results = transformService.transform(inputs);
}

public interface TransformService {
    int[] transform(List<Integer> inputs);
}

我注意到for循环的一些用法，但是在循环中甚至不需要任何东西。我提到这一点只是因为最初的问题是试图找到不那么冗长的代码。

int[] toArray(List<Integer> list) {
    int[] ret = new int[ list.size() ];
    int i = 0;
    for( Iterator<Integer> it = list.iterator();
         it.hasNext();
         ret[i++] = it.next() );
    return ret;
}

如果Java像c++那样允许在for循环中多次声明，我们可以更进一步，执行for(int i = 0, Iterator it…

最后(这部分只是我的观点)，如果你想要有一个帮助函数或方法来为你做一些事情，那就把它设置好，然后忘记它。它可以是一行或十条;如果你再也不看它，你就不会知道其中的区别。

在Java 8中添加流后，我们可以编写如下代码:

int[] example1 = list.stream().mapToInt(i->i).toArray();
// OR
int[] example2 = list.stream().mapToInt(Integer::intValue).toArray();

思维过程:

The simple Stream#toArray returns an Object[] array, so it is not what we want. Also, Stream#toArray(IntFunction<A[]> generator) doesn't do what we want, because the generic type A can't represent the primitive type int So it would be nice to have some stream which could handle the primitive type int instead of the wrapper Integer, because its toArray method will most likely also return an int[] array (returning something else like Object[] or even boxed Integer[] would be unnatural here). And fortunately Java 8 has such a stream which is IntStream So now the only thing we need to figure out is how to convert our Stream<Integer> (which will be returned from list.stream()) to that shiny IntStream. Quick searching in documentation of Stream while looking for methods which return IntStream points us to our solution which is mapToInt(ToIntFunction<? super T> mapper) method. All we need to do is provide a mapping from Integer to int. Since ToIntFunction is functional interface we can provide its instance via lambda or method reference. Anyway to convert Integer to int we can use Integer#intValue so inside mapToInt we can write: mapToInt( (Integer i) -> i.intValue() ) (or some may prefer: mapToInt(Integer::intValue).) But similar code can be generated using unboxing, since the compiler knows that the result of this lambda must be of type int (the lambda used in mapToInt is an implementation of the ToIntFunction interface which expects as body a method of type: int applyAsInt(T value) which is expected to return an int). So we can simply write: mapToInt((Integer i)->i) Also, since the Integer type in (Integer i) can be inferred by the compiler because List<Integer>#stream() returns a Stream<Integer>, we can also skip it which leaves us with mapToInt(i -> i)

如果您只是将一个Integer映射到int，那么您应该考虑使用并行性，因为您的映射逻辑不依赖于其作用域之外的任何变量。

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

要注意这一点

请注意，并行并不会自动地比串行执行操作快，尽管如果您有足够的数据和处理器核心，它可能会快。虽然聚合操作使您能够更容易地实现并行性，但您仍有责任确定应用程序是否适合并行性。

有两种方法将integer映射到它们的原始形式:

通过ToIntFunction。 mapToInt(整数::intValue) 通过lambda表达式显式开箱。 mapToInt(i -> i. intvalue ()) 通过隐式(自动)解盒lambda表达式。 mapToInt(i -> i)

给定一个空值的列表

List<Integer> list = Arrays.asList(1, 2, null, 4, 5);

这里有三个处理null的选项:

在映射之前过滤掉空值。 int[] arr = list.parallelStream().filter(对象::nonNull).mapToInt(Integer::intValue).toArray(); 将空值映射为默认值。 int[] arr = list.parallelStream()。映射(i -> i == null ?-1:i).mapToInt(Integer::intValue).toArray(); 在lambda表达式中处理null。 int[] arr = list.parallelStream()。mapToInt(i -> i == null ?-1: i.t intvalue ()).toArray();

使用Eclipse Collections，如果您有一个类型为java.util.List<Integer>的列表，您可以执行以下操作:

List<Integer> integers = Lists.mutable.with(1, 2, 3, 4, 5);
int[] ints = LazyIterate.adapt(integers).collectInt(i -> i).toArray();

Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, ints);

如果您已经有一个Eclipse集合类型，如MutableList，您可以执行以下操作:

MutableList<Integer> integers = Lists.mutable.with(1, 2, 3, 4, 5);
int[] ints = integers.asLazy().collectInt(i -> i).toArray();

Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, ints);

注意:我是Eclipse Collections的提交者

下面是一个Java 8的单行代码:

public int[] toIntArray(List<Integer> intList){
    return intList.stream().mapToInt(Integer::intValue).toArray();
}

Java 8为我们提供了一种通过流来实现这一点的简单方法……

使用collections stream()函数，然后映射到int，你将得到一个IntStream。对于IntStream，我们可以调用toArray()，得到int []

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

int []

to IntStream

这个简单的循环总是正确的!没有错误

  int[] integers = new int[myList.size()];
  for (int i = 0; i < integers.length; i++) {
      integers[i] = myList.get(i);
  }