精华内容
下载资源
问答
  • List<String> list = new ArrayList<>(); list.add("1"); list.add("2"); list.add("3"); list.add("3"); list.add("4"); System.out.println(list);... for (int i = 0; i < list.size(); ) { .
     List<String> list = new ArrayList<>();
            list.add("1");
            list.add("2");
            list.add("3");
            list.add("3");
            list.add("4");
            System.out.println(list);
      for (int i = 0; i < list.size(); ) {
                String s = list.get(i);
                if (s.equals("4")) {
                    list.remove(i);
                    continue;
                }
                System.out.println(i);
                i++;
            }
            System.out.println(list);
    
            Iterator<String> it = list.iterator();
            while(it.hasNext()) {
                if (it.next().equals("1")) {
                    it.remove();
                }
            }
            System.out.println(list);
        }
         
    
    展开全文
  • Java 迭代器以及和for循环的比较

    千次阅读 2015-07-30 08:39:38
    迭代器是一种模式,它可以使得对于序列类型的数据结构的遍历行为...Java提供一个专门的迭代器>Iterator,我们可以对某个序列实现该interface,来提供标准的Java迭代器。Iterator接口实现后的功能是“使用”一个迭代器.

    迭代器是一种模式,它可以使得对于序列类型的数据结构的遍历行为与被遍历的对象分离,即我们无需关心该序列的底层结构是什么样子的。只要拿到这个对象,使用迭代器就可以遍历这个对象的内部.

    1.Iterator

    Java提供一个专门的迭代器<<interface>>Iterator,我们可以对某个序列实现该interface,来提供标准的Java迭代器。Iterator接口实现后的功能是“使用”一个迭代器.

    文档定义:

    [java]  view plain copy print ?
    1. Package java.util;

    2. publicinterface Iterator<E> {

    3. boolean hasNext();//判断是否存在下一个对象元素

    4. E next();

    5. void remove();
    6. }
    [java]  view plain copy print ?
    1. <span style="font-size:18px;">Package  java.util;   
    2.   
    3. public interface Iterator<E> {  
    4.   
    5.     boolean hasNext();//判断是否存在下一个对象元素  
    6.   
    7.      E next();  
    8.   
    9.     void remove();  
    10. }  
    11. </span>  


    2.Iterable

    Java中还提供了一个Iterable接口,Iterable接口实现后的功能是“返回”一个迭代器,我们常用的实现了该接口的子接口有: Collection<E>, Deque<E>, List<E>, Queue<E>, Set<E> 等.该接口的iterator()方法返回一个标准的Iterator实现。实现这个接口允许对象成为 Foreach 语句的目标。就可以通过Foreach语法遍历你的底层序列。

    Iterable接口包含一个能够产生Iterator的iterator()方法,并且Iterable接口被foreach用来在序列中移动。因此如果创建了任何实现Iterable接口的类,都可以将它用于foreach语句中。

    [java]  view plain copy print ?
    1. 文档定义:

    2. Package java.lang;

    3. import java.util.Iterator;
    4. public interface Iterable<T> {
    5. Iterator<T> iterator();
    6. }
    [java]  view plain copy print ?
    1. <span style="font-size:18px;">文档定义:  
    2.   
    3. Package  java.lang;   
    4.   
    5. import  java.util.Iterator;   
    6. public interface Iterable<T> {   
    7.      Iterator<T> iterator();   
    8. }  
    9.   
    10. </span>  


    [java]  view plain copy print ?
    1. 使用Iterator的简单例子

    2. import java.util.*;

    3. publicclass TestIterator {


    4. public static void main(String[] args) {



    5. List list=new ArrayList();

    6. Map map=new HashMap();

    7. for(int i=0;i<10;i++){

    8. list.add(new String("list"+i) );

    9. map.put(i, new String("map"+i));

    10. }

    11. Iterator iterList= list.iterator();//List接口实现了Iterable接口

    12. while(iterList.hasNext()){

    13. String strList=(String)iterList.next();

    14. System.out.println(strList.toString());

    15. }

    16. Iterator iterMap=map.entrySet().iterator();

    17. while(iterMap.hasNext()){

    18. Map.Entry strMap=(Map.Entry)iterMap.next();

    19. System.out.println(strMap.getValue());



    20. }

    21. }

    22. }

    23. <span style="color: rgb(0, 0, 153); font-size: 18px;"> </span><span style="color: rgb(0, 0, 153); font-size: 18px;"></span>
    [java]  view plain copy print ?
    1. <span style="font-size:18px;">使用Iterator的简单例子  
    2.   
    3. import java.util.*;  
    4.   
    5. public class TestIterator {  
    6.   
    7.   
    8.    public static void main(String[] args) {  
    9.   
    10.           
    11.   
    12.       List list=new ArrayList();  
    13.   
    14.       Map map=new HashMap();  
    15.   
    16.       for(int i=0;i<10;i++){  
    17.   
    18.           list.add(new String("list"+i) );  
    19.   
    20.           map.put(i, new String("map"+i));  
    21.   
    22.       }  
    23.   
    24.       Iterator iterList= list.iterator();//List接口实现了Iterable接口  
    25.   
    26.         while(iterList.hasNext()){  
    27.   
    28.           String strList=(String)iterList.next();  
    29.   
    30.           System.out.println(strList.toString());  
    31.   
    32.       }  
    33.   
    34.       Iterator iterMap=map.entrySet().iterator();  
    35.   
    36.       while(iterMap.hasNext()){  
    37.   
    38.           Map.Entry  strMap=(Map.Entry)iterMap.next();  
    39.   
    40.           System.out.println(strMap.getValue());  
    41.   
    42.    
    43.   
    44.       }  
    45.   
    46.    }  
    47.   
    48. }  
    49.   
    50.  <span style="color:#0099;">  </span><span style="color:#0099;"></span> </span>  

    接口Iterator在不同的子接口中会根据情况进行功能的扩展,例如针对List的迭代器ListIterator,该迭代器只能用于各种List类的访问。ListIterator可以双向移动。添加了previous()等方法.

    3 Iterator与泛型搭配

    Iterator对集合类中的任何一个实现类,都可以返回这样一个Iterator对象。可以适用于任何一个类。

    因为集合类(List和Set等)可以装入的对象的类型是不确定的,从集合中取出时都是Object类型,用时都需要进行强制转化,这样会很麻烦,用上泛型,就是提前告诉集合确定要装入集合的类型,这样就可以直接使用而不用显示类型转换.非常方便.

    4.foreach和Iterator的关系

    for each是jdk5.0新增加的一个循环结构,可以用来处理集合中的每个元素而不用考虑集合定下标。

    格式如下 

    for(variable:collection){ statement; }

    定义一个变量用于暂存集合中的每一个元素,并执行相应的语句(块)。collection必须是一个数组或者是一个实现了lterable接口的类对象。 

    [java]  view plain copy print ?
    1. 上面的例子使用泛型和forEach的写法:

    2. import java.util.*;
    3. public class TestIterator {



    4. public static void main(String[] args) {



    5. List<String> list=new ArrayList<String> ();

    6. for(int i=0;i<10;i++){

    7. list.add(new String("list"+i) );

    8. }

    9. for(String str:list){

    10. System.out.println(str);

    11. }

    12. }
    [java]  view plain copy print ?
    1. <span style="font-size:18px;">上面的例子使用泛型和forEach的写法:  
    2.   
    3. import java.util.*;  
    4. public class TestIterator {  
    5.   
    6.   
    7.   
    8.    public static void main(String[] args) {  
    9.   
    10.           
    11.   
    12.       List<String>  list=new ArrayList<String> ();  
    13.   
    14.       for(int i=0;i<10;i++){  
    15.   
    16.           list.add(new String("list"+i) );  
    17.   
    18.       }  
    19.   
    20.       for(String str:list){  
    21.   
    22.         System.out.println(str);  
    23.   
    24.       }    
    25.   
    26. }  
    27.   
    28. </span>  


    可以看出,使用for each循环语句的优势在于更加简洁,更不容易出错,不必关心下标的起始值和终止值。

    forEach不是关键字,关键字还是for,语句是由iterator实现的,他们最大的不同之处就在于remove()方法上。

    一般调用删除和添加方法都是具体集合的方法,例如:

    List list = new ArrayList(); list.add(...); list.remove(...);

    但是,如果在循环的过程中调用集合的remove()方法,就会导致循环出错,因为循环过程中list.size()的大小变化了,就导致了错误。 所以,如果想在循环语句中删除集合中的某个元素,就要用迭代器iterator的remove()方法,因为它的remove()方法不仅会删除元素,还会维护一个标志,用来记录目前是不是可删除状态,例如,你不能连续两次调用它的remove()方法,调用之前至少有一次next()方法的调用。

    forEach就是为了让用iterator循环访问的形式简单,写起来更方便。当然功能不太全,所以但如有删除操作,还是要用它原来的形式。

    4 使用for循环与使用迭代器iterator的对比

    效率上的各有有事

    采用ArrayList对随机访问比较快,而for循环中的get()方法,采用的即是随机访问的方法,因此在ArrayList里,for循环较快

    采用LinkedList则是顺序访问比较快,iterator中的next()方法,采用的即是顺序访问的方法,因此在LinkedList里,使用iterator较快

    从数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定元素.而Iterator 适合访问链式结构,因为迭代器是通过next()和Pre()来定位的.可以访问没有顺序的集合.

    而使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素,而不用考虑集合类的内部实现(只要它实现了 java.lang.Iterable 接口),如果使用 Iterator 来遍历集合中元素,一旦不再使用 List 转而使用 Set 来组织数据,那遍历元素的代码不用做任何修改,如果使用 for 来遍历,那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样.

    展开全文
  • Java迭代器(iterator详解以及和for循环的区别) 觉得有用的话,欢迎一起讨论相互学习~[Follow] 转载自 https://blog.csdn.net/Jae_Wang/article/details/80526216 前言 迭代器是一种模式、详细可见其设计模式,可以...

    Java迭代器(iterator详解以及和for循环的区别)

    觉得有用的话,欢迎一起讨论相互学习~

    我的微博我的github我的B站

    • 转载自 https://blog.csdn.net/Jae_Wang/article/details/80526216

    前言

    • 迭代器是一种模式、详细可见其设计模式,可以使得序列类型的数据结构的遍历行为与被遍历的对象分离,即我们无需关心该序列的底层结构是什么样子的。只要拿到这个对象,使用迭代器就可以遍历这个对象的内部
    • Iterable 实现这个接口的集合对象支持迭代,是可以迭代的。实现了这个可以配合foreach使用~
    • Iterator 迭代器,提供迭代机制的对象,具体如何迭代是这个Iterator接口规范的。
    //Iterable JDK源码
    //可以通过成员内部类,方法内部类,甚至匿名内部类去实现Iterator
    
    public interface Iterable<T>
    {
    
        Iterator<T> iterator();
    
    
    • Iterable还有一个默认的方法forEach()
    • 而Iterator接口:包含三个方法:hasNext,next,remove、remove一般很少用到.
    
    public interface Iterator<E> {
    
    
        boolean hasNext();    //每次next之前,先调用此方法探测是否迭代到终点
    
        E next();            //返回当前迭代元素 ,同时,迭代游标后移
    
    
         /*删除最近一次已近迭代出出去的那个元素。
         只有当next执行完后,才能调用remove函数。
         比如你要删除第一个元素,不能直接调用 remove()   而要先next一下( );
         在没有先调用next 就调用remove方法是会抛出异常的。
         这个和MySQL中的ResultSet很类似
        */
        void remove()
        {
            throw new UnsupportedOperationException("remove");
        }
    

    Note

    • 迭代出来的元素都是原来集合元素的拷贝。
    • Java集合中保存的元素实质是对象的引用,而非对象本身。
    • 迭代出的对象也是引用的拷贝,结果还是引用。那么如果集合中保存的元素是可变类型的,那么可以通过迭代出的元素修改原集合中的对象。
    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class test {
        public static void main(String[] args) {
            ArrayList<Person> array = new ArrayList<Person>();
    
            Person p1 = new Person("Tom1");
            Person p2 = new Person("Tom2");
            Person p3 = new Person("Tom3");
            Person p4 = new Person("Tom4");
    
            array.add(p1);
            array.add(p2);
            array.add(p3);
            array.add(p4);
    
            Iterator<Person> iterator = array.iterator();
    
            for (Person pp : array){
                System.out.println(pp.getName());
            }
    
            System.out.println("\r\n" + "-----利用Lambda表达式的foreach-----" + "\r\n");
            array.forEach(obj -> System.out.println(obj.getName()));
    
    
            System.out.println("\r\n" + "-----利用for循环-----" + "\r\n");
            for(Person p : array){
                p.setName("wang");
            }
    
            while(iterator.hasNext()){
                System.out.println(iterator.next().getName()); //输出的是wang,而不是tom
            }
    
    
    
        }
    }
    

    Map遍历也是一样的~

    public static void main(String[] args) {
            Map map = new HashMap();
            for(int i = 0; i < 10; i ++){
                map.put(i, String.valueOf("map" + i));
            }
            Iterator iterMap = map.entrySet().iterator();
            while(iterMap.hasNext()){
                Map.Entry strMap = (Map.Entry)iterMap.next();
                System.out.println("key为:" + strMap.getKey() +
                        ", value为:" + strMap.getValue());
            }
        }
    

    那么当Iterator迭代访问Collection集合中元素时,Collection的元素不能改变(多个线程的修改),只有通过Iterator的remove()方法删除上一次next()方法返回集合才可以。这样会引发ModificationException异常,即fail-fast机制

    //创建集合,添加元素和上述一样      
            Iterator<Person> iterator = array.iterator();
    
          while(iterator.hasNext()){
             String name = iterator.next().getName();
             System.out.println(name);
             if(name.equals("Tom3")){
                 //array.remove(name);  不推荐这种方式
                 iterator.remove();
             }
          }
    

    Iterator与泛型搭配:

    • Iterator对集合类中的任何一个实现类,都可以返回这样一个Iterator对象。可以适用于任何一个类。
    • 因为集合类(List和Set等)可以装入的对象的类型是不确定的,从集合中取出时都是Object类型,用时都需要进行强制转化,这样会很麻烦,用上泛型,就是提前告诉集合确定要装入集合的类型,这样就可以直接使用而不用显示类型转换.非常方便.

    foreach和Iterator的关系:

    • for each以用来处理集合中的每个元素而不用考虑集合定下标。就是为了让用Iterator简单。但是删除的时候,区别就是在remove,循环中调用集合remove会导致原集合变化导致错误,而应该用迭代器的remove方法。

    使用for循环还是迭代器Iterator对比

    • 采用ArrayList对随机访问比较快,而for循环中的get()方法,采用的即是随机访问的方法,因此在ArrayList里,for循环较快
    • 采用LinkedList则是顺序访问比较快,iterator中的next()方法,采用的即是顺序访问的方法,因此在LinkedList里,使用iterator较快
    • 从数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定元素.而Iterator 适合访问链式结构,因为迭代器是通过next()和Pre()来定位的.可以访问没有顺序的集合.
    • 而使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素,而不用考虑集合类的内部实现(只要它实现了 java.lang.Iterable 接口),如果使用 Iterator 来遍历集合中元素,一旦不再使用 List 转而使用 Set 来组织数据,那遍历元素的代码不用做任何修改,如果使用 for 来遍历,那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样.(还是说明了一点遍历和集合本身分离了)
    展开全文
  • 迭代器是一种模式,它可以使得对于序列类型的数据结构...Java提供一个专门的迭代器>Iterator,我们可以对某个序列实现该interface,来提供标准的Java迭代器。Iterator接口实现后的功能是“使用”一个迭代器. 文档定义:

    迭代器是一种模式,它可以使得对于序列类型的数据结构的遍历行为与被遍历的对象分离,即我们无需关心该序列的底层结构是什么样子的。只要拿到这个对象,使用迭代器就可以遍历这个对象的内部.

    1.Iterator

    Java提供一个专门的迭代器<<interface>>Iterator,我们可以对某个序列实现该interface,来提供标准的Java迭代器。Iterator接口实现后的功能是“使用”一个迭代器.

    文档定义:

    1. Package java.util;

    2. publicinterface Iterator<E> {

    3. boolean hasNext();//判断是否存在下一个对象元素

    4. E next();

    5. void remove();
    6. }
    1. <span style="font-size:18px;">Package  java.util;   
    2.   
    3. public interface Iterator<E> {  
    4.   
    5.     boolean hasNext();//判断是否存在下一个对象元素  
    6.   
    7.      E next();  
    8.   
    9.     void remove();  
    10. }  
    11. </span>  


    2.Iterable

    Java中还提供了一个Iterable接口,Iterable接口实现后的功能是“返回”一个迭代器,我们常用的实现了该接口的子接口有: Collection<E>, Deque<E>, List<E>, Queue<E>, Set<E> 等.该接口的iterator()方法返回一个标准的Iterator实现。实现这个接口允许对象成为 Foreach 语句的目标。就可以通过Foreach语法遍历你的底层序列。

    Iterable接口包含一个能够产生Iterator的iterator()方法,并且Iterable接口被foreach用来在序列中移动。因此如果创建了任何实现Iterable接口的类,都可以将它用于foreach语句中。

    1. 文档定义:

    2. Package java.lang;

    3. import java.util.Iterator;
    4. public interface Iterable<T> {
    5. Iterator<T> iterator();
    6. }
    1. <span style="font-size:18px;">文档定义:  
    2.   
    3. Package  java.lang;   
    4.   
    5. import  java.util.Iterator;   
    6. public interface Iterable<T> {   
    7.      Iterator<T> iterator();   
    8. }  
    9.   
    10. </span>  


    1. 使用Iterator的简单例子

    2. import java.util.*;

    3. publicclass TestIterator {


    4. public static void main(String[] args) {



    5. List list=new ArrayList();

    6. Map map=new HashMap();

    7. for(int i=0;i<10;i++){

    8. list.add(new String("list"+i) );

    9. map.put(i, new String("map"+i));

    10. }

    11. Iterator iterList= list.iterator();//List接口实现了Iterable接口

    12. while(iterList.hasNext()){

    13. String strList=(String)iterList.next();

    14. System.out.println(strList.toString());

    15. }

    16. Iterator iterMap=map.entrySet().iterator();

    17. while(iterMap.hasNext()){

    18. Map.Entry strMap=(Map.Entry)iterMap.next();

    19. System.out.println(strMap.getValue());



    20. }

    21. }

    22. }

    23. <span style="color: rgb(0, 0, 153); font-size: 18px;"> </span><span style="color: rgb(0, 0, 153); font-size: 18px;"></span>
    1. <span style="font-size:18px;">使用Iterator的简单例子  
    2.   
    3. import java.util.*;  
    4.   
    5. public class TestIterator {  
    6.   
    7.   
    8.    public static void main(String[] args) {  
    9.   
    10.           
    11.   
    12.       List list=new ArrayList();  
    13.   
    14.       Map map=new HashMap();  
    15.   
    16.       for(int i=0;i<10;i++){  
    17.   
    18.           list.add(new String("list"+i) );  
    19.   
    20.           map.put(i, new String("map"+i));  
    21.   
    22.       }  
    23.   
    24.       Iterator iterList= list.iterator();//List接口实现了Iterable接口  
    25.   
    26.         while(iterList.hasNext()){  
    27.   
    28.           String strList=(String)iterList.next();  
    29.   
    30.           System.out.println(strList.toString());  
    31.   
    32.       }  
    33.   
    34.       Iterator iterMap=map.entrySet().iterator();  
    35.   
    36.       while(iterMap.hasNext()){  
    37.   
    38.           Map.Entry  strMap=(Map.Entry)iterMap.next();  
    39.   
    40.           System.out.println(strMap.getValue());  
    41.   
    42.    
    43.   
    44.       }  
    45.   
    46.    }  
    47.   
    48. }  
    49.   
    50.  <span style="color:#0099;">  </span><span style="color:#0099;"></span> </span>  

    接口Iterator在不同的子接口中会根据情况进行功能的扩展,例如针对List的迭代器ListIterator,该迭代器只能用于各种List类的访问。ListIterator可以双向移动。添加了previous()等方法.

    3 Iterator与泛型搭配

    Iterator对集合类中的任何一个实现类,都可以返回这样一个Iterator对象。可以适用于任何一个类。

    因为集合类(List和Set等)可以装入的对象的类型是不确定的,从集合中取出时都是Object类型,用时都需要进行强制转化,这样会很麻烦,用上泛型,就是提前告诉集合确定要装入集合的类型,这样就可以直接使用而不用显示类型转换.非常方便.

    4.foreach和Iterator的关系

    for each是jdk5.0新增加的一个循环结构,可以用来处理集合中的每个元素而不用考虑集合定下标。

    格式如下

    for(variable:collection){ statement; }

    定义一个变量用于暂存集合中的每一个元素,并执行相应的语句(块)。collection必须是一个数组或者是一个实现了lterable接口的类对象。

    1. 上面的例子使用泛型和forEach的写法:

    2. import java.util.*;
    3. public class TestIterator {



    4. public static void main(String[] args) {



    5. List<String> list=new ArrayList<String> ();

    6. for(int i=0;i<10;i++){

    7. list.add(new String("list"+i) );

    8. }

    9. for(String str:list){

    10. System.out.println(str);

    11. }

    12. }
    1. <span style="font-size:18px;">上面的例子使用泛型和forEach的写法:  
    2.   
    3. import java.util.*;  
    4. public class TestIterator {  
    5.   
    6.   
    7.   
    8.    public static void main(String[] args) {  
    9.   
    10.           
    11.   
    12.       List<String>  list=new ArrayList<String> ();  
    13.   
    14.       for(int i=0;i<10;i++){  
    15.   
    16.           list.add(new String("list"+i) );  
    17.   
    18.       }  
    19.   
    20.       for(String str:list){  
    21.   
    22.         System.out.println(str);  
    23.   
    24.       }    
    25.   
    26. }  
    27.   
    28. </span>  


    可以看出,使用for each循环语句的优势在于更加简洁,更不容易出错,不必关心下标的起始值和终止值。

    forEach不是关键字,关键字还是for,语句是由iterator实现的,他们最大的不同之处就在于remove()方法上。

    一般调用删除和添加方法都是具体集合的方法,例如:

    List list = new ArrayList(); list.add(...); list.remove(...);

    但是,如果在循环的过程中调用集合的remove()方法,就会导致循环出错,因为循环过程中list.size()的大小变化了,就导致了错误。 所以,如果想在循环语句中删除集合中的某个元素,就要用迭代器iterator的remove()方法,因为它的remove()方法不仅会删除元素,还会维护一个标志,用来记录目前是不是可删除状态,例如,你不能连续两次调用它的remove()方法,调用之前至少有一次next()方法的调用。

    forEach就是为了让用iterator循环访问的形式简单,写起来更方便。当然功能不太全,所以但如有删除操作,还是要用它原来的形式。

    4 使用for循环与使用迭代器iterator的对比

    效率上的各有有事

    采用ArrayList对随机访问比较快,而for循环中的get()方法,采用的即是随机访问的方法,因此在ArrayList里,for循环较快

    采用LinkedList则是顺序访问比较快,iterator中的next()方法,采用的即是顺序访问的方法,因此在LinkedList里,使用iterator较快

    数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定元素.而Iterator 适合访问链式结构,因为迭代器是通过next()和Pre()来定位的.可以访问没有顺序的集合.

    而使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素,而不用考虑集合类的内部实现(只要它实现了 java.lang.Iterable 接口),如果使用 Iterator 来遍历集合中元素,一旦不再使用 List 转而使用 Set 来组织数据,那遍历元素的代码不用做任何修改,如果使用 for 来遍历,那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样.

    展开全文
  • java迭代器Iteratorforeach循环

    千次阅读 2015-05-22 16:01:51
    迭代器应用:  list l = new ArrayList();  l.add("aa");  l.add("bb");  l.add("cc");  for (Iterator iter = l.iterator(); iter.hasNext();) {  String str = (String)iter.next();  System.out....
  • Java之使用增强for循环和迭代器遍历

    千次阅读 2016-10-17 13:57:12
    1、通过key集合访问,对Key敢兴趣,可以访问... for(String k:maps.keySet()){  System.out.println(k+":"+maps.get(k));  } 2、通过value集合访问,只对value值感兴趣,无法访问key值;  for(String value:maps.va
  • 对于 java 中 list 集合的遍历是我们开发中很长见到的操作,平时用的较多的有迭代器的方式或者是通过for循环遍历,那这两者有怎样的区别呢? 在对list进行遍历输出时效果是一样的,都能有效的输出 list 中的元素,...
  • 原文地址:... 在 JDK1.5 之后,至少有三种遍历的方式:ForEach、迭代器for循环性能比较   package bupt.xiaoye.charpter2.list;    import java.util.ArrayList;  import java...
  • 迭代器和for循环的效率比较

    万次阅读 2013-06-30 22:52:34
    实体Person类   ...public class Person { ...import java.util.ArrayList;...import java.util.Iterator;...import java.util.LinkedList...for循环便于访问顺序存储的记录,而foreach和迭代器便于访问链接存储。  
  • 一、Iterator接口 1、集合有很多种,存储的数据类型不同,那么取出的方式也不同,但是有了迭代器就可以都取出来 2、迭代:即Collection集合元素的...3、java.util.Iterator接口:迭代器(对集合进行遍历) 有两个...
  • java 迭代器跳出迭代In this post we are going to discuss about some basics of Java Enumeration and in-depth discussion about Java Iterator. As Java Enumeration interface is deprecated, it is not ...
  • package base4; import java.util.List;...在for循环中逆向遍历集合时,出现java.util.NoSuchElementException的错误,,,但在for循环中顺向遍历集合时,不会出现任何问题,我想知道原因,谢谢各位大神赐教,,,
  • 1、通过key集合访问,对Key敢兴趣,... for(String k:maps.keySet()){  System.out.println(k+":"+maps.get(k));  } 2、通过value集合访问,只对value值感兴趣,无法访问key值;  for(String value:maps.va
  • 迭代器是一种模式,它可以使得对于序列类型的数据结构的遍历...Java提供一个专门的迭代器>Iterator,我们可以对某个序列实现该interface,来提供标准的Java迭代器。Iterator接口实现后的功能是“使用”一个迭代器.
  • Iterator 接口也是Java集合中的一员,但它与collection、Hap接口有所不同,Collection 接口与Nap接口主要用于存储元素,而 Iterator主要用于迭代访问(即遍历) collection 中的元素,因此Iterator对象也被称为迭代器...
  • 文章目录1、Iterator迭代器2、开发中推荐使用方式3、错误使用方式4、Iterator迭代器中remove()方法5、利用迭代器实现的增强for循环遍历或者说foreach遍历 1、Iterator迭代器 用来遍历Colletioon接口实现的集合,返回...
  •  for(String k:maps.keySet()){  System.out.println(k+":"+maps.get(k));  } 2、通过value集合访问,只对value值感兴趣,无法访问key值;  for(String value:maps.values()){ ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,897
精华内容 34,758
关键字:

java迭代器和for循环

java 订阅