我玩游戏有些迟了，但是我注意到一些关键点被遗漏了，特别是在Java 8和效率方面Arrays.asList。
1. for-each循环如何工作？
正如Ciro Santilli指出的那样，有一个方便的实用程序可用来检查JDK附带的字节码：javap。使用该代码，我们可以确定以下两个代码段产生与Java 8u74相同的字节码：
每个循环：
int[] arr = {1, 2, 3};
for (int n : arr) {
System.out.println(n);
}
对于循环：
int[] arr = {1, 2, 3};
{
int[] iter = arr;
int length = iter.length;
for (int i = 0; i < length; i++) {
int n = iter[i];
System.out.println(n);
}
}
2.如何在Java中获得数组的迭代器？
尽管这不适用于原语，但应注意，将数组转换为具有的ListArrays.asList不会以任何重要方式影响性能。对内存和性能的影响几乎不可估量。
Arrays.asList不使用可作为类轻松访问的常规List实现。它使用java.util.Arrays.ArrayList，与并不相同java.util.ArrayList。它是围绕数组的非常薄的包装，无法调整大小。查看的源代码java.util.Arrays.ArrayList，我们可以看到它在功能上等效于数组。几乎没有开销。请注意，除了最相关的代码，我已经省略了所有代码，并添加了自己的注释。
public class Arrays {
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
private static class ArrayList<E> extends AbstractList<E> implements RandomAccess, java.io.Serializable {
private final E[] a;
ArrayList(E[] array) {
a = Objects.requireNonNull(array);
}
@Override
public int size() {
return a.length;
}
@Override
public E get(int index) {
return a[index];
}
@Override
public E set(int index, E element) {
E oldValue = a[index];
a[index] = element;
return oldValue;
}
}
}
迭代器位于java.util.AbstractList.Itr。就迭代器而言，这非常简单；它只是调用get()直到size()到达，就像手动for循环一样。这Iterator是数组的最简单且通常是最有效的实现。
同样，Arrays.asList不会创建java.util.ArrayList。它轻巧得多，适合用于开销很小的迭代器。
基本数组
正如其他人指出的那样，Arrays.asList不能在原始数组上使用。Java 8引入了几种用于处理数据集合的新技术，其中一些可用于从数组中提取简单且相对有效的迭代器。请注意，如果您使用泛型，则总是会遇到装箱/拆箱的问题：您需要将int转换为Integer，然后再转换回int。尽管装箱/拆箱通常可以忽略不计，但在这种情况下，确实会对性能产生O（1）的影响，并且可能导致大型阵列或资源非常有限的计算机（例如SoC）出现问题。
对于Java 8中的任何类型的数组转换/装箱操作，我个人最喜欢的是新的流API。例如：
int[] arr = {1, 2, 3};
Iterator<Integer> iterator = Arrays.stream(arr).mapToObj(Integer::valueOf).iterator();
流API最初还提供了用于避免装箱问题的构造，但这需要放弃迭代器以使用流。有用于int，long和double的专用流类型（分别为IntStream，LongStream和DoubleStream）。
int[] arr = {1, 2, 3};
IntStream stream = Arrays.stream(arr);
stream.forEach(System.out::println);
有趣的是，Java 8还添加了java.util.PrimitiveIterator。这提供了两全其美的优点：与Iterator<T>via装箱以及避免装箱的方法兼容。PrimitiveIterator具有三个扩展它的内置接口：OfInt，OfLong和OfDouble。如果next()调用，这三个函数都将置为box，但也可以通过诸如之类的方法返回原语nextInt()。next()除非绝对需要装箱，否则应避免使用为Java 8设计的较新代码。
int[] arr = {1, 2, 3};
PrimitiveIterator.OfInt iterator = Arrays.stream(arr);
Iterator<Integer> example = iterator;
while (iterator.hasNext()) {
int n = iterator.nextInt();
System.out.println(n);
}
如果您还没有使用Java 8，那么最遗憾的是您最简单的选择就不够简洁了，几乎可以肯定会涉及拳击：
final int[] arr = {1, 2, 3};
Iterator<Integer> iterator = new Iterator<Integer>() {
int i = 0;
@Override
public boolean hasNext() {
return i < arr.length;
}
@Override
public Integer next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return arr[i++];
}
};
或者，如果您想创建更可重用的内容：
public final class IntIterator implements Iterator<Integer> {
private final int[] arr;
private int i = 0;
public IntIterator(int[] arr) {
this.arr = arr;
}
@Override
public boolean hasNext() {
return i < arr.length;
}
@Override
public Integer next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return arr[i++];
}
}
您可以通过添加自己的获取基元的方法来解决拳击问题，但这仅适用于您自己的内部代码。
3.是否将数组转换为列表以获取迭代器？
不它不是。但是，这并不意味着将其包装在列表中会给您带来较差的性能，前提是您使用了诸如的轻量级内容Arrays.asList。