如何转换列表<；整数>；要在Java中使用int[]吗？

这与这个问题类似：

我是Java新手。如何在Java中将

列表

转换为

int[]

？我很困惑，因为

List.toArray（）

实际上返回了一个

对象[]

，它可以被转换为下一个

整数[]

或

int[]

现在我正在使用一个循环来实现这一点：

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

int[]toIntArray（列表）{
int[]ret=new int[list.size（）]；
对于（int i=0；i

---

我确信有更好的方法可以做到这一点。

不幸的是，由于Java处理基元类型、装箱、数组和泛型的本质，我不相信有更好的方法。特别是：

• List.toArray

  不起作用，因为没有从

  Integer

  到

  int

• 您不能使用

  int

  作为泛型的类型参数，因此它必须是一个

  int

  特定的方法（或者使用反射来进行肮脏的欺骗）

我相信有些库对于所有的基元类型都有这种方法的自动生成版本（也就是说，每个类型都有一个复制的模板）。很难看，但恐怕就是这样：(

---

即使该类在泛型进入Java之前出现，但如果它是在今天引入的（假设您想使用基元数组），它仍然必须包含所有可怕的重载。

确实没有办法“一行”完成您正在尝试的操作，因为toArray返回一个对象[]，并且您无法从对象[]强制转换为int[]或Integer[]到int[]

最简单的方法是利用。它有一个方便的ArrayUtils类，可以做您想做的事情。对

Integer

数组使用重载方法

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

int[]toIntArray（列表）{
int[]ret=new int[list.size（）]；
int i=0；
for（整数e:list）
ret[i++]=e；
返回ret；
}

---

对代码稍作修改以避免昂贵的列表索引（因为列表不一定是ArrayList，但可能是链表，随机访问很昂贵）

除了Commons Lang之外，您还可以使用的方法执行此操作：

List=。。。
int[]ints=ints.toArray（列表）；

这就省去了Commons Lang等效程序需要自己进行的中间数组转换。

try-allow（）：

导入静态com.humaorie.dollar.dollar*
...
列表源=。。。；
int[]ints=$（源）.convert（）.toIntArray（）；

我建议您使用java collections 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));
}
}

package-mypackage；
导入java.util.AbstractList；
导入java.util.array；
导入java.util.Collections；
导入java.util.List；
公开课考试{
//将int数组转换为列表的Helper方法
静态列表intArrayAsList（最终int[]a）{
如果（a==null）
抛出新的NullPointerException（）；
返回新的AbstractList（）{
@凌驾
公共整数get（int i）{
返回一个[i]；//自动装箱
}
@凌驾
公共整数集（整数i，整数val）{
最终整数=a[i]；
a[i]=val；//自动取消装箱
返回旧的；//自动装箱
}
@凌驾
公共整数大小（）{
返回a.length；
}
};
}
公共静态void main（最终字符串[]args）{
int[]a={1,2,3,4,5}；
收款。反向（intArrayAsList（a））；
System.out.println（Arrays.toString（a））；
}
}

小心装箱/拆箱的缺点

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

迭代器iter=list.Iterator（）；
对于（int i=0；iter.hasNext（）；i++）{
ret[i]=iter.next（）；
}                                        
返回ret；

使用lambda可以做到这一点（在jdk lambda中编译）：

publicstaticvoidmain（字符串ars[]）{
TransformService TransformService=（输入）->{
int[]ints=新的int[inputs.size（）]；
int i=0；
for（整数元素：输入）{
ints[i++]=元素；
}
返回整数；
};
列表输入=新数组列表（5）{add（10）；add（10）；}；
int[]results=transformService.transform（输入）；
}
公共接口转换服务{
int[]转换（列表输入）；
}

我会在这里再加一个。我注意到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;
}

int[]toArray（列表）{
int[]ret=new int[list.size（）]；
int i=0；
for（Iterator it=list.Iterator（）；
it.hasNext（）；
ret[i++]=it.next（）；
返回ret；
}

如果C++允许一个for循环中的多个声明，我们可以进一步做（int i＝0，迭代器……/p>）

---

不过，最后（这部分只是我的观点），如果你想有一个帮助函数或方法来为你做一些事情，只需设置它，然后忘记它。它可以是一行或十行；如果你再也看不到它，你就不会知道它的区别了。

没有人提到Java 8中添加了streams，因此它是这样的：

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

---

思维过程：

• 简单的

  Stream#toArray

  返回

  Object[]

  ，因此它不是我们想要的。还有

  Stream#toArray（IntFunction
  
  

• 所以现在我们唯一需要弄清楚的是如何将我们的

  流

  （将从

  list.Stream（）

  ）转换为闪亮的

  IntStream

  。我们需要做的就是将

  整数

  映射到

  int

  我们公司

  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;                              
  

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

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

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

  mapToInt( (Integer i) -> i.intValue() )  
  

  mapToInt((Integer i)->i)
  

  mapToInt(i -> i)
  

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

  mapToInt(Integer::intValue)
  

  mapToInt(i -> i.intValue())
  

  mapToInt(i -> i)
  

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

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

  int[] arr = list.parallelStream().map(i -> i == null ? -1 : i).mapToInt(Integer::intValue).toArray();
  

  int[] arr = list.parallelStream().mapToInt(i -> i == null ? -1 : i.intValue()).toArray();
  

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

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

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

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

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