也可以使用 for

小说:德扑圈内部版作弊器作者:文平更新时间:2019-02-17字数:21995

盗一呵呵一笑说道:“做我们这行的,最重要的就是情报工作了。在偷这幅话之前,我早就做好了功课。这人名叫穆灵,以前是灵王宫的护卫队长,好像曾经参加过某项秘密的任务,因为他的表现不错,得到了赏识,因此回来后便是加官进爵。再然后,他似乎就和国务大臣的女儿进行拍拖了,也因此来到了国务大臣的家中暂时任职”。

黑桃棋牌下载安装

此刻天刚蒙蒙亮,初冬季节,江南水乡地区雾气很多,这一天凌晨老天爷也帮忙,大雾弥漫,五六米外几乎看不见东西,整个青浦江好像都笼罩在一片白茫茫之中,凭借着岸边的那些芦苇作为掩护,小舢板船队小心翼翼的朝前面驶过来,当然为了不被鬼子船只发现,韩非命令陈婉儿他们保持无线电沉默,人员尽量不要开口说话。
悟空闻言稍有失望,但金翅大鹏语锋一转,道:“不过这件事,我却是知道的。”牛魔王骂道:“知道便说,吞吞吐吐哪像个汉子。”

在千仞雪出第一轮神念探测的时候,唐三就已经发现了,那奇异的金光从瀚海护身罩上扫过时,唐三顿时全身一紧,匍匐在地面上,静静地等待神念从自己身上扫过。拥有蓝银领域的他当然知道千仞雪在干什么。同样的扫描方式他也进行过,只是他能明显感觉到,千雪这神念的探查要比自己蓝银领域的扫描强大得多了。

也可以使用 for


我们知道集合中的遍历都是通过迭代(iterator)完成的。

也许有人说,不一定非要使用迭代,如:

  List<String> list = new LinkedList<String>();
     
    list.add("a");
    list.add("b");
    list.add("c");
    for(int i=0;i<list.size();i++){
         String item = list.get(i);
         System.out.println(item);
    }

 

这种方式对于基于链表实现的List来说,是比较耗性能的。

因为get(int i)方法包含了一个循环,而且这个循环就是迭代遍历一次List,直到遇到第i个元素,才停止循环,返回第i个元素。对于数量小,遍历不频繁的List来说,开销可以忽略。否则,开销将不容忽视。

所以集合遍历是使用迭代器Iterator来遍历的:

  List<String> list = new LinkedList<String>();
      list.add("a");
      list.add("b");
      list.add("c");
     
      //获取集合的迭代器
      Iterator<String> itor = list.iterator();
     
      //集合的普通for循环
      for(;itor.hasNext();){//相当于 while(itor.hasNext())
         String item = itor.next();
         System.out.println(item);
     }

 

对应的for-Each循环的例子:

 List<String> list = new LinkedList<String>();
     list.add("a");
     list.add("b");
     list.add("c");
     for(String item:list){//for-Each
         System.out.println(item);
    }

 

可以看出,for-Each循环比普通for循环要简洁很多。

我们回答上面的两个问题:

    1. 编译器是如何处理集合中的for-Each循环的?
public static void main(String args[])
     {
         List list = new LinkedList();
         list.add("aaa");
         list.add("bbb");
        
         for(String item:list)
         {
             if("bbb".equals(item))
                 list.add("ccc");
         }
    }
反编译上面代码:

 public static void main(String args[])
     {
         List list = new LinkedList();
         list.add("aaa");
         list.add("bbb");
         
         for(Iterator iterator = list.iterator(); iterator.hasNext();)
         {
             String item = (String)iterator.next();
             if("bbb".equals(item))
                 list.add("ccc");
         }
    }

 

与数组类似,编译器最终也就是将集合中的for-Each循环处理成集合的普通for循环。而集合的Collection接口通过扩展Iterable接口来提供iterator()方。

那么我们换一个角度,是不是只要实现 Iterable接口,提供iterator()方法,也可以使用 for-Each循环呢?

例子:

class  MyList<T> implements Iterable<T>{
    private ArrayList<T> list = new ArrayList<>();
    
    public void addId(T id){
        list.add(id);
    }
    public boolean removeId(T id){
        return list.remove(id);
    }
    
    @Override
    public Iterator<T> iterator() {//扩展自Iterable接口
           //为了简单起见,就直接使用已有的迭代器
        return list.iterator();
    }
    
    public static void main(String[] args) {
        MyList<String> myList = new MyList<>();
        myList.addId("666999");
        myList.addId("973219");
             //for-Each
        for(String item:myList){
            System.out.println(item);
        }
    }
}

 

编译通过。

所以只要实现了Iterable接口的类,都可以使用for-Each循环来遍历。

集合迭代的陷阱

集合循环遍历时所使用的迭代器Iterator有一个要求:在迭代的过程中,除了使用迭代器(如:Iterator.remove()方法)对集合增删元素外,是不允许直接对集合进行增删操作。否则将会抛出 ConcurrentModificationException异常。

所以,由于集合的for-Each循环本质上使用的还是Iterator来迭代,因此也要注意这个陷阱。for-Each循环很隐蔽地使用了Iterator,导致程序员很容易忽略掉这个细节,所以一定要注意。

看下面的例子,for-Each循环中修改了集合。

public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
       
        for (String item : list) {//for-Each
            if ("bbb".equals(item)) {
                list.add("ccc"); //直接操作list
            }
        }
    }

 

运行抛出异常.

上面仅仅是单线程下的情况,如果在 多线程 的环境中,线程是交替运行的(时间片轮转调度)。这就意味着,如果有两个线程A、B,线程A对集合使用Iterator迭代遍历,线程B则对集合进行增删操作。线程A、B一旦交替运行,就会出现在迭代的同时对集合增删的效果,也会抛出异常。

解决办法就是加锁变成原子操作。

    1. 集合中的for-Each循环能代替集合的普通for循环吗?

同样也不能。

集合中的for-Each循环的局限性与数组的for-Each循环是一样的。集合的for-Each循环是不能对集合进行增删操作、也不能获取索引。

而集合的普通for循环可以使用的迭代器提供了对集合的增删方法(如:Iterator.remove,ListIterator.add()),获取索引的方法(如:ListIterator.nextIndex()、ListIterator.previousIndex());

扩展:Iterator源码分析

我们来分析一下Iterator源码,主要看看为什么在集合迭代时,修改集合可能会抛出ConcurrentModificationException异常。以ArrayList中实现的Iterator为例。

先来看一下ArrayList.iterator()方法,如下:

    public Iterator<E> iterator() {
        return new Itr();
    }

 

iterator()方法直接创建了一个类Itr的对象。那就接着看 Itr类的定义吧!发现Itr其实是ArrayList的内部类,实现了 Iterator 接口。

/**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
        int cursor;       // 当前的索引值,index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;
        public boolean hasNext() {
            return cursor != size;
        }
        
        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            //ArrayList的底层数组
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
        
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                //再次更新 expectedModCount
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
        
        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

 

ArrayList.this.elementData是ArrayList的底层数组,这些方法都是对ArrayList.this.elementData这个底层数组进行操作。

重点看一下checkForComodification()方法,它是用来抛出ConcurrentModificationException异常,判断modCount与expectedModCount是否相等。modCount存储的AarryList中的元素个数。而expectedModCount则是对象创建时将modCount的值赋给它,也就是说expectedModCount存储的是迭代器创建时元素的个数。

那么checkForComodification()方法其实在比较迭代期间,ArrayList元素的个数 是否发生了改变,如果改变了,就抛出异常。

注意,expectedModCount除了在声明时赋值外,也在remove()方法中更新了一次。

当前文章:http://www.0477auto.com/play/x3zaketuld.html

发布时间:2019-02-17 05:26:58

大富豪李逵劈鱼 石家庄冀友棋牌 联众世界游戏大厅ipad 联众斗地主游戏送金币 赛鱼扑克微赛德扑 亲友衡阳棋牌俱乐部 苹果手机怎么下载吉祥棋牌游戏 蔚蓝棋牌下载安装

编辑:辛王安

我要说两句: (0人参与)

发布