java迭代器原理及迭代map的四種方式

更新時間：2021年09月03日 15:14:28 作者：dandeseed

本文我們將了解一下java迭代器原理及其在Java中迭代Map各種不同方法。具有一定的參考價值，感興趣的可以了解一下

迭代器原理：

什么是迭代器，使用迭代器的好處？

迭代器就是用來遍歷集合中對象的東西，也就是說，對于集合，我們不像對原始數(shù)組那樣通過直接訪問元素來迭代的，而是通過迭代器來遍歷對象。這么做的好處是將對于集合類型的遍歷行為與被遍歷集合對象分離，這樣以來，就不需要關(guān)心該集合類型的具體實現(xiàn)是怎么樣的。只要獲取這個集合對象的迭代器便可以遍歷這個集合中的對象。而像遍歷對象順序以及怎么訪問對象元素這些細節(jié)，全部由它自己的迭代器來處理。

迭代器怎么實現(xiàn)的？

首先集合要先實現(xiàn)iterable接口來表示此對象是可以進行迭代的。而實現(xiàn)iterable接口的對象實現(xiàn)了iterator方法，這個方法返回了一個Iterator對象。一個迭代器對象需要Iterator接口中的方法：hasNext(),next(),remove()。remove()方法會刪除最近一次調(diào)用的元素，如果remove()之前沒有調(diào)用next()的話直接調(diào)用remove()會產(chǎn)生報錯信息（IllegalStateException)。我們在進行對集合對象迭代的時候，next()會返回當(dāng)前對象第一個對象并返回，然后next會指向下一個元素，hasNext方法就是看這個指針后面還有沒有元素了。

迭代器的陷阱？

使用for迭代的時候不可以使用集合進行remove操作。這時候需要使用迭代器進行迭代，然后使用迭代器中的remove方法進行刪除。

為什么會產(chǎn)生這樣的錯誤？

remove()方法在刪除元素的時候，還會修改一個修改次數(shù)的標(biāo)志位modCount，如果iterator的expectedModCount與modCount的大小不相等時，會拋出一個ConcurrentModificationException異常。modCount的目的主要是為了防止當(dāng)前對象迭代過程中存在其他線程對當(dāng)前對象的修改。

// iterable接口源代碼

public interface Iterable<T> {
    /**
     * Returns an iterator over elements of type {@code T}.
     *
     * @return an Iterator.
     */
    Iterator<T> iterator();

    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

// iterator接口源代碼

public interface Iterator<E> {
    /**
    * 如果迭代擁有更多元素，那么返回true
    */
    boolean hasNext();
    /**
    * 返回iteration中的下一個元素
    */
    E next();
    /**
    * 如果刪除一個集合中的元素沒有調(diào)用這個方法，二十直接中集合中刪除，那么這個迭代器的行為沒有被指定
    */
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    /**
    * 遍歷集合中的剩余元素（如果之前調(diào)用了兩次next()那么只會遍歷集合中剩余元素
    * 使用案例：
    * Iterator<Integer> it = map.keySet().iterator();
        it.next();
        it.next();
        it.forEachRemaining(System.out::println);
    */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

HashMap中實現(xiàn)迭代的核心代碼：

        final Node<K,V> nextNode() {
            Node<K,V>[] t;
            Node<K,V> e = next; // 對象屬性中的next是下一個值
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (e == null)
                throw new NoSuchElementException();
            // next = e.next 如果e.next為null，那么繼續(xù)找數(shù)組下一個不為null的值
            if ((next = (current = e).next) == null && (t = table) != null) {
                do {} while (index < t.length && (next = t[index++]) == null);
            }
            return e;
        }

        public final void remove() {
            Node<K,V> p = current;
            if (p == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            current = null;
            K key = p.key;
            removeNode(hash(key), key, null, false, false);
            expectedModCount = modCount;

遍歷map的四種方式

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.HashMap;

public class MapTest {
    public static void main(String[] args) {
        HashMap<Integer,Integer> map = new HashMap();
        map.put(0,1);
        map.put(2,2);
        map.put(1,2);
        map.put(4,5);
        map.put(3,4);
        // 遍歷hashmap entry foreach
        Set<Map.Entry<Integer,Integer>> ent = map.entrySet();
        for(Map.Entry<Integer,Integer> entry:ent){
            System.out.println(entry.getKey()+"  :  "+entry.getValue());
            //map.remove(0);
        }
        System.out.println();
        // 通過keySet或者values()遍歷
        Set<Integer> set = map.keySet();
        for(Integer key:set){
            System.out.println(key+"  --  "+map.get(key));
        }
        Collection<Integer> set1 = map.values();
        for(Integer val:set1){
            System.out.println(val);
        }
        System.out.println();
        // iterator原理是什么 通過iterator遍歷map
        Iterator<Map.Entry<Integer,Integer>> iter = map.entrySet().iterator();
        while(iter.hasNext()){
            Map.Entry entry = iter.next();
            System.out.println(entry.getKey()+"  :  "+entry.getValue());
            iter.remove();
        }
        System.out.println();
        Iterator<Integer> keys = map.keySet().iterator();
        while(keys.hasNext()){
            int k = keys.next();
            System.out.println(k+" -- "+ map.get(k));
        }

    }
}

參考鏈接：https://blog.csdn.net/fuzhongmin05/article/details/72460658

到此這篇關(guān)于java迭代器原理及迭代map的四種方式的文章就介紹到這了,更多相關(guān)java迭代map內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: