精华内容
下载资源
问答
  • 增强for循环

    千次阅读 2018-08-01 19:12:55
    一、增强for循环 增强for循环的作用: 简化迭代器的书写格式。...增强for循环的缺点:增强for循环和iterator遍历的效果是一样的,也就说增强for循环的内部也就是调用iteratoer实现的,但是增强for循环有些缺点...

    一、增强for循环
    增强for循环的作用: 简化迭代器的书写格式。(注意:增强for循环的底层还是使用了迭代器遍历。)
    增强for循环的适用范围: 如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。
    增强for循环的缺点:增强for循环和iterator遍历的效果是一样的,也就说增强for循环的内部也就是调用iteratoer实现的,但是增强for循环有些缺点,例如不能在增强循环里动态的删除集合内容、不能获取下标等。

    二、增强for循环的格式:
    for(数据类型 变量名 :遍历的目标){ //数据类型 变量名:声明一个变量用来接收遍历目标遍历后的元素

    }

    三、增强for循环要注意的事项:
    增强for循环底层也是使用了迭代器获取的,只不过获取迭代器由jvm完成,不需要我们获取迭代器而已,所以在使用增强for循环变量元素的过程中不准使用集合对象对集合的元素个数进行修改。
    迭代器遍历元素与增强for循环变量元素的区别:使用迭代器遍历集合的元素时可以删除集合的元素,而增强for循环变量集合的元素时,不能调用迭代器的remove方法删 除 元素。
    普通for循环与增强for循环的区别:普通for循环可以没有遍历的目标,而增强for循环一定要有遍历的目标。
    int[] arr = {5,11,2,4,9,18};

        普通for循环的遍历方式 
        for(int i =  0 ; i<arr.length ; i++){ 
            System.out.println("元素:"+ arr[i]); 
        } 
    
        //使用增强for循环实现 
        for(int item :arr){ 
            System.out.println("元素:"+ item); 
        } 
    
      HashSet<String> set = new HashSet<String>();  
        //添加元素  
        set.add("张狗蛋");  
        set.add("张全蛋");  
        set.add("张傻蛋");  
    
        //使用迭代器遍历Set的集合. 
        Iterator<String> it  = set.iterator(); 
        while(it.hasNext()){ 
            String temp = it.next(); 
            System.out.println("元素:"+ temp); 
            it.remove(); 
        } 
    
    
        //使用增强for循环解决 
        for(String item : set){ 
            System.out.println("元素:"+ item); 
    
        } 
    
    展开全文
  • 相信for循环对大家来说一定很不陌生,毕竟不管是初学者还是资深老鸟对于for循环的使用都应该是较为频繁的,那么不知道大家对于增强for循环是否同样熟悉呢? 首先增强for循环和iterator遍历的效果是一样的,也就说...
    相信for循环对大家来说一定很不陌生,毕竟不管是初学者还是资深老鸟对于for循环的使用都应该是较为频繁的,那么不知道大家对于增强for循环是否同样熟悉呢?
    首先增强for循环和iterator遍历的效果是一样的,也就说增强for循环的内部也就是调用iteratoer实现的。
    增强for循环的优点是写法简便,无需获得数组、集合长度,也无需根据索引来访问元素。
    缺点是不能在循环里动态的删除元素和获取元素下标。
    最后一定要注意的是增强for循环有一个局限性,那就是必须要有被遍历的目标,而普通for循环是不需要的。
    
    展开全文
  • 增强for循环亦为高级for循环。 增强for循环内部是使用的Iterator来遍历的,只能遍历数组和实现了Iterable接口的集合。优点是写法简便,无需获得数组、集合长度,也无需根据索引来访问元素。缺点是不能在循环里动态...

    增强for循环亦为高级for循环。
    增强for循环内部是使用的Iterator来遍历的,只能遍历数组和实现了Iterable接口的集合。优点是写法简便,无需获得数组、集合长度,也无需根据索引来访问元素。缺点是不能在循环里动态的删除元素和获取元素下标。
    任何的增强for循环都可以改写为普通for循环。遍历集合所有元素的话用增强for循环更加简洁,如果是复杂的循环,还是用for循环比较好,for循环功支持索引取元素,可以使用下标来控制位置。
    高级for有一个局限性,必须有被遍历的目标。
    建议在遍历数组的时候,还是希望使用传统for,因为传统for可以定义角标。
    凡是支持迭代器的都支持高级for
    .而对于 LinkedList 由于获取一个元素,要从头开始向后找,因此建议使用 增强for循环,也就是iterator。

    下面用一个例子说明这点:

    代码一

    public static void removeEvensVer2(List<Integer> lst)  
        {  
            for (Integer x : lst)  
                if (x % 2 == 0)  
                    lst.remove(x);  
    
            System.out.println(lst);  
        }  

    代码二

    public static void removeEvensVer3(List<Integer> lst)  
        {  
            Iterator<Integer> itr = lst.iterator();  
            while (itr.hasNext())  
                if (itr.next() % 2 == 0)  
                    itr.remove();  
    
            System.out.println(lst);  
        } 

    代码一在运行时抛出异常,代码二正常

    原因分析:因为增强的for循环内部就是调用iterator实现的,在遍历的时候就将list转化为了迭代器,当迭代器被创建之后,如果从结构上对列表修改除非通过迭代器自身的remove、add方法,其他任何时间任何方式的修改,迭代器都会抛出ConcurrentModificationException异常。

    展开全文
  • 在遍及集合过程对集合进行删除操作最好不要做,如果非要做可以利用迭代器,并发集合,或者同步代码。  单线程模式下直接使用迭代器提供的remove方法就行或者首先记录下标遍历... 普通for循环遍历集合过程进行...

           在遍及集合过程中对集合进行删除操作最好不要做,如果非要做可以利用迭代器,并发集合,或者同步代码。

           单线程模式下直接使用迭代器提供的remove方法就行或者首先记录下标遍历完后进行删除,多线程模式下建议使用同步或并发结合。

    1 面试遇到的问题和迭代器没关系考察的是普通的for循环和foreach循环

    下面先说出观点:

           普通for循环遍历集合过程中进行删除,如果进行大量删除会报IndexOutOfBoundsException异常,如果少量删除可以成功删除,但是循环的次数会减少,造成结果不准确。

          增强for循环遍历过程中进行删除,会报ConcurrentModificationException异常,这个异常大家应该很熟悉,并发修改异常。集合遍历时进行增删操作都需要留意是否会触发ConcurrentModificationException异常

    下面写个简单的例子

    	public static void main(String[] args) {
    
    		ArrayList<String> datalist = new ArrayList<String>();
    		for(int i=0;i<100;i++) {
    			datalist.add(i+"stringdata");
    		}
    		
    		int num = 0;
    		 Iterator<String> itea = datalist.iterator();
    		 //删除不会出错
    		 while(itea.hasNext()) {
    			 num++;
    			 if(num %2 ==0) {
    				 String str = itea.next();
    				 itea.remove(); 
    			 }
    			
    		 }
    		
    		int count = 0;
    		
            //少量删除不会报错,大量删除会报indexoutofbounds
    		for(int i = 0;i<datalist.size();i++) {
    			count++;
    			if(i== 5) {
    				datalist.remove(i);
    				System.out.println("delete   "+i+"    "+datalist.get(i)+"");
    			}
    			
    		}
    		
    		System.out.println("执行次数 "+count);
    		num = 0;
    //删除就会出错
    		for(String data :datalist) {
    			num++;
    			if(num == 5) {
    				datalist.remove(data);
    			}
    			
    		}
    		
    	}
    Exception in thread "main" java.util.ConcurrentModificationException
    	at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
    	at java.util.ArrayList$Itr.next(Unknown Source)
    	at com.ldx.demo2.Test4.main(Test4.java:41)

    2 为什么迭代器删除不会出错

    集合都实现了自己的迭代器,从ArrayList进行迭代器的分析,ArrayList..iterator()获取迭代器,

    迭代器不会出错原因:迭代器内部还是利用ArrayList的添加删除函数进行操作,只不过操作只有会对相应的指针进行修改(下一个),如果进行了删除操作,集合整体长度变小,指向下一个的指针也会相应减小,所以再次访问下一个时就不会发生错误了。

    //获取迭代器 
    public Iterator<E> iterator() {
            return new 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;
    
            Itr() {}
    
            public boolean hasNext() {
                return cursor != size;
            }
    
            @SuppressWarnings("unchecked")
            public E next() {
                checkForComodification();
                int i = cursor;
                if (i >= size)
                    throw new NoSuchElementException();
                Object[] elementData = ArrayList.this.elementData;
                if (i >= elementData.length)
                    throw new ConcurrentModificationException();
                cursor = i + 1;
                return (E) elementData[lastRet = i];
            }
    
    //重点看remove操作
            public void remove() {
                if (lastRet < 0)
                    throw new IllegalStateException();
                checkForComodification();
    
                //利用集合的方法删除数据,然后修改指向下一个元素的指针,
                try {
                    ArrayList.this.remove(lastRet);
                    cursor = lastRet;
                    lastRet = -1;
                //两个值相同,做判断时不会出现异常
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
    
           
            //modeCount 利用集合的操作可以修改,expectedModCount 则只有利用迭代器才能修改
            //如果操作之前两个值不一样,就会报异常
            final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
        }
    
    
    arrayList remove函数
    
    public E remove(int index) {
            rangeCheck(index);
            //修改modCount
            modCount++;
            E oldValue = elementData(index);
    
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            elementData[--size] = null; // clear to let GC do its work
    
            return oldValue;
        }

     

    看源码还可以发现ListIterator,是一个功能更加强大的Iterator,只能用于各种List类型的访问,ListIterator特点。

    (1)可以向前,向后遍历.

    (2)产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引.

    (3)可以使用set()方法替换它访问过的最后一个元素.

    (4)可以使用add()方法在next()方法返回的元素之前或previous()方法返回的元素之后插入一个元素.

    展开全文
  • ![图片说明](https://img-ask.csdn.net/upload/201707/12/1499839119_326037.png) 如图,怎么让aPlus[i]的i传递到add()这个函数,然后让其赋值给num
  • for循环与增强for循环

    千次阅读 2019-02-26 00:00:58
    @for循环与增强for循环 for与增强for循环的对比 for循环分为两种: 第一种为普通的for循环 这种for循环通常需要三个步骤即 for(初始表达式;条件表达式;递增表达式)有时候递增表达式也可以省去,一般是在使用...
  • 关于增强for循环的用法

    万次阅读 多人点赞 2016-12-02 12:50:07
    一、增强for循环增强for循环的作用: 简化迭代器的书写格式。(注意:增强for循环的底层还是使用了迭代器遍历。) 增强for循环的适用范围: 如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。 ...
  • 增强for循环不能获取下标,所以遍历数组时最好使用普通for循环。2,特点:书写简洁。对集合进行遍历,只能获取集合元素,不能对集合进行操作,类似迭代器的简写形式,但是迭代器可以对元素进行remove操作(ListI...
  • 增强for循环用法

    千次阅读 2014-06-08 19:33:38
    增强for循环用法 1.首先增强for循环和iterator遍历的效果是一样的,也就说增强for循环的内部也就是调用iteratoer实现的, 但是增强for循环有些缺点,例如不能在增强循环里动态的删除集合内容。不能获取下标等。 ...
  • 增强for循环的使用

    千次阅读 2015-12-08 23:06:52
    最近在工作发现增强for循环对集合的操作很方便 下面是增强for循环的用法: 1.增强for循环和iterator遍历的效果是一样的,也就说 增强for循环的内部也就是调用iteratoer实现的(可以查看编译后的文件),但是增强...
  • 遍历集合所有元素的话用增强For循环更加简洁, 如果是复杂的循环,还是For循环比较好,For循环支持索引取元素,可以使用下标控制位置. 高级For循环有一个局限性, 必须得有个被遍历的目标. 建议在遍历数组的时候,还是...
  • 首先普通for循环是能获取元素下标,并能通过下标遍历元素,而增强for却不可以获取下标,因此在遍历时的效率不同。当为数组时,效率几乎是差不多的当为集合时效率却大不同,当为ArrayLIst时,普通for的效率高于增强...
  • for循环分为两种:一种为普通for循环,一种为增强for循环(也就是foreach循环) 区别: 1)任何循环都能用普通for循环运行,但不一定能用增强for循环,也就是增强for循环的使用范围要小。 2)增强for循环内部其实是...
  • Java关于增强For循环

    2018-03-30 00:41:34
    增强for循环其也是利用的迭代器,如果是只要遍历元素的话 增强for循环较为简单 其基本的格式为 : for(数据类型 变量名 :遍历的目标) {  //其中内容与普通的for循环相似 } ...
  • java增强for循环中获取index

    千次阅读 2018-06-06 19:22:00
    java增强for循环中获取index http://rensanning.iteye.com/blog/2003205 转载于:https://www.cnblogs.com/czlovezmt/p/9146868.html
  • 1、增强for循环书写简洁,遍历数组时不需要下标,主要用于数组或集合的遍历,数组或集合遍历完毕时循环会结束执行。 2、普通for循环需要三个条件,包括循环变量、循环结束条件和循环变量的变化。在进行数据遍...
  • java中增强for循环的原理

    千次阅读 2015-01-23 23:21:16
    java中增强for循环的原理 增强for循环的语句如下: for(ElementType element:arrayName){}; 遍历数组 int[] arr = {1,2,3}; for(int i = 0; i  System.out.println(arr[i]);//1,2,3 } for(int e : arr)...
  • 总结: 1、For-Each循环的缺点:丢掉了索引信息。 ...1.首先增强for循环和iterator遍历的效果是一样的,也就说增强for循环的内部也就是调用iteratoer实现的, 但是增强for循环有些缺点,例如...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,638
精华内容 6,655
关键字:

增强for循环中下标