我們要遍歷一個(gè)數(shù)組、一個(gè)列表，經(jīng)常會(huì)用到kotlin的 for in 語(yǔ)法，但是 for in 是不是有序的呢？forEach是不是有序的呢？這就需要看一下它們的本質(zhì)了。

數(shù)組的 for in

// 調(diào)用：
val arr = arrayOf(1, 2, 3)
for (ele in arr) {
    println(ele)
}

反編譯成Java是個(gè)什么東西呢？

Integer[] arr = new Integer[]{1, 2, 3};
Integer[] var4 = arr;
int var5 = arr.length;

for(int var3 = 0; var3 < var5; ++var3) {
    int ele = var4[var3];
    System.out.println(ele);
}

總結(jié)：從Java代碼可以看出，實(shí)際就是一個(gè)普通的for循環(huán)，是從下標(biāo)0開(kāi)始遍歷到結(jié)束的，所以是有序的。

列表的 for in

// 調(diào)用：
val list = listOf(1, 2, 3)
for (ele in list) {
    println(ele)
}

反編譯成Java：

List list = CollectionsKt.listOf(new Integer[]{1, 2, 3});
Iterator var3 = list.iterator();

while(var3.hasNext()) {
    int ele = ((Number)var3.next()).intValue();
    System.out.println(ele);
}

可以看出列表的for in是通過(guò)iterator實(shí)現(xiàn)的，和數(shù)組不一樣，那這個(gè)iterator遍歷是否是有序的呢？首先我們要知道這個(gè)iterator怎么來(lái)的：

// iterator 是通過(guò)調(diào)用 list.iterator() 得到的，那么這個(gè)list又是什么呢？
Iterator var3 = list.iterator();

// list
List list = CollectionsKt.listOf(new Integer[]{1, 2, 3});

// list是通過(guò)數(shù)組elements.asList()得到的
public fun <T> listOf(vararg elements: T): List<T> = if (elements.size > 0) elements.asList() else emptyList()

// 這里有個(gè)expect，找到對(duì)應(yīng)的actual
public expect fun <T> Array<out T>.asList(): List<T>

// 對(duì)應(yīng)的actual
public actual fun <T> Array<out T>.asList(): List<T> {
    return ArraysUtilJVM.asList(this)
}

// 最終調(diào)用了Arrays.asList(array)
class ArraysUtilJVM {
    static <T> List<T> asList(T[] array) {
        return Arrays.asList(array);
    }
}

public class Arrays {
    
    // 從這里看到最終拿到的list是 Arrays 類(lèi)中的 ArrayList
    // 然后我們找到里面的 iterator() 方法
    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;

        @Override
        public Iterator<E> iterator() {
            // 最終得到的iterator是ArrayItr
            // 這里的a是一個(gè)數(shù)組，也就是我們一開(kāi)始傳進(jìn)來(lái)的1,2,3
            return new ArrayItr<>(a);
        }
    }

    private static class ArrayItr<E> implements Iterator<E> {
        private int cursor;
        private final E[] a;

        ArrayItr(E[] a) {
            this.a = a;
        }

        @Override
        public boolean hasNext() {
            return cursor < a.length;
        }

        @Override
        public E next() {
            int i = cursor;
            if (i >= a.length) {
                throw new NoSuchElementException();
            }
            cursor = i + 1;
            return a[i];
        }
    }
}

總結(jié)：列表的for in是通過(guò)iterator實(shí)現(xiàn)的，這個(gè)iterator是ArrayItr，從里面的next()方法可以看出，這也是有序的，從cursor開(kāi)始，cursor默認(rèn)是0，也就是從下標(biāo)0開(kāi)始遍歷。
注：這里只是分析了Arrays.ArrayList的iterator，具體的集合類(lèi)需要具體分析，比如ArrayList、LinkedList等，不過(guò)從正常思維來(lái)看，iterator是一個(gè)迭代器，就應(yīng)該有序的把數(shù)據(jù)一個(gè)一個(gè)丟出來(lái)。

數(shù)組的 forEach

// 調(diào)用：
val arr = arrayOf(1, 2, 3)
arr.forEach {
    println(it)
}

// 點(diǎn)進(jìn)去forEach看：
// 其實(shí)也是調(diào)用了for in，所以也是有序的。
public inline fun <T> Array<out T>.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

列表的 forEach

// 調(diào)用：
val list = listOf(1, 2, 3)
list.forEach {
    println(it)
}

// 點(diǎn)進(jìn)去forEach看：
// 其實(shí)也是調(diào)用了for in，所以也是有序的。
public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}