精华内容
下载资源
问答
  • 普通for循环与增强for循环的差别:       普通for循环:通过角标操作数组更加灵活,并可操作数组内元素。...

    普通for循环与增强for循环的差别与注意事项:

          普通for循环:通过角标操作数组更加灵活,并可精确操作数组内元素。
          增强for循环:书写简洁,但难精确操作数组内元素。操作基本类型时难用。
    普通for循环示例:

    import java.util.Arrays;
    public class Test {
    	public static void main(String[] args) {
    		int[] forOne= {1,2,3,4,5};
    		for(int i = 0 ; i < forOne.length ; i++) {
    			forOne[i] = 1;
    		}
    		System.out.println(Arrays.toString(forOne));
    	}
    }
    

    输出:

    [1, 1, 1, 1, 1]
    

    增强for循环示例:

    class Test1{
    	public int i;
    }
    public class Test {
    	public static void main(String[] args) {
    		Test1[] a= {new Test1(),new Test1(),new Test1()};
    		
    		for(Test1 b:a) {
    			b.i=3;
    		}
    		for(Test1 b:a) {
    			System.out.print(b.i+" ");
    		}
    	}
    }
    

    输出:

    3 3 3
    

    增强for循环失败示例:

    import java.util.Arrays;
    public class Test {
    	public static void main(String[] args) {
    		int[] forOne= {1,2,3,4,5};
    		for(int i:forOne) {
    			i = 1;
    		}
    		System.out.println(Arrays.toString(forOne));
    	}
    }
    

    输出:

    [1, 2, 3, 4, 5]
    

          增强for循环并未对数组内元素产生影响。原因是此例执行循环的数组是基本类型,基本类型在进行赋值操作时是将内容进行了赋值,而不是将引用进行赋值,所以基本类型在用循环操作时不可使用增强for循环。
          但在某些情况下增强for循环也可以对组内int元素产生影响,例如static修饰的类的成员变量。(我水平有限只知道这么一个,欢迎补充)
    示例:

    import java.util.Arrays;
    class A{
    	private static long counter=1;
    	public String toString(){
    		//每return一次,counter就会+1
    		return "counter = "+(counter++) ;
    	}
    }
    
    public class Test {
    	public static void main(String[] args) {
    		A[] forOne= {new A() , new A()};
    		for(A i:forOne) {
    			//对象i有toString方法所以可以直接这么输出
    			System.out.println(i);
    		}
    		System.out.println(Arrays.toString(forOne));
    	}
    }
    

    输出:

    counter = 1
    counter = 2
    [counter = 3, counter = 4]
    
    展开全文
  • 增强for循环亦为高级for循环。 增强for循环内部是使用的Iterator来遍历的...任何的增强for循环都可以改写为普通for循环。遍历集合所有元素的话用增强for循环更加简洁,如果是复杂的循环,还是用for循环比较好,for循环

    增强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异常。

    展开全文
  • 有些人循环用的是普通for循环, 有些人用的是增强for循环, 它们之间有什么区别?应该在什么时候使用这两种循环了? ==========语法格式========== 普通for循环语法: for (int i = 0; i &lt; integers....

    有些人循环用的是普通for循环,

    有些人用的是增强for循环,

    它们之间有什么区别?应该在什么时候使用这两种循环了?

    ==========语法格式==========

    普通for循环语法:

    for (int i = 0; i < integers.length; i++) {  
        System.out.println(intergers[i]);  
    }  

    增强for循环语法:

    for(Integer in : integers){  
        System.out.println(in);  
    }  

    今天我们来比较一下两种for循环对ArrayList和LinkList集合的循环性能比较。首先简单的了解一下ArrayList和LinkList的区别:

    ArrayList是采用数组的形式保存对象的,这种方式将对象放在连续的内存块中,所以插入和删除时比较麻烦,查询比较方便。

    LinkList是将对象放在独立的空间中,而且每个空间中还保存下一个空间的索引,也就是数据结构中的链表结构,插入和删除比较方便,但是查找很麻烦,要从第一个开始遍历。

    将ArrayList和LinkList分别插入10万条记录

    测试代码:

    package utils;
    
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    
    public class ForEach {
        public static void main(String[] args) {
            List<Integer> arrayList = new ArrayList<Integer>();
            List<Integer> linkList = new LinkedList<Integer>();
            // 每个集合插入10万条数据
            for (int i = 0; i < 100000; i++) {
                arrayList.add(i);
                linkList.add(i);
            }
    
            int arry = 0;
    
            System.out.println("============遍历arrayList============");
    
            // 用for循环arrayList
            long forStartTime = System.currentTimeMillis();
            for (int i = 0; i < arrayList.size(); i++) {
                arry = arrayList.get(i);
            }
            long forEndTime = System.currentTimeMillis();
            System.out.println("for遍历需要:" + (forEndTime - forStartTime) + "毫秒");
    
    
            // 用增强for循环arrayList
            long forUpStartTime = System.currentTimeMillis();
            for (Integer in : arrayList) {
                arry = in;
            }
            long forUpEndTime = System.currentTimeMillis();
            System.out.println("增强for遍历需要:" + (forUpEndTime - forUpStartTime) + "毫秒");
    
    
            System.out.println("============linkList============");
    
            // 用for循环linkList
            long linkForStartTime = System.currentTimeMillis();
            int link = 0;
            for (int i = 0; i < linkList.size(); i++) {
                link = linkList.get(i);
            }
            long linkForEndTime = System.currentTimeMillis();
            System.out.println("for遍历:" + (linkForEndTime - linkForStartTime) + "毫秒");
    
            // 用增强for循环linkList
            long linkForeachStartTime = System.currentTimeMillis();
            for (Integer in : linkList) {
                link = in;
            }
            long linkForeachEndTime = System.currentTimeMillis();
            System.out.println("用增强for遍历需要:" + (linkForeachEndTime - linkForeachStartTime) + "毫秒");
    
        }
    }
    

    运行结果:

    可以看出,循环ArrayList时,普通for循环比foreach循环花费的时间要少一点;循环LinkList时,普通for循环比foreach循环花费的时间要多很多。当我将循环次数提升到一百万次的时候,循环ArrayList,普通for循环还是比foreach要快一点;但是普通for循环在循环LinkList时,程序直接卡死。

    结论:需要循环数组结构的数据时,建议使用普通for循环,因为for循环采用下标访问,对于数组结构的数据来说,采用下标访问比较好。

    需要循环链表结构的数据时,一定不要使用普通for循环,这种做法很糟糕,数据量大的时候有可能会导致系统崩溃。

    展开全文
  • 对于普通for循环,如果需要使用索引进行其它操作的话,建议用这个。 详细来说: 1、区别: 增强for循环必须有被遍历的目标(如集合或数组)。 普通for循环遍历数组的时候需要索引。 增强for循环不能获取下标,所以...

    整体来说:
    增强型for循环使用起来比较方便,代码也比较简单,如果只是操作集合中元素的而不使用索引的话,建议用此方法。
    对于普通for循环,如果需要使用索引进行其它操作的话,建议用这个。

    详细来说:
    1、区别:
    增强for循环必须有被遍历的目标(如集合或数组)。
    普通for循环遍历数组的时候需要索引。
    增强for循环不能获取下标,所以遍历数组时最好使用普通for循环。

    2、特点:
    书写简洁。
    对集合进行遍历,只能获取集合元素,不能对集合进行操作,类似迭代器的简写形式,但是迭代器可以对元素进行remove操作(ListIterator可以进行增删改查的操作)。

    3、格式:
    for(数据类型变量名 :被遍历的集合(collection)或者数组) {
    执行语句
    }

    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List; 
    public class ForTest {
            public static void main(String[] args) {
                    // TODO Auto-generated method stub
                    /* 1.普通数组中的使用 */  
            int array[] = { 1,2,3,4,5,6,7,8,9};    
            // 增强for循环  
            for (int item : array) {  
                System.out.println(item);  
            }  
      
            // 普通for循环
            for (int i = 0; i < array.length; i++)  
                System.out.println(array[i]);  
      
            /* 2.二维数组中的使用 */  
            int array2[][] = {{1,2,3}, {4,5,6}, {7,8,9} };  
              
            // 增强for循环  
            for (int arr[] : array2) {  
                for (int item : arr) {  
                    System.out.println(item);  
                }  
            }  
      
            // 普通for循环  
            for (int i = 0; i < array2.length; i++) {  
                for (int j = 0; j < array2[i].length; j++) {  
                    System.out.println(array2[i][j]);  
                }  
            }  
      
            /* 3.List中的使用 */  
            List<String> list = new ArrayList<String>();  
            list.add("我");  
            list.add("爱");  
            list.add("中");  
            list.add("国"); 
              
            // 增强for循环  
            for (String item : list){  
                System.out.println(item);             
            }  
                      
            //普通for循环
            for (int i = 0; i < list.size(); i++) {  
                System.out.println(list.get(i));  
            }  
      
            //迭代器遍历  
            Iterator<String> it = list.iterator();
            while (it.hasNext()) {  
                System.out.println(it.next());  
            }  
            }
    }
    
    

    4、示例(单个删除与批量删除)
    注:批量删除直接调用单个删除的方法

    在这里插入图片描述

    展开全文
  • 下面小编就为大家带来一篇浅谈普通for循环遍历LinkedList弊端。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 首先普通for循环是能获取元素下标,并能通过下标遍历元素,而增强for却不可以获取下标,因此在遍历时的效率不同。当为数组时,效率几乎是差不多的当为集合时效率却大不同,当为ArrayLIst时,普通for的效率高于增强...
  • 在遍及集合过程中对集合进行删除操作最好不要做,如果非要做可以利用迭代器,并发集合,或者同步代码。  单线程模式下直接使用迭代器提供的remove方法就行或者首先记录下标遍历... 普通for循环遍历集合过程中进行...
  • 普通for循环 数组元素下标的合法区间:[0, length-1]。我们可以通过下标来遍历数组中的元素,遍历时可以读取元素的值或者修改元素的值。 例: publicclassTest{ publicstaticvoidmain(String[]args){ int[]a=...
  • To Java程序员:切勿用普通for循环遍历LinkedList ArrayList与LinkedList的普通for循环遍历 对于大部分Java程序员朋友们来说,可能平时使用得最多的List就是ArrayList,对于ArrayList的遍历,一般...
  • for循环分为两种:第一种为普通for循环 这种for循环通常需要三个步骤即 for(初始表达式;条件表达式;递增表达式)有时候递增表达式也可以省去,一般是在使用Iterator迭代时(Iterator的hasNext方法判断时,可以...
  • java 8的新特性之一就是lambda表达式,其中lambda表达式的foreach循环最为引人注目,现比较下lambda表达式foreach和普通for循环的性能测试。代码如下: public static void main(String[] args){ List<...
  • 切勿用普通for循环遍历LinkedList

    千次阅读 2016-04-26 17:34:28
    ArrayList与LinkedList的普通for循环遍历 对于大部分Java程序员朋友们来说,可能平时使用得最多的List就是ArrayList,对于ArrayList的遍历,一般用如下写法: public static void main(String[] args) { List...
  • 1.增强for循环: 1 public static void main(String[] args) { 2 List<Object> list = null; 3 for(Object s : list){ 4 System.out.println("a"); 5 ...
  • @Test public void test3(){ String[] str =new String[]{"AA","BB","MM"};... for(int i=0;i;i++){ str[i]=i+"";//此处将新的值赋值给str[i] } for(int i=0;i;i++){ System.out.print
  • 增强for和普通for循环遍历空数组

    千次阅读 2019-04-06 15:45:39
    好久没有碰cookie和session了,正好在进行登录操作时遇到小bug,看图
  • 作为一名前端开发,for和foreach循环遍历几乎每天都在使用,那么这两种遍历方式哪一种效率更...foreach有的也叫增强for循环,foreach其实是for循环的一个特殊简化版。注意,forEach() 对于空数组是不会执行回调函数的.
  • 测试增强for循环是否需要判断为null 例1: public static void main(String[] args) { List list = null; for(Object s : list){ System.out.println("a"); } } 例2 public static void main(St
  • 对于大部分Java程序员朋友们来说,可能平时使用得最多的List就是ArrayList,对于ArrayList的遍历,一般用如下写法: public static void main(String[] args) ... for (int i = 0; i ) { arrayL
  •  println("以下是循环遍历")  val result3=list.map(s=>{  s.split(" ")  })  result3.foreach(arr=>{  arr.foreach(println)  println("*********************")  })  println("???????????????????????...
  • 然后自己动手用常规for循环和递归来编程, 看看二者有何不同, 最后的代码如下: 虽然有点简单, 但是还是值得学习的!特别是递归的思想。 package mi; import java.util.Scanner; public class Test { public ...
  • java增强型for循环普通循环比较

    万次阅读 2016-09-30 15:17:44
     (2)对于集合类(实现了Iterable接口),增强型for循环的遍历其本质就是迭代器 iterator的遍历,和普通循环遍历相比,各自有自己适用的场景,比如说普通for循环比较适合List类(数组类)遍历通过下标查找数据的,而
  • 增强型的for循环 和普通for循环一样 增强型的for循环 优点主要体现在集合中,随便举个例子 比如对 set 的遍历 一般是迭代遍历
  • Parallel.For循环普通for循环

    千次阅读 2018-10-17 10:46:24
    前两天看书发现了一个新的循环Parallel.For,这个循环循环期间可以创建多个线程并行循环,就是说循环的内容是无序的。这让我想到了我前面的牛...还有一点,如果循环里面的内容很简单,单一,建议还是使用普通for...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 278,110
精华内容 111,244
关键字:

普通for循环