Arrays 将数组转换为列表

为了将整数数组转换为整数列表，我尝试了以下方法：

初始化列表（整数类型），在数组上迭代并插入到列表中

通过使用Java 8流：

int[] ints = {1, 2, 3};
List<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, Arrays.stream(ints).boxed().toArray(Integer[]::new));

int[]int={1,2,3}；
列表=新的ArrayList（）；
Collections.addAll（list，Arrays.stream（ints）.boxed（）.toArray（Integer[]：：new））；

---

哪一种性能更好？

第二种方法创建一个新的整数数组（第一次），然后将此新数组的所有元素添加到列表中（第二次）。因此，它的效率低于第一个，它只进行一次传递，并且不会创建不必要的整数数组

使用流的更好方法是

List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());

List List=Arrays.stream（ints）.boxed（）.collect（Collectors.toList（））；

它应该具有与第一个大致相同的性能

---

请注意，对于这样一个小数组，不会有任何显著差异。您应该尝试编写正确、可读、可维护的代码，而不是专注于性能。

只需尝试以下操作

Arrays.asList(array)

---

如果您处理的是字符串[]而不是int[]，那么我们可以使用

ArrayList<String> list = new ArrayList<>();
list.addAll(Arrays.asList(StringArray));

ArrayList list=new ArrayList（）；
addAll（Arrays.asList（StringArray））；

整数[]={4,10,7,25,60,1}；

---

List lista=IntStream.of（numeros.boxed（）.collect（Collectors.toList（））

如果您不想更改列表：

List<Integer> list = Arrays.asList(array)

List List=Arrays.asList（数组）

但如果您想修改它，则可以使用：

List<Integer> list = new ArrayList<Integer>(Arrays.asList(ints));

List List=newarraylist（Arrays.asList（ints））；

或者像下面这样使用java8：

List<Integer> list = Arrays.stream(ints).collect(Collectors.toList());

List List=Arrays.stream（ints.collect（Collectors.toList（））；

Java9引入了这种方法：

List<Integer> list = List.of(ints);

List List=List.of（ints）；

但是，这将返回一个无法添加到的不可变列表

您需要执行以下操作以使其可变：

List<Integer> list = new ArrayList<Integer>(List.of(ints));

List List=newarraylist（List.of（ints））；

如果您不介意第三方依赖关系，您可以使用一个本机支持原始集合的库，例如，并完全避免装箱。如果需要，还可以使用基本集合创建盒装常规集合

int[] ints = {1, 2, 3};
MutableIntList intList = IntLists.mutable.with(ints);
List<Integer> list = intList.collect(Integer::valueOf);

因为问题是关于性能的，所以我使用您的解决方案、投票最多的答案以及Eclipse集合的原始版本和盒装版本编写了一些JMH基准测试

import org.eclipse.collections.api.list.primitive.IntList;
import org.eclipse.collections.impl.factory.primitive.IntLists;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

@State(Scope.Thread)
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
@Fork(2)
public class IntegerArrayListFromIntArray
{
    private int[] source = IntStream.range(0, 1000).toArray();

    public static void main(String[] args) throws RunnerException
    {
        Options options = new OptionsBuilder().include(
                ".*" + IntegerArrayListFromIntArray.class.getSimpleName() + ".*")
                .forks(2)
                .mode(Mode.Throughput)
                .timeUnit(TimeUnit.SECONDS)
                .build();
        new Runner(options).run();
    }

    @Benchmark
    public List<Integer> jdkClassic()
    {
        List<Integer> list = new ArrayList<>(source.length);
        for (int each : source)
        {
            list.add(each);
        }
        return list;
    }

    @Benchmark
    public List<Integer> jdkStreams1()
    {
        List<Integer> list = new ArrayList<>(source.length);
        Collections.addAll(list,
                Arrays.stream(source).boxed().toArray(Integer[]::new));
        return list;
    }

    @Benchmark
    public List<Integer> jdkStreams2()
    {
        return Arrays.stream(source).boxed().collect(Collectors.toList());
    }

    @Benchmark
    public IntList ecPrimitive()
    {
        return IntLists.immutable.with(source);
    }

    @Benchmark
    public List<Integer> ecBoxed()
    {
        return IntLists.mutable.with(source).collect(Integer::valueOf);
    }
}

如果有人发现基准测试有任何问题，我很乐意进行更正并再次运行它们

注意：我是Eclipse集合的提交者

Arrays.stream(ints).forEach(list::add);

这基本上是1（迭代数组）和2（使用Java8）。（1和2指的是您的原始问题）

其中stateb是列表“ bucket是一个二维数组

statesb=IntStream.of（bucket[j-1]）.boxed（）.collect（Collectors.toList（））

与 导入java.util.stream.IntStream

---

请参见

第一种方法更好，第二种方法在创建新数组和转换为列表时花费更多时间

问题是什么？为什么不？您也可以使用Arrays.asList（）。@Arnabbis实际上，不，他不能。如果他有一个整数[]，而不是一个整数[]，他就可以了。@JBNizet My Bad！没有注意到这一点。但是当我们不需要imutable集合时，这可能会导致问题，特别是当它不适用于基元类型值的数组时：int[]array=newint[]{1,2,3,4}；Arrays.asList（array）：：列表框，完美！

# Run complete. Total time: 00:06:52

Benchmark                                  Mode  Cnt        Score      Error  Units
IntegerArrayListFromIntArray.ecBoxed      thrpt   40   191671.859 ± 2107.723  ops/s
IntegerArrayListFromIntArray.ecPrimitive  thrpt   40  2311575.358 ± 9194.262  ops/s
IntegerArrayListFromIntArray.jdkClassic   thrpt   40   138231.703 ± 1817.613  ops/s
IntegerArrayListFromIntArray.jdkStreams1  thrpt   40    87421.892 ± 1425.735  ops/s
IntegerArrayListFromIntArray.jdkStreams2  thrpt   40   103034.520 ± 1669.947  ops/s

Arrays.stream(ints).forEach(list::add);