精华内容
下载资源
问答
  • NULL 博文链接:https://rensanning.iteye.com/blog/2003205
  • 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

    java增强for循环中获取index

     

    http://rensanning.iteye.com/blog/2003205

    转载于:https://www.cnblogs.com/czlovezmt/p/9146868.html

    展开全文
  • java增强for循环和普通循环比较

    千次阅读 2018-07-01 11:34:43
    增强for循环和普通循环比较:      (1)对于非集合类(没有实现 Iterable接口)的数组遍历,增强for循环和普通循环遍历原理相同,效率相同      (2...
    增强型for循环和普通循环比较:
         (1)对于非集合类(没有实现 Iterable接口)的数组遍历,增强型for循环和普通循环遍历原理相同,效率相同
         (2)对于集合类(实现了Iterable接口),增强型for循环的遍历其本质就是迭代器 iterator的遍历,和普通循环遍历相比,各自有自己适用的场景,比如说普通for循环比较适合List类(数组类)遍历通过下标查找数据的,而增强型for循环则比较适合链表结构的集合的遍历。

    一.对于基本数组类的遍历,我就不举例子说明了,大家可以通过遍历一个日大的数组,通过查看两种方式遍历的时间差,基本是相同的。当然,也可以通过 javap命令,查看运行的虚拟机指令对比(这是从底层查看运行,想了解的朋友,可以查看我的虚拟机介绍部分),可以看到普通for循环和增强型for循环运行相同。

    二.集合类,增强型for循环和普通for循环比较
        增强型for循环和iterator遍历是一样的,可以通过查看编译后的class文件,或者通过javap命令看到。

       那么普通for循环和迭代器遍历又有什么区别呢?
         大家知道普通for循环是通过下标访问的,所以非常适用于类似于List这种下标获取(list.get(0))内容的集合.而增强型for循环(iterator遍历)则比较适合于链表的遍历,下面咱通过实例测试说明:
       
    
         
    1. List<String> list = new ArrayList<String>();
    2. for ( int i = 0; i < 500000; i++) {
    3. list.add( “xiaotang”);
    4. }
    5. long start = System.currentTimeMillis();
    6. int size = list.size();
    7. String str = null;
    8. for ( int i = 0; i < size; i++) {
    9. str = list.get(i);
    10. }
    11. System.out.println( “for + get(i)方法: “
    12. + (System.currentTimeMillis() - start));
    13. long start2 = System.currentTimeMillis();
    14. for (String str1 : list) {
    15. }
    16. System.out.println( “Iterator(foreach)方法:”
    17. + (System.currentTimeMillis() - start2));
        运行结果如下:
       
    可以看到:对于ArrayList集合,添加 500000记录,然后通过普通for循环遍历明显快于增强型for循环。
    那么链表类集合的遍历呢?我们在这里使用 LinkedList测试,测试代码如下:
    
          
    1. List<String> list = new LinkedList<String>();
    2. for ( int i = 0; i < 5000; i++) {
    3. list.add( “xiaotang”);
    4. }
    5. long start = System.currentTimeMillis();
    6. int size = list.size();
    7. String str = null;
    8. for ( int i = 0; i < size; i++) {
    9. str = list.get(i);
    10. }
    11. System.out.println( “for + get(i)方法: “
    12. + (System.currentTimeMillis() - start));
    13. long start2 = System.currentTimeMillis();
    14. for (String str1 : list) {
    15. }
    16. System.out.println( “Iterator(foreach)方法:”
    17. + (System.currentTimeMillis() - start2));

        运行结果如下:

       
       可以看到对于链表结构的遍历,增强型for循环的遍历速度是远远快于普通for循环的!
     




    展开全文
  • 在遍及集合过程中对集合进行删除操作最好不要做,如果非要做可以利用迭代器,并发集合,...1 面试遇到的问题和迭代器没关系考察的是普通的for循环和foreach循环 下面先说出观点:  普通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()方法返回的元素之后插入一个元素.

    展开全文
  • 首先普通for循环是能获取元素下标,并能通过下标遍历元素,而增强for却不可以获取下标,因此在遍历时的效率不同。当为数组时,效率几乎是差不多的当为集合时效率却大不同,当为ArrayLIst时,普通for的效率高于增强...

    首先普通for循环是能获取元素下标,并能通过下标遍历元素,而增强for却不可以获取下标,因此在遍历时的效率不同。

    当为数组时,效率几乎是差不多的

    当为集合时效率却大不同,当为ArrayLIst时,普通for的效率高于增强for

    当为LInkedList时,增强for的效率高于普通for

    验证代码:

    package com.niuguwang.jihe;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.LinkedList;
    
    public class CollectionTest {
    
    	public static void main(String[] args) {
    //		ArrayList listtest =new ArrayList<>();
    //		LinkedList listtest =new LinkedList();
    		person[] listtest =new person[5000000];
    		for(int i=0;i<5000000;i++){
    			listtest[i]= new person("xiaoming");
    		}
    /*		
    		for(int i=0;i<5000000;i++){
    			listtest.add(new person("xiaoming"));
    		}
    		
    	*/	
    		Object p=null;
    		long start=System.currentTimeMillis();
    		for(int i=0;i<listtest.length;i++){
    			p=listtest[i];
    		}
    /*		
    		for(int i=0;i<(listtest.size());i++){
    			p = listtest.get(i);
    		}
    		*/
    		
    		System.out.println("普通for的耗用时间     "+(System.currentTimeMillis()-start));
    		long start1=System.currentTimeMillis();
    		for(Object o:listtest){
                            p=o;
                     }
    		System.out.println("增强for的耗用时间     "+(System.currentTimeMillis()-start1));
    	}
    }
    class person{
    	String name;
    
    	public person(String name) {
    		super();
    		this.name = name;
    	}
    	
    }

    其次集合中的元素动态删除时,增强for无法动态删除,而普通for可以动态删除。在增强for动态删除时会报一个 java.util.ConcurrentModificationException的错误,而普通for却没有这个问题,但是每删除一个元素时,集合的size会发生变化,删除会有遗漏,所以建议使用迭代器Iterator对集合进行动态删除操作。

    在next()方法中有一个checkForComodification()方法,其实现为:

        final void checkForComodification() 
        {
             if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

      可以看到,该函数是用来判断集合的修改次数是否合法。

      在集合内部维护一个字段modCount用于记录集合被修改的次数,每当集合内部结构发生变化(add,remove,set)时,modCount+1。

      在迭代器内部也维护一个字段expectedModCount,同样记录当前集合修改的次数,初始化为集合的modCount值。当我们在调用Iterator进行遍历操作时,如果有其他线程修改list会出现modCount!=expectedModCount的情况,就会报并发修改异常java.util.ConcurrentModificationException。

    而使用迭代器删除时在执行remove操作时,同样先执行checkForComodification(),然后会执行ArrayList的remove()方法,该方法会将modCount值加1,这里我们将expectedModCount=modCount,使之保持统一。



    有参考博客https://blog.csdn.net/u010911386/article/details/52711519


    展开全文
  • 随机读取的情况下,数组结构优于链表结构;从头遍历的情况下,普通for循环只适用于数组结构,而迭代器根据实现不同,数组结构和链表结构都选取了效率高的方式遍历,增强for循环类比迭代器。
  • 以前网上看过的源码,嗯。... 开始前,先说一下增强for循环是什么鬼,就是咱们常用的for(数据类型 变量名 :遍历的目标){},底层还是使用了迭代器遍历。好了,开搞 一、List 1.List用下标来remove是可以的,因...
  • Java 增强for循环 泛型

    2018-10-09 21:12:00
    增强for循环专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。格式:for(元素的数据类型 变量 : Collection集合or数组){}例子 public ...
  • Java 数组的遍历访问(普通循环,增强for循环)普通循环增强 for 循环普通循环和增强 for 循环的区别 普通循环 首先我们要知道数组元素下标的合法区间:[0, length-1](即从0开始到数组长度减一)。我们可以通过下标...
  • = size(2),然后执行 var2.next(),此时 cursor=1 执行 list.remove(“e1”),此时,list的size将从2变为1 当执行完第一次循环,进入第二次hasNext()判断时,cursor=1而且size=1,导致Iterator认为已经遍历结束,...
  • for循环分为两种:一种为普通for...3)普通for循环可以获取元素索引,增强for循环无法获取元素索引 4)增强for循环比普通for循环代码更简洁。 5)增强for循环必要有被遍历的目标。 6)增强for循环无法在循环时动态的
  • for-each循环是jdk1.5引入的新的语法功能。并不是所有东西都可以使用这个循环的。可以看下Iterable接口的注释,它说明了除了数组外,其他类想要使用for-each循环必须实现这个接口。这一点表明除了数组外的for-each...
  • 增强for循环用法

    2017-01-04 14:40:57
    1.首先增强for循环和iterator遍历的效果是一样的,也就说增强for循环的内部也就是调用iteratoer实现的, 但是增强for循环有些缺点,例如不能在增强循环里动态的删除集合内容。不能获取下标等。 2.ArrayList由于...
  • java增强for循环

    2015-03-21 21:17:09
    package cn.jdk.foreach; import java.util.HashMap; import java.util.Map; public class ForEachTest { public static void main(String[] args) { int[] arr = {1,2,3};... for(int a:arr){ System.out.pr
  • for循环与增强for循环

    千次阅读 2019-02-26 00:00:58
    @for循环与增强for循环 for与增强for循环的对比 for循环分为两种: 第一种为普通的for循环 这种for循环通常需要三个步骤即 for(初始表达式;条件表达式;递增表达式)有时候递增表达式也可以省去,一般是在使用...
  • 整体来说: 增强型for循环使用起来比较方便,代码也比较简单,如果只是操作集合中元素的而不使用索引的话,建议用此...增强for循环不能获取下标,所以遍历数组时最好使用普通for循环。 2、特点: 书写简洁。 对集...
  • For-Each循环 For-Each循环也叫增强型的for循环,或者叫foreach循环。 For-Each循环是JDK5.0的新特性(其他新特性比如泛型、自动装箱等)。...之后实现了用增强for循环遍历二维数组;最后采用三种方式
  • 两个不同的list使用双重for遍历 删除listAccCount总的对象元素,增加accidentLevelCount中的对象元素,出现了空指针。改成了如下代码:
  • 增强for循环的用法

    2020-09-06 17:20:00
    一、增强for循环 增强for循环的作用:简化迭代器的书写格式。...增强for循环的缺点:增强for循环和iterator遍历的效果是一样的,也就说增强for循环的内部也就是调用iteratoer实现的,但是增强for循环有些缺点,例...
  • 增强for的优点:所谓的增强For循环,它能对数组和集合进行遍历,使用它会使用你的代码短小而精炼的多。 1、 简化数组和Collection集合的遍历,输入for,之后alt+/提示后自动补全 2、格式: for(元素数据类型 变量 : ...
  • Next() 获取下个元素,并把下标向后移动一位 import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Iter_test { public static void main(...
  • 1增强for和集合中的forEach方法的底层是通过迭代器实现的 2使用场景 3迭代器Iterator 4 使用普通for循环与使用迭代器iterator的对比 1)forEach循环能否完全替代普通for循环 2)效率上对比 5 map中能不能...
  • 增强for循环: 这种for循环的内部是调用了Iterator实现的(实现了Iterator接口),和Iterator遍历效果是一样(你可以断点调试跟踪代码看看内部原理),主要用于遍历数组、集合的每一个元素。 优点:1.写法简便 2.....
  • 在使用增强for循环时,在循环体内移除一个集合元素后,出现concurrentModificationException异常的解决办法
  • Java普通for和增强for探究

    千次阅读 2017-08-25 15:19:27
    最近在刷算法题,for循环自然是离不开的。今天一个某算法网站中做一道题目,提交...题目不是重点,重点是引起了我对Java for循环的探究。 既然探究,就得看看编译器是如何理解它的,于是我就反编译了一下,效果如下
  • 有关增强for循环的使用(详细)

    千次阅读 2021-01-24 11:26:10
    JDK1.5引进了一种新的循环类型,即增强型for循环,主要用于数组和集合 基本格式语法如下: for(type element: arrays) { ...增强for循环使用注意事项: 1、增强型for循环底层是使用了迭代器i.
  • for循环java出生的时候就已经支持了,在jdk 1.5中开始支持 foreach循环,foreach在一定程度上简化了集合的遍历,但是由于场景的局限性不能完全替代 for 循环。...
  • 如果用数组实现的,那最好用普通for循环,因为下标索引速度更快。增强型的for循环,其实是用iterator迭代器来做的,迭代器适合链表格式的存储结构。 所以,公司里很多人的代码都不规范,或者没有考虑效率问题,只是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,612
精华内容 3,444
关键字:

java增强for循环获取下标

java 订阅